How to use

TriangulationPoint

in

org.poly2tri.triangulation

@Override
public String toString()
{
  return "[" + getX() + "," + getY() + "]";
}
 

double ux = p2.getX() - p1.getX();
double uy = p2.getY() - p1.getY();
double uz = p2.getZ() - p1.getZ();
double vx = p3.getX() - p1.getX();
double vy = p3.getY() - p1.getY();
double vz = p3.getZ() - p1.getZ();

if( p1.getY() > p2.getY() )
else if( p1.getY() == p2.getY() )
  if( p1.getX() > p2.getX() )
  else if( p1.getX() == p2.getX() )
q.addEdge(this);

public AdvancingFrontNode( TriangulationPoint point )
{
  this.point = point;
  value = point.getX();
  key = Double.valueOf( value ); // XXX: BST
}    

private static boolean isShallow( DTSweepContext tcx, AdvancingFrontNode node )
{
  double height;
  if( tcx.basin.leftHighest )
  {
    height = tcx.basin.leftNode.getPoint().getY() - node.getPoint().getY();
  }
  else
  {
    height = tcx.basin.rightNode.getPoint().getY() - node.getPoint().getY();            
  }
  if( tcx.basin.width > height ) 
  {
    return true;
  }        
  return false;
}

/**
 * Start sweeping the Y-sorted point set from bottom to top
 * 
 * @param tcx
 */
private static void sweep( DTSweepContext tcx )
{
  List<TriangulationPoint> points;
  TriangulationPoint point;
  AdvancingFrontNode node;
  
  points = tcx.getPoints();
  
  for( int i=1; i<points.size(); i++ )
  {
    point = points.get(i);
    node = pointEvent( tcx, point );
    if( point.hasEdges() )
    {
      for( DTSweepConstraint e : point.getEdges() )
      {
        if( tcx.isDebugEnabled() ) { tcx.getDebugContext().setActiveConstraint( e ); }
        edgeEvent( tcx, e, node );
      }
    }
    tcx.update( null );
  }
}

@SuppressWarnings("unchecked")
@Override
public void prepareTriangulation( TriangulationContext tcx )
{
  super.prepareTriangulation( tcx );
  if( _constrainedPointList != null )
  {
    HashMap<TriangulationPoint, TriangulationPoint> uniquePts = new HashMap<TriangulationPoint, TriangulationPoint>(_points.size());
    // Enforce same coordinates means same instance of TriangulationPoint
    TriangulationPoint.mergeInstances(uniquePts, _points);
    TriangulationPoint.mergeInstances(uniquePts, _constrainedPointList);
    TriangulationPoint p1,p2;
    Iterator iterator = _constrainedPointList.iterator();
    while(iterator.hasNext())
    {
      p1 = (TriangulationPoint)iterator.next();
      p2 = (TriangulationPoint)iterator.next();
      tcx.newConstraint(p1,p2);
    }
  }
  else
  {
    for( int i = 0; i < _index.length; i+=2 )
    {
      // XXX: must change!!
      tcx.newConstraint( _points.get( _index[i] ), _points.get( _index[i+1] ) );
    }
  }
}

public String toString()
{
  StringBuilder sb = new StringBuilder();
  AdvancingFrontNode node = head;
  while( node != tail )
  {
    sb.append( node.point.getX() ).append( "->" );
    node = node.next;
  } 
  sb.append( tail.point.getX() );
  return sb.toString();
}

if( node.prev.point.getY() < node.next.point.getY() )

TriangulationPoint.mergeInstances(uniquePts, _points);
if(_steinerPoints != null) {
  TriangulationPoint.mergeInstances(uniquePts, _steinerPoints);
    TriangulationPoint.mergeInstances(uniquePts, p._points);

public double area()
{
  double a = (points[0].getX() - points[2].getX())*(points[1].getY() - points[0].getY());
  double b = (points[0].getX() - points[1].getX())*(points[2].getY() - points[0].getY());
  return 0.5*Math.abs( a - b );
}

double ux = p2.getX() - p1.getX();
double uy = p2.getY() - p1.getY();
double uz = p2.getZ() - p1.getZ();
double vx = p3.getX() - p1.getX();
double vy = p3.getY() - p1.getY();
double vz = p3.getZ() - p1.getZ();

/**
 * We use a balancing tree to locate a node smaller or equal to
 * given key value
 * 
 * @param x
 * @return
 */
public AdvancingFrontNode locateNode( TriangulationPoint point )
{
  return locateNode( point.getX() );
}

public boolean equals(Object obj) 
{
  if( obj instanceof TriangulationPoint ) 
  {
    TriangulationPoint p = (TriangulationPoint)obj;
    return getX() == p.getX() && getY() == p.getY();
  }
  return super.equals( obj );
}

double ux = p2.getX() - p1.getX();
double uy = p2.getY() - p1.getY();
double uz = p2.getZ() - p1.getZ();
double vx = p3.getX() - p1.getX();
double vy = p3.getY() - p1.getY();
double vz = p3.getZ() - p1.getZ();

final double px = point.getX();
AdvancingFrontNode node = findSearchNode(px);
final double nx = node.point.getX();

public TPoint centroid()
{
  double cx = ( points[0].getX() + points[1].getX() + points[2].getX() ) / 3d;
  double cy = ( points[0].getY() + points[1].getY() + points[2].getY() ) / 3d;
  return new TPoint( cx, cy );
}

private static void fillRightAboveEdgeEvent(  DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node )
{
  while( node.next.point.getX() < edge.p.getX() )
  {
    if( tcx.isDebugEnabled() ) { tcx.getDebugContext().setActiveNode( node ); }
    // Check if next node is below the edge
    Orientation o1 = orient2d( edge.q, node.next.point, edge.p ); 
    if( o1 == Orientation.CCW )
    {
      fillRightBelowEdgeEvent( tcx, edge, node );                        
    }
    else
    {
      node = node.next;
    }            
  }         
}

/**
 * The basin angle is decided against the horizontal line [1,0]
 */
private static double basinAngle( AdvancingFrontNode node )
{
  double ax = node.point.getX() - node.next.next.point.getX();
  double ay = node.point.getY() - node.next.next.point.getY();
  return Math.atan2( ay, ax );
}

private static void fillLeftAboveEdgeEvent(  DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node )
{
  while( node.prev.point.getX() > edge.p.getX() )
  {
    if( tcx.isDebugEnabled() ) { tcx.getDebugContext().setActiveNode( node ); }
    // Check if next node is below the edge
    Orientation o1 = orient2d( edge.q, node.prev.point, edge.p ); 
    if( o1 == Orientation.CW )
    {
      fillLeftBelowEdgeEvent( tcx, edge, node );                        
    }
    else
    {
      node = node.prev;
    }            
  }         
}