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

ImageEnvironment

open class ImageEnvironment<T> : Continuous2DObstacles<T>

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

Parameters

<T>

concentration type

Constructors

ImageEnvironment

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

val DEFAULT_COLOR: Int

Default color to be parsed as obstacle.

DEFAULT_DELTA_X

val DEFAULT_DELTA_X: Double = 0.0

Default X starting position.

DEFAULT_DELTA_Y

val DEFAULT_DELTA_Y: Double = 0.0

Default Y starting position.

val DEFAULT_ZOOM: Double = 1.0

Default zoom level.

globalReactions

val globalReactions: ListSet<GlobalReaction<T>>

open val incarnation: Incarnation<T, P>

val nodes: ListSet<Node<T>>

val shapeFactory: Euclidean2DShapeFactory

A factory of shapes compatible with this environment.

open var simulation: Simulation<T, P>

Functions

addGlobalReaction

open fun addGlobalReaction(p: GlobalReaction<T>)

fun addLayer(p: Molecule, p1: Layer<T, P>)

fun addNode(p: Node<T>, p1: P): Boolean

abstract fun addObstacle(p: W)

fun addObstacle(@Nonnull o: RectObstacle2D<Euclidean2DPosition>)

fun addTerminator(p: Predicate<Environment<T, P>>)

farthestPositionReachable

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.

fun forEach(p: Consumer<in Node<T>>)

fun getDimensions(): Int

getDistanceBetweenNodes

fun getDistanceBetweenNodes(p: Node<T>, p1: Node<T>): Double

abstract fun getHeading(node: Node<T>): P

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

Gets the heading of a node as a direction vector.

fun getLayer(p: Molecule): Optional<Layer<T, P>>

fun getLayers(): ListSet<Layer<T, P>>

fun getLinkingRule(): LinkingRule<T, P>

getNeighborhood

fun getNeighborhood(p: Node<T>): Neighborhood<T>

fun getNodeByID(p: Int): Node<T>

fun getNodeCount(): Int

open fun getNodesWithin(shape: Shape<Euclidean2DPosition, Euclidean2DTransformation>): List<Node<T>>

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

getNodesWithinRange

fun getNodesWithinRange(p: Node<T>, p1: Double): ListSet<Node<T>>

abstract fun getObstacles(): List<W>

@Nonnull

fun getObstacles(): List<RectObstacle2D<Euclidean2DPosition>>

getObstaclesInRange

abstract fun getObstaclesInRange(p: Euclidean2DPosition, p1: Double): List<W>

@Nonnull

fun getObstaclesInRange(@Nonnull center: Euclidean2DPosition, range: Double): List<RectObstacle2D<Euclidean2DPosition>>

@Nonnull

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

fun getOffset(): Array<Double>

open fun getOrigin(): P

open fun getOrigin(): Euclidean2DPosition

fun getPosition(p: Node<T>): P

abstract fun getShape(node: Node<T>): Shape<P, A>

open fun getShape(node: Node<T>): Shape<Euclidean2DPosition, Euclidean2DTransformation>

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

getShapeFactory

abstract fun getShapeFactory(): F

A factory of shapes compatible with this environment.

fun getSize(): Array<Double>

getSizeInDistanceUnits

open fun getSizeInDistanceUnits(): Array<Double>

hasMobileObstacles

abstract fun hasMobileObstacles(): Boolean

open fun hasMobileObstacles(): Boolean

Subclasses dealing with mobile obstacles may change this.

intersectsObstacle

abstract fun intersectsObstacle(p: P, p1: P): Boolean

fun intersectsObstacle(start: Euclidean2DPosition, end: Euclidean2DPosition): Boolean

fun isTerminated(): Boolean

fun iterator(): Iterator<Node<T>>

abstract fun iterator(): Iterator<T>

abstract fun makePosition(p: Array<Number>): P

open fun makePosition(p: Double, p1: Double): Euclidean2DPosition

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

Creates an euclidean position from the given coordinates.

open fun moveNode(p: Node<T>, p1: P)

moveNodeToPosition

open fun moveNodeToPosition(p: Node<T>, p1: P)

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(@Nonnull node: Node<T>, newPos: Euclidean2DPosition)

Moves the node to the farthestPositionReachable towards the desired newPosition.

abstract fun next(p: P, p1: P): P

@Nonnull

fun next(@Nonnull current: Euclidean2DPosition, @Nonnull desired: Euclidean2DPosition): Euclidean2DPosition

fun next(ox: Double, oy: Double, nx: Double, ny: Double): Euclidean2DPosition

This method must calculate the ABSOLUTE next allowed position given the current position and the position in which the node wants to move.

fun <R> Iterable<R>.randomElement(randomGenerator: RandomGenerator): R

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

removeGlobalReaction

open fun removeGlobalReaction(p: GlobalReaction<T>)

fun removeNode(p: Node<T>)

abstract fun removeObstacle(p: W): Boolean

fun removeObstacle(@Nonnull o: RectObstacle2D<Euclidean2DPosition>): Boolean

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

Sets the heading of a node.

fun setLinkingRule(p: LinkingRule<T, P>)

fun <R> Iterable<R>.shuffled(randomGenerator: RandomGenerator): Iterable<R>

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

fun spliterator(): Spliterator<Node<T>>

open fun spliterator(): Spliterator<T>

subscriptionMonitor

fun <T, P : Position<out P>> Environment<T, P>.subscriptionMonitor(): EnvironmentSubscriptionMonitor<T, P>

Returns the EnvironmentSubscriptionMonitor of this Environment.

toGraphQLEnvironmentSurrogate

fun <T, P : Position<out P>> Environment<T, P>.toGraphQLEnvironmentSurrogate(): EnvironmentSurrogate<T, P>

Converts an Environment to a EnvironmentSurrogate.

open fun toString(): String