Package org.locationtech.jts.planargraph

Class DirectedEdge

  • All Implemented Interfaces:
    Comparable
    Direct Known Subclasses:
    LineMergeDirectedEdge
    public class DirectedEdge
extends GraphComponent
implements Comparable
    Represents a directed edge in a PlanarGraph. A DirectedEdge may or may not have a reference to a parent Edge (some applications of planar graphs may not require explicit Edge objects to be created). Usually a client using a PlanarGraph will subclass DirectedEdge to add its own application-specific data and methods.
    Version:
    1.7

    • Field Detail

      • parentEdge

        protected Edge parentEdge

      • from

        protected Node from

      • to

        protected Node to

      • edgeDirection

        protected boolean edgeDirection

      • quadrant

        protected int quadrant

      • angle

        protected double angle

    • Constructor Detail

      • DirectedEdge

        public DirectedEdge​(Node from,
                    Node to,
                    Coordinate directionPt,
                    boolean edgeDirection)
        Constructs a DirectedEdge connecting the from node to the to node.
        Parameters:
        directionPt - specifies this DirectedEdge's direction vector (determined by the vector from the from node to directionPt)
        edgeDirection - whether this DirectedEdge's direction is the same as or opposite to that of the parent Edge (if any)

    • Method Detail

      • toEdges

        public static List toEdges​(Collection dirEdges)
        Returns a List containing the parent Edge (possibly null) for each of the given DirectedEdges.

      • getEdge

        public Edge getEdge()
        Returns this DirectedEdge's parent Edge, or null if it has none.

      • setEdge

        public void setEdge​(Edge parentEdge)
        Associates this DirectedEdge with an Edge (possibly null, indicating no associated Edge).

      • getQuadrant

        public int getQuadrant()
        Returns 0, 1, 2, or 3, indicating the quadrant in which this DirectedEdge's orientation lies.

      • getDirectionPt

        public Coordinate getDirectionPt()
        Returns a point to which an imaginary line is drawn from the from-node to specify this DirectedEdge's orientation.

      • getEdgeDirection

        public boolean getEdgeDirection()
        Returns whether the direction of the parent Edge (if any) is the same as that of this Directed Edge.

      • getFromNode

        public Node getFromNode()
        Returns the node from which this DirectedEdge leaves.

      • getToNode

        public Node getToNode()
        Returns the node to which this DirectedEdge goes.

      • getCoordinate

        public Coordinate getCoordinate()
        Returns the coordinate of the from-node.

      • getAngle

        public double getAngle()
        Returns the angle that the start of this DirectedEdge makes with the positive x-axis, in radians.

      • getSym

        public DirectedEdge getSym()
        Returns the symmetric DirectedEdge -- the other DirectedEdge associated with this DirectedEdge's parent Edge.

      • setSym

        public void setSym​(DirectedEdge sym)
        Sets this DirectedEdge's symmetric DirectedEdge, which runs in the opposite direction.

      • isRemoved

        public boolean isRemoved()
        Tests whether this directed edge has been removed from its containing graph
        Specified by:
        isRemoved in class GraphComponent
        Returns:
        true if this directed edge is removed

      • compareTo

        public int compareTo​(Object obj)
        Returns 1 if this DirectedEdge has a greater angle with the positive x-axis than b", 0 if the DirectedEdges are collinear, and -1 otherwise.

        Using the obvious algorithm of simply computing the angle is not robust, since the angle calculation is susceptible to roundoff. A robust algorithm is:

        • first compare the quadrants. If the quadrants are different, it it trivial to determine which vector is "greater".
        • if the vectors lie in the same quadrant, the robust Orientation#computeOrientation(Coordinate, Coordinate, Coordinate) function can be used to decide the relative orientation of the vectors.
        Specified by:
        compareTo in interface Comparable

      • compareDirection

        public int compareDirection​(DirectedEdge e)
        Returns 1 if this DirectedEdge has a greater angle with the positive x-axis than b", 0 if the DirectedEdges are collinear, and -1 otherwise.

        Using the obvious algorithm of simply computing the angle is not robust, since the angle calculation is susceptible to roundoff. A robust algorithm is:

        • first compare the quadrants. If the quadrants are different, it it trivial to determine which vector is "greater".
        • if the vectors lie in the same quadrant, the robust Orientation#computeOrientation(Coordinate, Coordinate, Coordinate) function can be used to decide the relative orientation of the vectors.

      • print

        public void print​(PrintStream out)
        Prints a detailed string representation of this DirectedEdge to the given PrintStream.