alchemist/it.unibo.alchemist.model.cognitive.environments/ImageEnvironmentWithGraph

ImageEnvironmentWithGraph

class ImageEnvironmentWithGraph<T> @JvmOverloads constructor(incarnation: Incarnation<T, Euclidean2DPosition>, path: String, zoom: Double = 1.0, dx: Double = 0.0, dy: Double = 0.0, obstaclesColor: Int = Color.BLACK.rgb, roomsColor: Int = Color.BLUE.rgb) : ImageEnvironment<T> , EuclideanPhysics2DEnvironmentWithGraph<RectObstacle2D<Euclidean2DPosition>, T, ConvexPolygon, Euclidean2DPassage>

An ImageEnvironment providing an Euclidean2DNavigationGraph. The NaviGator algorithm is used to produce such graph (see generateNavigationGraph). The positions where to plant initial seeds should be specified directly in the image, marking each area of the environment with one or more pixels of a given color (defaults to blue).

Constructors

ImageEnvironmentWithGraph

constructor(incarnation: Incarnation<T, Euclidean2DPosition>, path: String, zoom: Double = 1.0, dx: Double = 0.0, dy: Double = 0.0, obstaclesColor: Int = Color.BLACK.rgb, roomsColor: Int = Color.BLUE.rgb)

Properties

globalReactions

val globalReactions: ListSet<GlobalReaction<T>>

open override val graph: Euclidean2DNavigationGraph

val nodes: ListSet<Node<T>>

@get:Nonnull

override val obstacles: List<RectObstacle2D<Euclidean2DPosition>>

open override val origin: Euclidean2DPosition

open override val shapeFactory: Euclidean2DShapeFactory

Functions

addGlobalReaction

open override fun addGlobalReaction(p0: GlobalReaction<T>)

override fun addLayer(p0: Molecule, p1: Layer<T, Euclidean2DPosition>)

override fun addNode(p0: Node<T>, p1: Euclidean2DPosition): Boolean

override fun addObstacle(@Nonnull obstacle: RectObstacle2D<Euclidean2DPosition>)

override fun addTerminator(p0: Predicate<Environment<T, Euclidean2DPosition>>)

farthestPositionReachable

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

override fun forEach(p0: Consumer<in Node<T>>)

override fun getDimensions(): Int

getDistanceBetweenNodes

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

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

@Nonnull

override fun getIncarnation(): Incarnation<T, Euclidean2DPosition>

override fun getLayer(p0: Molecule): Optional<Layer<T, Euclidean2DPosition>>

override fun getLayers(): ListSet<Layer<T, Euclidean2DPosition>>

override fun getLinkingRule(): LinkingRule<T, Euclidean2DPosition>

getNeighborhood

override fun getNeighborhood(@Nonnull p0: Node<T>): Neighborhood<T>

override fun getNodeByID(p0: Int): Node<T>

override fun getNodeCount(): Int

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

getNodesWithinRange

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

override fun getNodesWithinRange(p0: Euclidean2DPosition, p1: Double): ListSet<Node<T>>

getObstaclesInRange

@Nonnull

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

@Nonnull

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

override fun getOffset(): DoubleArray

@Nonnull

override fun getPosition(p0: Node<T>): Euclidean2DPosition

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

@Nonnull

override fun getSimulation(): Simulation<T, Euclidean2DPosition>

override fun getSize(): DoubleArray

getSizeInDistanceUnits

open override fun getSizeInDistanceUnits(): DoubleArray

hasMobileObstacles

open override fun hasMobileObstacles(): Boolean

intersectsObstacle

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

override fun isTerminated(): Boolean

@Nonnull

operator override fun iterator(): MutableIterator<Node<T>>

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

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

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

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

moveNodeToPosition

open override fun moveNodeToPosition(@Nonnull node: Node<T>, newPosition: Euclidean2DPosition)

@Nonnull

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

override fun next(p0: Double, p1: Double, p2: Double, p3: Double): Euclidean2DPosition

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

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

removeGlobalReaction

open override fun removeGlobalReaction(p0: GlobalReaction<T>)

override fun removeNode(@Nonnull p0: Node<T>)

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

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

override fun setLinkingRule(p0: LinkingRule<T, Euclidean2DPosition>)

override fun setSimulation(p0: Simulation<T, Euclidean2DPosition>)

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

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

override fun spliterator(): Spliterator<Node<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 override fun toString(): String