C# Poly2Tri.DTSweepConstraint類代碼示例

		private static void FillLeftBelowEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
		{
			if (tcx.IsDebugEnabled) tcx.DTDebugContext.ActiveNode = node;

			if (node.Point.X > edge.P.X)
			{
				if (TriangulationUtil.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 FillLeftAboveEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
		{
			while (node.Prev.Point.X > edge.P.X)
			{
				if (tcx.IsDebugEnabled) tcx.DTDebugContext.ActiveNode = node;
				// Check if next node is below the edge
				Orientation o1 = TriangulationUtil.Orient2d(edge.Q, node.Prev.Point, edge.P);
				if (o1 == Orientation.CW)
				{
					FillLeftBelowEdgeEvent(tcx, edge, node);
				}
				else
				{
					node = node.Prev;
				}
			}
		}

		private static void FillRightConvexEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
		{
			// Next concave or convex?
			if (TriangulationUtil.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 (TriangulationUtil.Orient2d(edge.Q, node.Next.Next.Point, edge.P) == Orientation.CCW)
				{
					// Below
					FillRightConvexEdgeEvent(tcx, edge, node.Next);
				}
				else
				{
					// Above
				}
			}
		}

		private static void FillLeftConcaveEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
		{
			Fill(tcx, node.Prev);
			if (node.Prev.Point != edge.P)
			{
				// Next above or below edge?
				if (TriangulationUtil.Orient2d(edge.Q, node.Prev.Point, edge.P) == Orientation.CW)
				{
					// Below
					if (TriangulationUtil.Orient2d(node.Point, node.Prev.Point, node.Prev.Prev.Point) == Orientation.CW)
					{
						// Next is concave
						FillLeftConcaveEdgeEvent(tcx, edge, node);
					}
					else
					{
						// Next is convex
					}
				}
			}
		}

		private static void EdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
		{
			try
			{
				tcx.EdgeEvent.ConstrainedEdge = edge;
				tcx.EdgeEvent.Right = edge.P.X > edge.Q.X;

				if (tcx.IsDebugEnabled) { tcx.DTDebugContext.PrimaryTriangle = node.Triangle; }

				if (IsEdgeSideOfTriangle(node.Triangle, edge.P, edge.Q)) 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.P, edge.Q, node.Triangle, edge.Q);
			}
			catch (PointOnEdgeException)
			{
				//Debug.WriteLine( String.Format( "Warning: Skipping Edge: {0}", e.Message ) );
				throw;
			}
		}

		private static void FillEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
		{
			if (tcx.EdgeEvent.Right)
			{
				FillRightAboveEdgeEvent(tcx, edge, node);
			}
			else
			{
				FillLeftAboveEdgeEvent(tcx, edge, node);
			}
		}

 public void MarkConstrainedEdge(DTSweepConstraint edge)
 {
     MarkConstrainedEdge(edge.P, edge.Q);
 }

        public bool GetEdgeCW(TriangulationPoint p, out DTSweepConstraint edge)
        {
            int pointIndex = IndexOf(p);
            int edgeIdx = (pointIndex + 1) % 3;

            return GetEdge(edgeIdx, out edge);
        }

        public bool GetEdgeAcross(TriangulationPoint p, out DTSweepConstraint edge)
        {
            int pointIndex = IndexOf(p);
            int edgeIdx = pointIndex;

            return GetEdge(edgeIdx, out edge);
        }

        public bool GetEdge(int idx, out DTSweepConstraint edge)
        {
            edge = null;
            if (idx < 0 || idx > 2)
            {
                return false;
            }
            TriangulationPoint p1 = Points[(idx + 1) % 3];
            TriangulationPoint p2 = Points[(idx + 2) % 3];
            if (p1.GetEdge(p2, out edge))
            {
                return true;
            }
            else if (p2.GetEdge(p1, out edge))
            {
                return true;
            }

            return false;
        }

		public void AddEdge(DTSweepConstraint e) {
			if (Edges == null) Edges = new List<DTSweepConstraint>();
			Edges.Add(e);
		}