alchemist/it.unibo.alchemist.model.geometry.navigationgraph/BaseNavigationGraph

BaseNavigationGraph

open class BaseNavigationGraph<V : Vector<V>, A : Transformation<V>, N : ConvexShape<V, A>, E>(vertexSupplier: Supplier<N>?, edgeSupplier: Supplier<E>?, graphType: GraphType) : AbstractBaseGraph<N, E> , NavigationGraph<V, A, N, E>

An implementation of NavigationGraph, deriving from AbstractBaseGraph. The user can specify the GraphType so as to obtain a custom graph (e.g. weighted or not, directed or undirected, etc). AbstractBaseGraph guarantees deterministic ordering for the collection it maintains, as stated in its api documentation. Note that vertices and edges are used as keys inside AbstractBaseGraph, so when choosing their types, you must follow these rules:

You must follow the contract defined in java.lang.Object for both equals and hashCode.
In particular, if you override either equals or hashCode, you must override them both.
Your implementation for hashCode must produce a value which does not change over the lifetime of the object. Further information available here.

Inheritors

DirectedNavigationGraph

UndirectedNavigationGraph

Constructors

BaseNavigationGraph

constructor(edgeClass: Class<out E>, directed: Boolean)

constructor(vertexSupplier: Supplier<N>?, edgeSupplier: Supplier<E>?, graphType: GraphType)

Properties

edgeSupplier

var edgeSupplier: Supplier<E>

type

val type: GraphType

vertexSupplier

var vertexSupplier: Supplier<N>

Functions

addEdge

open override fun addEdge(p0: N, p1: N): E

open override fun addEdge(p0: N, p1: N, p2: E): Boolean

addVertex

open override fun addVertex(): N

open override fun addVertex(p0: N): Boolean

clone

open override fun clone(): Any

containsEdge

open override fun containsEdge(p0: E): Boolean

open override fun containsEdge(p0: N, p1: N): Boolean

containsVertex

open override fun containsVertex(p0: N): Boolean

degreeOf

open override fun degreeOf(p0: N): Int

edgeSet

open override fun edgeSet(): MutableSet<E>

edgesOf

open override fun edgesOf(p0: N): MutableSet<E>

equals

open operator override fun equals(other: Any?): Boolean

getAllEdges

open override fun getAllEdges(p0: N, p1: N): MutableSet<E>

getEdge

open override fun getEdge(p0: N, p1: N): E

getEdgeSource

open override fun getEdgeSource(p0: E): N

getEdgeTarget

open override fun getEdgeTarget(p0: E): N

getEdgeWeight

open override fun getEdgeWeight(p0: E): Double

hashCode

open override fun hashCode(): Int

incomingEdgesOf

open override fun incomingEdgesOf(p0: N): MutableSet<E>

inDegreeOf

open override fun inDegreeOf(p0: N): Int

iterables

open override fun iterables(): GraphIterables<N, E>

nodeContaining

open fun nodeContaining(position: V): N?

outDegreeOf

open override fun outDegreeOf(p0: N): Int

outgoingEdgesOf

open override fun outgoingEdgesOf(p0: N): MutableSet<E>

pathExists

fun <V> Graph<V, *>.pathExists(source: V, sink: V): Boolean

Checks whether a path exists between source and sink. DijkstraShortestPath is used instead of org.jgrapht.alg.connectivity.ConnectivityInspector.pathExists, because, in case of directed graph, the latter checks whether the given vertices lay in the same weakly connected component, which is not the desired behavior. As unweighted graphs have a default edge weight of 1.0, shortest path algorithms can always be applied meaningfully.

removeAllEdges

open override fun removeAllEdges(p0: MutableCollection<out E>): Boolean

open override fun removeAllEdges(p0: N, p1: N): MutableSet<E>

removeAllVertices

open override fun removeAllVertices(p0: MutableCollection<out N>): Boolean

removeEdge

open override fun removeEdge(p0: E): Boolean

open override fun removeEdge(p0: N, p1: N): E

removeVertex

open override fun removeVertex(p0: N): Boolean

setEdgeWeight

open fun setEdgeWeight(p0: N, p1: N, p2: Double)

open override fun setEdgeWeight(p0: E, p1: Double)

toString

open override fun toString(): String

vertexSet

open override fun vertexSet(): MutableSet<N>