com.revolsys.jts.geomgraph

Class EdgeEnd

java.lang.Object

com.revolsys.jts.geomgraph.EdgeEnd

All Implemented Interfaces:

Comparable

Direct Known Subclasses:

DirectedEdge, EdgeEndBundle

public class EdgeEnd
extends Object
implements Comparable

Models the end of an edge incident on a node. EdgeEnds have a direction determined by the direction of the ray from the initial point to the next point. EdgeEnds are comparable under the ordering "a has a greater angle with the x-axis than b". This ordering is used to sort EdgeEnds around a node.

Version:

1.7

Field Summary

Fields

Modifier and Type	Field and Description
protected Edge	edge

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	EdgeEnd(Edge edge)
	EdgeEnd(Edge edge, Point p0, Point p1)
	EdgeEnd(Edge edge, Point p0, Point p1, Label label)

Method Summary

Methods

Modifier and Type	Method and Description
int	compareDirection(EdgeEnd e) Implements the total order relation:
int	compareTo(Object obj)
void	computeLabel(BoundaryNodeRule boundaryNodeRule)
Point	getCoordinate()
Point	getDirectedCoordinate()
double	getDx()
double	getDy()
Edge	getEdge()
Label	getLabel()
Node	getNode()
int	getQuadrant()
protected void	init(Point p0, Point p1)
void	print(PrintStream out)
protected void	setLabel(Label label)
void	setNode(Node node)
String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

edge

protected Edge edge

Constructor Detail

EdgeEnd

protected EdgeEnd(Edge edge)

EdgeEnd

public EdgeEnd(Edge edge,
       Point p0,
       Point p1)

EdgeEnd

public EdgeEnd(Edge edge,
       Point p0,
       Point p1,
       Label label)

Method Detail

compareDirection

public int compareDirection(EdgeEnd e)

Implements the total order relation:

a has a greater angle with the positive x-axis than b

Using the obvious algorithm of simply computing the angle is not robust, since the angle calculation is obviously susceptible to roundoff. A robust algorithm is: - first compare the quadrant. If the quadrants are different, it it trivial to determine which vector is "greater". - if the vectors lie in the same quadrant, the computeOrientation function can be used to decide the relative orientation of the vectors.

compareTo

public int compareTo(Object obj)

Specified by:

compareTo in interface Comparable

computeLabel

public void computeLabel(BoundaryNodeRule boundaryNodeRule)

getCoordinate

public Point getCoordinate()

getDirectedCoordinate

public Point getDirectedCoordinate()

getDx

public double getDx()

getDy

public double getDy()

getEdge

public Edge getEdge()

getLabel

public Label getLabel()

getNode

public Node getNode()

getQuadrant

public int getQuadrant()

init

protected void init(Point p0,
        Point p1)

print

public void print(PrintStream out)

setLabel

protected void setLabel(Label label)

setNode

public void setNode(Node node)

toString

public String toString()

Overrides:

toString in class Object