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

ImageEnvironmentWithGraph

class ImageEnvironmentWithGraph<T> @JvmOverloads constructor(incarnation: Incarnation<T, Euclidean2DPosition>, path: String, zoom: Double, dx: Double, dy: Double, obstaclesColor: Int, roomsColor: Int) : 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

@JvmOverloads

fun <T> ImageEnvironmentWithGraph(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)

Functions

addLayer

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

addNode

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

addObstacle

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

addTerminator

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

computeActualInsertionPosition

open override fun computeActualInsertionPosition(p0: Node<T>, p1: Euclidean2DPosition): Euclidean2DPosition

farthestPositionReachable

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

node.canFit must be true for the returned position. For a better understanding of how to compute collision points with circular hitboxes see this discussion.

findMarkedRegions

open fun findMarkedRegions(color: Int, img: BufferedImage): MutableList<RectObstacle2D<Euclidean2DPosition>>

forEach

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

getDimensions

abstract fun getDimensions(): Int

getDistanceBetweenNodes

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

getHeading

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

Gets the heading of a node as a direction vector.

getIncarnation

abstract fun getIncarnation(): Optional<Incarnation<T, Euclidean2DPosition>>

getLayer

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

getLayers

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

getLinkingRule

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

getNeighborhood

abstract fun getNeighborhood(p0: Node<T>): Neighborhood<T>

getNodeByID

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

getNodeCount

abstract fun getNodeCount(): Int

getNodes

abstract fun getNodes(): ListSet<Node<T>>

getNodesWithin

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

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

getNodesWithinRange

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

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

getObstaclesInRange

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

@Nonnull

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

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

getOffset

abstract fun getOffset(): DoubleArray

getPosition

@Nonnull

abstract fun getPosition(p0: Node<T>): 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.

getSimulation

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

getSize

abstract fun getSize(): DoubleArray

getSizeInDistanceUnits

abstract fun getSizeInDistanceUnits(): DoubleArray

hasMobileObstacles

open override fun hasMobileObstacles(): Boolean

ifEngineAvailable

fun ifEngineAvailable(p0: Consumer<Simulation<T, Euclidean2DPosition>>)

includeObject

fun includeObject(p0: Euclidean2DPosition)

fun includeObject(p0: Double, p1: Double, p2: Double, p3: Double)

intersectsObstacle

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

isAllowed

override fun isAllowed(p: Euclidean2DPosition): Boolean

Checks whether a position is allowed to be occupied by a node in this environment.

isTerminated

abstract fun isTerminated(): Boolean

iterator

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

makePosition

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

Creates an euclidean position from the given coordinates.

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

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

Creates a new Euclidean2DPosition.

moveNode

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

moveNodeToPosition

open override 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.

@Nonnull

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

override 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. 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].

nodeShouldBeAdded