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

DirectedNavigationGraph

class DirectedNavigationGraph<V : Vector<V>, A : Transformation<V>, N : ConvexShape<V, A>, E>(edgeClass: Class<out E>) : BaseNavigationGraph<V, A, N, E>

A directed unweighted BaseNavigationGraph, allowing multiple edges between the same pair of vertices and without self-loops (i.e. edges connecting a node to itself).

Constructors

constructor(edgeClass: Class<out E>)

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>