Пример #1
0
 private static bool Legalize(DTSweepContext tcx, DelaunayTriangle t)
 {
     for (int i = 0; i < 3; i++)
     {
         if (!t.EdgeIsDelaunay[i])
         {
             DelaunayTriangle ot = t.Neighbors[i];
             if (ot != null)
             {
                 TriangulationPoint p      = t.Points[i];
                 TriangulationPoint point2 = ot.OppositePoint(t, p);
                 int index = ot.IndexOf(point2);
                 if (ot.EdgeIsConstrained[index] || ot.EdgeIsDelaunay[index])
                 {
                     t.EdgeIsConstrained[i] = ot.EdgeIsConstrained[index];
                 }
                 else if (TriangulationUtil.SmartIncircle(p, t.PointCCWFrom(p), t.PointCWFrom(p), point2))
                 {
                     t.EdgeIsDelaunay[i]      = true;
                     ot.EdgeIsDelaunay[index] = true;
                     RotateTrianglePair(t, p, ot, point2);
                     if (!Legalize(tcx, t))
                     {
                         tcx.MapTriangleToNodes(t);
                     }
                     if (!Legalize(tcx, ot))
                     {
                         tcx.MapTriangleToNodes(ot);
                     }
                     t.EdgeIsDelaunay[i]      = false;
                     ot.EdgeIsDelaunay[index] = false;
                     return(true);
                 }
             }
         }
     }
     return(false);
 }
Пример #2
0
        /// <summary>
        /// Returns true if triangle was legalized
        /// </summary>
        private static bool Legalize(DTSweepContext tcx, DelaunayTriangle t)
        {
            // To legalize a triangle we start by finding if any of the three edges
            // violate the Delaunay condition
            for (int i = 0; i < 3; i++)
            {
                // TODO: fix so that cEdge is always valid when creating new triangles then we can check it here
                //       instead of below with ot
                if (t.EdgeIsDelaunay[i])
                {
                    continue;
                }

                DelaunayTriangle ot = t.Neighbors[i];
                if (ot == null)
                {
                    continue;
                }

                TriangulationPoint p  = t.Points[i];
                TriangulationPoint op = ot.OppositePoint(t, p);
                int oi = ot.IndexOf(op);
                // If this is a Constrained Edge or a Delaunay Edge(only during recursive legalization)
                // then we should not try to legalize
                if (ot.EdgeIsConstrained[oi] || ot.EdgeIsDelaunay[oi])
                {
                    t.EdgeIsConstrained[i] = ot.EdgeIsConstrained[oi];                     // XXX: have no good way of setting this property when creating new triangles so lets set it here
                    continue;
                }

                if (!TriangulationUtil.SmartIncircle(p, t.PointCCWFrom(p), t.PointCWFrom(p), op))
                {
                    continue;
                }

                // Lets mark this shared edge as Delaunay
                t.EdgeIsDelaunay[i]   = true;
                ot.EdgeIsDelaunay[oi] = true;

                // Lets rotate shared edge one vertex CW to legalize it
                RotateTrianglePair(t, p, ot, op);

                // We now got one valid Delaunay Edge shared by two triangles
                // This gives us 4 new edges to check for Delaunay

                // Make sure that triangle to node mapping is done only one time for a specific triangle
                if (!Legalize(tcx, t))
                {
                    tcx.MapTriangleToNodes(t);
                }
                if (!Legalize(tcx, ot))
                {
                    tcx.MapTriangleToNodes(ot);
                }

                // Reset the Delaunay edges, since they only are valid Delaunay edges
                // until we add a new triangle or point.
                // XXX: need to think about this. Can these edges be tried after we
                //      return to previous recursive level?
                t.EdgeIsDelaunay[i]   = false;
                ot.EdgeIsDelaunay[oi] = false;

                // If triangle have been legalized no need to check the other edges since
                // the recursive legalization will handles those so we can end here.
                return(true);
            }
            return(false);
        }