alchemist/it.unibo.alchemist.model.maps.environments/OSMEnvironment

OSMEnvironment

class OSMEnvironment<T> : Abstract2DEnvironment<T, P> , MapEnvironment<T, O, S>

This class serves as template for more specific implementations of environments using a map. It encloses the navigation logic, but leaves the subclasses to decide how to provide map data (e.g. loading from disk or rely on online services). The data is then stored in-memory for performance reasons.

Parameters

<T>

concentration type

Constructors

OSMEnvironment

constructor(incarnation: Incarnation<T, GeoPosition>)

Builds a new OSMEnvironment without an actual backing map.

constructor(incarnation: Incarnation<T, GeoPosition>, file: String)

Builds a new OSMEnvironment, with nodes not forced on streets.

constructor(incarnation: Incarnation<T, GeoPosition>, file: String, onStreets: Boolean)

constructor(incarnation: Incarnation<T, GeoPosition>, file: String, onStreets: Boolean, onlyOnStreets: Boolean)

constructor(incarnation: Incarnation<T, GeoPosition>, file: String, approximation: Int)

constructor(incarnation: Incarnation<T, GeoPosition>, file: String, approximation: Int, onStreets: Boolean, onlyOnStreets: Boolean)

Properties

DEFAULT_APPROXIMATION

val DEFAULT_APPROXIMATION: Int = 0

The default value for approximating the positions comparison.

DEFAULT_FORCE_STREETS

val DEFAULT_FORCE_STREETS: Boolean = false

The default value for the discard of nodes too far from streets option.

DEFAULT_ON_STREETS

val DEFAULT_ON_STREETS: Boolean = true

The default value for the force nodes on streets option.

globalReactions

val globalReactions: ListSet<GlobalReaction<T>>

incarnation

open val incarnation: Incarnation<T, P>

nodes

val nodes: ListSet<Node<T>>

simulation

open var simulation: Simulation<T, P>

Functions

addGlobalReaction

abstract fun addGlobalReaction(reaction: GlobalReaction<T>)

Add a GlobalReaction to the Environment.

open fun addGlobalReaction(reaction: GlobalReaction<T>)

Add a GlobalReaction to the Environment.

addLayer

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.

addNode

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.

addTerminator

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.

computeRoute

open fun computeRoute(p1: GeoPosition, p2: GeoPosition): Route<GeoPosition>

open fun computeRoute(node: Node<T>, coord: GeoPosition): Route<GeoPosition>

open fun computeRoute(node: Node<T>, node2: Node<T>): Route<GeoPosition>

open fun computeRoute(from: GeoPosition, to: GeoPosition, options: GraphHopperOptions): Route<GeoPosition>

open fun computeRoute(node: Node<T>, coord: GeoPosition, options: GraphHopperOptions): Route<GeoPosition>

This method relies on the map data, and computes a route towards some absolute coordinate solving a TSP problem.

enableBenchmark

open fun enableBenchmark()

Call this method to tell this environment that it should record its performances.

forEach

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

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

getBenchmarkResult

open fun getBenchmarkResult(): Double

getDimensions

abstract fun getDimensions(): Int

The number of dimensions of this environment.

fun getDimensions(): Int

The number of dimensions of this environment.

getDistanceBetweenNodes

abstract fun getDistanceBetweenNodes(n1: Node<T>, n2: Node<T>): Double

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

fun getDistanceBetweenNodes(n1: Node<T>, n2: Node<T>): Double

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

getGlobalReactions

abstract fun getGlobalReactions(): NonExistentClass

Get the Environment's GlobalReactions.

getIncarnation

abstract fun getIncarnation(): Incarnation<T, P>

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

getLayer

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.

getLayers

abstract fun getLayers(): NonExistentClass

Return all the Layers in this Environment.

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

Return all the Layers in this Environment.

getLinkingRule

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

Returns the current LinkingRule.

fun getLinkingRule(): LinkingRule<T, P>

Returns the current LinkingRule.

getNeighborhood

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

Given a node, this method returns its neighborhood.

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

Given a node, this method returns its neighborhood.

getNodeByID

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.

getNodeCount

abstract fun getNodeCount(): Int

Returns the number of Nodes currently in the Environment.

fun getNodeCount(): Int

Returns the number of Nodes currently in the Environment.

getNodes

abstract fun getNodes(): NonExistentClass

Returns all the Nodes that exist in current Environment.

getNodesWithinRange

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.

getOffset

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.

fun getOffset(): Array<Double>

This method allows to know which are the smallest coordinates represented.

getPosition

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.

getRoutingService

open fun getRoutingService(): GraphHopperRoutingService

getSimulation

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

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

getSimulationOrNull

abstract fun getSimulationOrNull(): Simulation<T, P>

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

open fun getSimulationOrNull(): Simulation<T, P>

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

getSize

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.

fun getSize(): Array<Double>

The size of the environment as an array of length getDimensions().

getSizeInDistanceUnits

open fun getSizeInDistanceUnits(): Array<Double>

Override this method if units measuring distance do not match with units used for coordinates.

isTerminated

abstract fun isTerminated(): Boolean

Return true if all the terminators are true.

fun isTerminated(): Boolean

Return true if all the terminators are true.

iterator

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

abstract fun iterator(): Iterator<T>

makePosition

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

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

moveNodeToPosition

abstract fun moveNodeToPosition(node: Node<T>, position: P)

This method moves a node in the environment to some position. If node move is unsupported, it does nothing.

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.

randomElement

fun <R> Iterable<R>.randomElement(randomGenerator: <Error class: unknown class>): R

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

removeGlobalReaction

abstract fun removeGlobalReaction(reaction: GlobalReaction<T>)

Remove a GlobalReaction from the Environment.

open fun removeGlobalReaction(reaction: GlobalReaction<T>)

Remove a GlobalReaction from the Environment.

removeNode

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.

setLinkingRule

abstract fun setLinkingRule(<set-?>: LinkingRule<T, P>)

Returns the current LinkingRule.

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

Returns the current LinkingRule.

setSimulation

abstract fun setSimulation(<set-?>: Simulation<T, P>)

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

shuffled

fun <R> Iterable<R>.shuffled(randomGenerator: <Error class: unknown class>): Iterable<R>

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

spliterator

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.

toEnvironmentSurrogate

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).

toGraphQLEnvironmentSurrogate

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

Converts an Environment to a EnvironmentSurrogate.

toString

open fun toString(): String

Not used internally.