alchemist-physics/it.unibo.alchemist.model.physics.environments/Continuous2DObstacles

Continuous2DObstacles

open class Continuous2DObstacles<T>(incarnation: Incarnation<T, Euclidean2DPosition>) : AbstractLimitedContinuous2D<T> , EuclideanPhysics2DEnvironmentWithObstacles<RectObstacle2D<Euclidean2DPosition>, T> (source)

A 2D continuous environment that supports rectangular obstacles and prevents nodes from moving through them.

Parameters

incarnation

the incarnation used to build nodes and concentrations

Type Parameters

the concentration type

Inheritors

ImageEnvironment

Constructors

Continuous2DObstacles

constructor(incarnation: Incarnation<T, Euclidean2DPosition>)

Properties

currentPosition

open val Node<T>.currentPosition: Euclidean2DPosition

dimensions

override val dimensions: Int

incarnation

override val incarnation: Incarnation<T, Euclidean2DPosition>

isTerminated

open override val isTerminated: Boolean

layers

override val layers: Map<Molecule, Layer<T, Euclidean2DPosition>>

neighborhood

open val Node<T>.neighborhood: Observable<Neighborhood<T>>

networkModel

override var networkModel: NetworkModel<T>

nodeCount

override val nodeCount: Observable<Int>

nodes

open override val nodes: ObservableList<Node<T>>

obstacles

open override val obstacles: List<RectObstacle2D<Euclidean2DPosition>>

offset

override val offset: DoubleArray

origin

open override val origin: Euclidean2DPosition

position

open val Node<T>.position: Observable<Euclidean2DPosition>

reactions

open override val reactions: ObservableList<Reaction<T>>

shapeFactory

open override val shapeFactory: Euclidean2DShapeFactory

A factory of shapes compatible with this environment.

simulation

override var simulation: Simulation<T, Euclidean2DPosition>

simulationOrNull

override var simulationOrNull: Simulation<T, Euclidean2DPosition>?

size

override val size: DoubleArray

sizeInDistanceUnits

open override val sizeInDistanceUnits: DoubleArray

Functions

addLayer

open override fun addLayer(molecule: Molecule, layer: Layer<T, Euclidean2DPosition>)

addNode

open override fun addNode(node: Node<T>, position: Euclidean2DPosition): Boolean

addObstacle

open override fun addObstacle(obstacle: RectObstacle2D<Euclidean2DPosition>)

addReaction

open override fun addReaction(reaction: Reaction<T>)

addTerminator

open fun addTerminator(terminator: (Environment<T, Euclidean2DPosition>) -> Boolean)

open override fun addTerminator(terminator: TerminationPredicate<T, Euclidean2DPosition>)

contains

open operator override fun contains(node: Node<T>): Boolean

currentPositionOf

open override fun currentPositionOf(node: Node<T>): Euclidean2DPosition

distanceBetween

open override fun distanceBetween(n1: Node<T>, n2: Node<T>): Double

distanceTo

open fun Node<T>.distanceTo(other: Node<T>): Double

farthestReachablePosition

open override fun farthestReachablePosition(node: Node<T>, desired: Euclidean2DPosition): Euclidean2DPosition

The farthest position reachable by node towards desired, stopping before the first obstacle on its path.

getHeading

open override fun getHeading(node: Node<T>): Euclidean2DPosition

Gets the heading of a node as a direction vector.

getNodesWithin

open override fun getNodesWithin(shape: Euclidean2DShape): List<Node<T>>

Gets all nodes whose shape.intersect is true for the given shape.

getObstaclesInRange

open override fun getObstaclesInRange(center: Euclidean2DPosition, range: Double): List<RectObstacle2D<Euclidean2DPosition>>

open override fun getObstaclesInRange(centerx: Double, centery: Double, range: Double): List<RectObstacle2D<Euclidean2DPosition>>

getShape

open override fun getShape(node: Node<T>): Euclidean2DShape

Gets the shape of a node relatively to its position and heading in the environment.

hasMobileObstacles

open override fun hasMobileObstacles(): Boolean

layerFor

open override fun layerFor(molecule: Molecule): Layer<T, Euclidean2DPosition>?

makePosition

open fun makePosition(coordinates: DoubleArray): Euclidean2DPosition

open fun makePosition(coordinates: List<Number>): Euclidean2DPosition

open fun makePosition(x: Double, y: Double): Euclidean2DPosition

open fun makePosition(x: Number, y: Number): Euclidean2DPosition

open override fun makePosition(vararg coordinates: Number): Euclidean2DPosition

Creates an euclidean position from the given coordinates.

moveBy

open fun Node<T>.moveBy(displacement: Euclidean2DPosition)

moveNodeBy

open fun moveNodeBy(node: Node<T>, displacement: Euclidean2DPosition)

moveNodeTo

open override fun moveNodeTo(node: Node<T>, position: Euclidean2DPosition)

moveTo

open fun Node<T>.moveTo(position: Euclidean2DPosition)

neighborhoodOf

open override fun neighborhoodOf(node: Node<T>): Observable<Neighborhood<T>>

nodesAround

open override fun nodesAround(position: Euclidean2DPosition, range: Double): List<Node<T>>

open override fun nodesAround(node: Node<T>, range: Double): List<Node<T>>

nodesInRange

open fun Euclidean2DPosition.nodesInRange(range: Double): List<Node<T>>

open fun Node<T>.nodesInRange(range: Double): List<Node<T>>

nodeWithId

open override fun nodeWithId(id: Int): Node<T>

observeLayerValue

open override fun observeLayerValue(molecule: Molecule, node: Node<T>): Observable<T?>

observeNodesAround

open override fun observeNodesAround(position: Euclidean2DPosition, range: Double): ObservableSet<Node<T>>

open override fun observeNodesAround(node: Node<T>, range: Double): ObservableSet<Node<T>>

observeNodesInRange

open fun Euclidean2DPosition.observeNodesInRange(range: Double): ObservableSet<Node<T>>

open fun Node<T>.observeNodesInRange(range: Double): ObservableSet<Node<T>>

positionOf

open override fun positionOf(node: Node<T>): Observable<Euclidean2DPosition>

remove

open fun Node<T>.remove()

open fun RectObstacle2D<Euclidean2DPosition>.remove(): Boolean

open fun Reaction<T>.remove()

removeNode

open override fun removeNode(node: Node<T>)

removeObstacle

open override fun removeObstacle(obstacle: RectObstacle2D<Euclidean2DPosition>): Boolean

removeReaction

open override fun removeReaction(reaction: Reaction<T>)

setHeading

open override fun setHeading(node: Node<T>, direction: Euclidean2DPosition)

Sets the heading of a node.

shortestPathIntersectsObstacle

open override fun shortestPathIntersectsObstacle(start: Euclidean2DPosition, end: Euclidean2DPosition): Boolean

shortestPathToIntersectsObstacle

open fun Euclidean2DPosition.shortestPathToIntersectsObstacle(other: Euclidean2DPosition): Boolean

toPosition

open fun DoubleArray.toPosition(): Euclidean2DPosition

toString

open override fun toString(): String