ImageEnvironment

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

Parameters

<T>

concentration type

Inheritors

Constructors

Link copied to clipboard
constructor(incarnation: Incarnation<T, Euclidean2DPosition>, path: String)
constructor(incarnation: Incarnation<T, Euclidean2DPosition>, path: String, zoom: Double)
constructor(incarnation: Incarnation<T, Euclidean2DPosition>, path: String, zoom: Double, dx: Double, dy: Double)
constructor(incarnation: Incarnation<T, Euclidean2DPosition>, obstacleColor: Int, path: String, zoom: Double, dx: Double, dy: Double)

Properties

Link copied to clipboard
Default color to be parsed as obstacle.
Link copied to clipboard
Default X starting position.
Link copied to clipboard
Default Y starting position.
Link copied to clipboard
val DEFAULT_ZOOM: Double = 1.0
Default zoom level.
Link copied to clipboard
val globalReactions: ListSet<GlobalReaction<T>>
Link copied to clipboard
Link copied to clipboard
val nodes: ListSet<Node<T>>
Link copied to clipboard

A factory of shapes compatible with this environment.

Link copied to clipboard
open var simulation: Simulation<T, P>

Functions

Link copied to clipboard
abstract fun addGlobalReaction(reaction: GlobalReaction<T>)
open fun addGlobalReaction(reaction: GlobalReaction<T>)
Link copied to clipboard
abstract fun addLayer(molecule: Molecule, layer: Layer<T, P>)

Add a Layer to the Environment.

fun addLayer(molecule: Molecule, layer: Layer<T, P>)
Add a Layer to the Environment.
Link copied to clipboard
abstract fun addNode(node: Node<T>, position: P): Boolean

This method allows to add a new node to this environment in a specific position. The environment is responsible to call the right method of the simulation in order to ensure that the reaction is properly scheduled. The function returns true if the node is added to the environment.

fun addNode(node: Node<T>, p: P): Boolean
This method allows to add a new node to this environment in a specific position.
Link copied to clipboard
abstract fun addObstacle(obstacle: W)

Adds an obstacle to this environment.

Adds an obstacle to this environment.
Link copied to clipboard
abstract fun addTerminator(terminator: TerminationPredicate<T, P>)

Add a terminator indicating whether the simulation should be considered finished.

open fun addTerminator(terminator: TerminationPredicate<T, P>)
Adds to the simulation a predicate that determines whether a simulation should be terminated.
Link copied to clipboard
abstract fun farthestPositionReachable(node: Node<T>, desiredPosition: P, hitboxRadius: Double): P

Computes the farthest position reachable by a node towards a desiredPosition, avoiding node overlapping. If no node is located in between, desiredPosition is returned. Otherwise, the first position where the node collides with someone else is returned. For collision purposes, hitboxes are used: each node is given a circular hitbox of radius equal to its shape's radius (shapeless nodes can't cause overlapping). The client can specify a different radius for the hitbox of the moving node.

open fun farthestPositionReachable(node: Node<T>, desiredPosition: Euclidean2DPosition, hitboxRadius: Double): Euclidean2DPosition

Computes the farthest position reachable by a node towards a desiredPosition, avoiding node overlapping. If no node is located in between, desiredPosition is returned. Otherwise, the first position where the node collides with someone else is returned. For collision purposes, hitboxes are used: each node is given a circular hitbox of radius equal to its shape's radius (shapeless nodes can't cause overlapping). The client can specify a different radius for the hitbox of the moving node.

Link copied to clipboard
fun forEach(action: Consumer<in Node<T>>)
open fun forEach(p: Consumer<in T>)
Link copied to clipboard
abstract fun getDimensions(): Int

The number of dimensions of this environment.

The number of dimensions of this environment.
Link copied to clipboard
abstract fun getDistanceBetweenNodes(n1: Node<T>, n2: Node<T>): Double

Measures the distance between two nodes (n1, n2) in the environment.

Measures the distance between two nodes (n1, n2) in the environment.
Link copied to clipboard
abstract fun getGlobalReactions(): NonExistentClass
Link copied to clipboard
abstract fun getHeading(node: Node<T>): P
open fun getHeading(node: Node<T>): NonExistentClass

Gets the heading of a node as a direction vector.

Link copied to clipboard
abstract fun getIncarnation(): Incarnation<T, P>

Return the Incarnation used to initialize the entities of this Environment, if it has been set.

Link copied to clipboard
abstract fun getLayer(molecule: Molecule): Layer<T, P>

Get the Layer associate to the given molecule. If no Layer is associated with the given molecule, return null.

fun getLayer(molecule: Molecule): Layer<T, P>
Get the Layer associate to the given molecule.
Link copied to clipboard
abstract fun getLayers(): NonExistentClass

Return all the Layers in this Environment.

fun getLayers(): ListSet<Layer<T, P>>
Return all the Layers in this Environment.
Link copied to clipboard
abstract fun getLinkingRule(): LinkingRule<T, P>

Returns the current LinkingRule.

Returns the current LinkingRule.
Link copied to clipboard
abstract fun getNeighborhood(node: Node<T>): Neighborhood<T>

Given a node, this method returns its neighborhood.

Given a node, this method returns its neighborhood.
Link copied to clipboard
abstract fun getNodeByID(id: Int): Node<T>

Allows to access a Node in this Environment known its id. Depending on the implementation, this method may or not be optimized (namely, id could run in constant or linear time with the number of nodes).

fun getNodeByID(id: Int): Node<T>
Allows to access a Node in this Environment known its id.
Link copied to clipboard
abstract fun getNodeCount(): Int

Returns the number of Nodes currently in the Environment.

Returns the number of Nodes currently in the Environment.
Link copied to clipboard
abstract fun getNodes(): NonExistentClass

Returns all the Nodes that exist in current Environment.

Link copied to clipboard

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

Link copied to clipboard
abstract fun getNodesWithinRange(node: Node<T>, range: Double): NonExistentClass

Given a node this method returns a list of all the surroundings nodes within the given range. Note that this method (depending on the implementation) might be not optimized, and it's consequently much better to use Environment.getNeighborhood and filter the neighborhood if you are sure that all the nodes within the range are connected to the center.

fun getNodesWithinRange(position: P, range: Double): ListSet<Node<T>>
Given a position this method returns a list of all the surroundings nodes within the given range.
fun getNodesWithinRange(node: Node<T>, range: Double): ListSet<Node<T>>
Given a node this method returns a list of all the surroundings nodes within the given range.
Link copied to clipboard
abstract fun getObstacles(): List<W>

A list of all the obstacles in this environment.

A list of all the obstacles in this environment.
Link copied to clipboard
abstract fun getObstaclesInRange(center: Euclidean2DPosition, range: Double): List<W>

Given a point and a range, retrieves all the obstacles within.

Given a point and a range, retrieves all the obstacles within.
Link copied to clipboard
abstract fun getOffset(): Array<Double>

This method allows to know which are the smallest coordinates represented. Return an array of length dimensions containing the smallest coordinates for each dimension.

This method allows to know which are the smallest coordinates represented.
Link copied to clipboard
open fun getOrigin(): P

Create a position corresponding to the origin of this environment.

Link copied to clipboard
abstract fun getPosition(node: Node<T>): P

Calculates the position of a node.

fun getPosition(node: Node<T>): P
Calculates the position of a node.
Link copied to clipboard
abstract fun getShape(node: Node<T>): Shape<P, A>

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

Link copied to clipboard
abstract fun getShapeFactory(): F

A factory of shapes compatible with this environment.

Link copied to clipboard
abstract fun getSimulation(): Simulation<T, P>

Return the current Simulation, if present, or throws an IllegalStateException otherwise.

Link copied to clipboard
abstract fun getSimulationOrNull(): Simulation<T, P>

Return the current Simulation, if present, or null otherwise.

Return the current Simulation, if present, or null otherwise.
Link copied to clipboard
abstract fun getSize(): Array<Double>

The size of the environment as an array of length getDimensions(). This method must return distance measured with the same unit used by the positions. No non-euclidean distance metrics are allowed.

The size of the environment as an array of length getDimensions().
Link copied to clipboard

This method returns the size of the environment as an array of length .getDimensions. This method must return distance measured with the same unit used for measuring distances. It may or may not return the same result of .getSize.

Override this method if units measuring distance do not match with units used for coordinates.
Link copied to clipboard
abstract fun hasMobileObstacles(): Boolean

Subclasses dealing with mobile obstacles may change this.
Link copied to clipboard
abstract fun intersectsObstacle(start: P, end: P): Boolean

Checks whether there is at least an obstacle intersecting the line connecting start and end.

Checks whether there is at least an obstacle intersecting the line connecting start and end.
Link copied to clipboard
abstract fun isTerminated(): Boolean

Return true if all the terminators are true.

Return true if all the terminators are true.
Link copied to clipboard
abstract fun iterator(): Iterator<T>
Link copied to clipboard
abstract fun makePosition(coordinates: Array<Number>): P

Given the coordinates of the point, returns a Position compatible with this environment.

Creates a new Euclidean2DPosition.

open fun makePosition(coordinates: Array<Number>): NonExistentClass

Creates an euclidean position from the given coordinates.

Link copied to clipboard
open fun moveNode(node: Node<T>, direction: P)

This method moves a node in the environment toward some direction. If node move is unsupported, it does nothing. Subclasses may override this method if they want to change the way a node moves towards some direction. The current implementation internally calls {@link #moveNodeToPosition(Node, Position2D)}, as such, overriding that method may suffice.

Link copied to clipboard
open fun moveNodeToPosition(node: Node<T>, newpos: P)
Subclasses may override this method if they want to change the way a node moves towards some absolute position.
open fun moveNodeToPosition(node: Node<T>, newPosition: Euclidean2DPosition)

Moves the node to the farthestPositionReachable towards the desired newPosition. If the node is shapeless, it is simply moved to newPosition.

open fun moveNodeToPosition(node: Node<T>, newPos: Euclidean2DPosition)
Moves the node to the farthestPositionReachable towards the desired newPosition.
Link copied to clipboard
abstract fun next(current: P, desired: P): P

This method must calculate the ABSOLUTE next allowed position given the current position and the position in which the node wants to move. For example, if your node is in position 2,3, wants to move to 3,4 but the next allowed position (because, e.g., of physical obstacles) is 2.5,3.5, the result must be a Position containing coordinates 2.5,3.5.

This method must calculate the ABSOLUTE next allowed position given the current position and the position in which the node wants to move.
Link copied to clipboard
fun <R> Iterable<R>.randomElement(randomGenerator: <Error class: unknown class>): R

Returns a random element of the Iterable using the provided randomGenerator.

Link copied to clipboard
abstract fun removeGlobalReaction(reaction: GlobalReaction<T>)

Remove a GlobalReaction from the Environment.

Remove a GlobalReaction from the Environment.
Link copied to clipboard
abstract fun removeNode(node: Node<T>)

This method allows to remove a node. If node removal is unsupported, it does nothing.

fun removeNode(node: Node<T>)
This method allows to remove a node.
Link copied to clipboard
abstract fun removeObstacle(obstacle: W): Boolean

Removes an obstacle from this environment.

Removes an obstacle from this environment.
Link copied to clipboard
open fun setHeading(node: Node<T>, direction: Euclidean2DPosition)

Sets the heading of a node.

Link copied to clipboard
abstract fun setLinkingRule(<set-?>: LinkingRule<T, P>)

Returns the current LinkingRule.

Returns the current LinkingRule.
Link copied to clipboard
abstract fun setSimulation(<set-?>: Simulation<T, P>)

Return the current Simulation, if present, or throws an IllegalStateException otherwise.

Link copied to clipboard
fun <R> Iterable<R>.shuffled(randomGenerator: <Error class: unknown class>): Iterable<R>

Fisher–Yates shuffle algorithm using a RandomGenerator. More information on Wikipedia.

Link copied to clipboard
Link copied to clipboard
fun <T, P : Position<out P>, TS : Any> Environment<T, P>.toEnvironmentSurrogate(toConcentrationSurrogate: (T) -> TS): EnvironmentSurrogate<TS, PositionSurrogate>

A function that maps an Environment to its surrogate class (EnvironmentSurrogate). Use the toSuitablePositionSurrogate strategy for PositionSurrogate mapping.

fun <T, P : Position<out P>, TS : Any, PS : PositionSurrogate> Environment<T, P>.toEnvironmentSurrogate(toConcentrationSurrogate: (T) -> TS, toPositionSurrogate: (P) -> PS): EnvironmentSurrogate<TS, PS>

A function that maps an Environment to its surrogate class (EnvironmentSurrogate).

Link copied to clipboard
open fun toString(): String
Not used internally.