/// <summary>
/// edgeEvent
/// </summary>
///
/// <param name="tcx"></param>
/// <param name="edge"></param>
/// <param name="node"></param>
///
private static void edgeEvent(DTSweepContext tcx,
DTSweepConstraint edge,
AdvancingFrontNode node)
{
try
{
tcx.edgeEvent.constrainedEdge = edge;
tcx.edgeEvent.right = edge.getP().getX() > edge.getQ().getX();
if (tcx.isDebugEnabled())
{
tcx.getDebugContext().setPrimaryTriangle(node.triangle);
}
if (isEdgeSideOfTriangle(node.triangle, edge.getP(), edge.getQ()))
{
return;
}
// For now we will do all needed filling
// TODO: integrate with flip process might give some better performance
// but for now this avoid the issue with cases that needs both flips and fills
fillEdgeEvent(tcx, edge, node);
edgeEvent(tcx, edge.getP(), edge.getQ(), node.triangle, edge.getQ());
}
catch (PointOnEdgeException e)
{
logger.Warn("Skipping edge: {}", e.Message);
}
}
private static void fillLeftAboveEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
while (node.prev.point.getX() > edge.getP().getX())
{
if (tcx.isDebugEnabled())
{
tcx.getDebugContext().setActiveNode(node);
}
// Check if next node is below the edge
Orientation o1 = orient2d(edge.getQ(), node.prev.point, edge.getP());
if (o1 == Orientation.CW)
{
fillLeftBelowEdgeEvent(tcx, edge, node);
}
else
{
node = node.prev;
}
}
}
private static void fillLeftConcaveEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
fill(tcx, node.prev);
if (node.prev.point != edge.getP())
{
// Next above or below edge?
if (orient2d(edge.getQ(), node.prev.point, edge.getP()) == Orientation.CW)
{
// Below
if (orient2d(node.point, node.prev.point, node.prev.prev.point) == Orientation.CW)
{
// Next is concave
fillLeftConcaveEdgeEvent(tcx, edge, node);
}
else
{
// Next is convex
}
}
}
}
public void markConstrainedEdge(DTSweepConstraint edge)
{
markConstrainedEdge(edge.getP(), edge.getQ());
if ((edge.getQ() == points[0] && edge.getP() == points[1]) ||
(edge.getQ() == points[1] && edge.getP() == points[0]))
{
cEdge[2] = true;
}
else if ((edge.getQ() == points[0] && edge.getP() == points[2]) ||
(edge.getQ() == points[2] && edge.getP() == points[0]))
{
cEdge[1] = true;
}
else if ((edge.getQ() == points[1] && edge.getP() == points[2]) ||
(edge.getQ() == points[2] && edge.getP() == points[1]))
{
cEdge[0] = true;
}
}
private static void fillLeftBelowEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
if (tcx.isDebugEnabled())
{
tcx.getDebugContext().setActiveNode(node);
}
if (node.point.getX() > edge.getP().getX())
{
if (orient2d(node.point, node.prev.point, node.prev.prev.point) == Orientation.CW)
{
// Concave
fillLeftConcaveEdgeEvent(tcx, edge, node);
}
else
{
// Convex
fillLeftConvexEdgeEvent(tcx, edge, node);
// Retry this one
fillLeftBelowEdgeEvent(tcx, edge, node);
}
}
}
private static void fillRightConvexEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
// Next concave or convex?
if (orient2d(node.next.point, node.next.next.point, node.next.next.next.point) == Orientation.CCW)
{
// Concave
fillRightConcaveEdgeEvent(tcx, edge, node.next);
}
else
{
// Convex
// Next above or below edge?
if (orient2d(edge.getQ(), node.next.next.point, edge.getP()) == Orientation.CCW)
{
// Below
fillRightConvexEdgeEvent(tcx, edge, node.next);
}
else
{
// Above
}
}
}
public bool contains(DTSweepConstraint e)
{
return(contains(e.getP()) && contains(e.getQ()));
}
