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

ImageEnvironment

open class ImageEnvironment<T> @JvmOverloads constructor(incarnation: Incarnation<T, Euclidean2DPosition>, path: String, zoom: Double = DEFAULT_ZOOM, dx: Double = DEFAULT_DELTA_X, dy: Double = DEFAULT_DELTA_Y, obstacleColor: Int = DEFAULT_COLOR) : Continuous2DObstacles<T> (source)

This environment loads an image from the classpath or the file system, and marks as obstacles all the pixels of a given color.

Parameters

incarnation

the incarnation to be used.

path

the path where to load the image from: a classpath resource or a local file path.

zoom

zoom level.

delta X position.

delta Y position.

obstacleColor

integer representing the RGB color of the obstacles in the image, encoded as in Color.getRGB.

Type Parameters

concentration type

Throws

IOException

if the image cannot be read.

Constructors

ImageEnvironment

@JvmOverloads

constructor(incarnation: Incarnation<T, Euclidean2DPosition>, path: String, zoom: Double = DEFAULT_ZOOM, dx: Double = DEFAULT_DELTA_X, dy: Double = DEFAULT_DELTA_Y, obstacleColor: Int = DEFAULT_COLOR)

Types

Companion

object Companion

Default values for the ImageEnvironment parameters.

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