Add functions to create and remove virtual edges and triangles

diff --git a/poly2tri-c/refine/cdt-flipfix.c b/poly2tri-c/refine/cdt-flipfix.c
index 20cce9cf15b0474c090a8db31730a87c282b6521..e359cdde81dcabc25ddcf47bd03205556d391e5d 100644 (file)
--- a/poly2tri-c/refine/cdt-flipfix.c
+++ b/poly2tri-c/refine/cdt-flipfix.c
@@ -94,10 +94,10 @@ p2tr_cdt_flip_fix (P2trCDT     *self,
           P2trEdge *flipped = p2tr_cdt_try_flip (self, edge);
           if (flipped != NULL)
             {
-              p2tr_vedge_set_add2 (candidates, p2tr_vedge_new (A, C1));
-              p2tr_vedge_set_add2 (candidates, p2tr_vedge_new (A, C2));
-              p2tr_vedge_set_add2 (candidates, p2tr_vedge_new (B, C1));
-              p2tr_vedge_set_add2 (candidates, p2tr_vedge_new (B, C2));
+              p2tr_vedge_set_add (candidates, p2tr_point_get_edge_to (A, C1, TRUE));
+              p2tr_vedge_set_add (candidates, p2tr_point_get_edge_to (A, C2, TRUE));
+              p2tr_vedge_set_add (candidates, p2tr_point_get_edge_to (B, C1, TRUE));
+              p2tr_vedge_set_add (candidates, p2tr_point_get_edge_to (B, C2, TRUE));
               p2tr_edge_unref (flipped);
             }
         }

diff --git a/poly2tri-c/refine/vedge.c b/poly2tri-c/refine/vedge.c
index ba1b69300f704a3f0c71264a4eb071e7e3e72fec..b6b899ed893856117513b3ce582d90717f2cffe8 100644 (file)
--- a/poly2tri-c/refine/vedge.c
+++ b/poly2tri-c/refine/vedge.c
@@ -41,20 +41,23 @@
 static void
 p2tr_vedge_init (P2trVEdge *self,
                  P2trPoint *start,
-                 P2trPoint *end)
+                 P2trPoint *end,
+                 gboolean   constrained)
 {
-  self->start    = start;
-  self->end      = end;
-  self->refcount = 0;
+  self->start       = start;
+  self->end         = end;
+  self->constrained = constrained;
+  self->refcount    = 0;
 }
 
 P2trVEdge*
 p2tr_vedge_new (P2trPoint *start,
-                P2trPoint *end)
+                P2trPoint *end,
+                gboolean   constrained)
 {
-  P2trVEdge *self   = g_slice_new (P2trVEdge);
+  P2trVEdge *self = g_slice_new (P2trVEdge);
 
-  p2tr_vedge_init (self, start, end);
+  p2tr_vedge_init (self, start, end, constrained);
 
   p2tr_point_ref (start);
   p2tr_point_ref (end);
@@ -64,9 +67,10 @@ p2tr_vedge_new (P2trPoint *start,
 }
 
 P2trVEdge*
-p2tr_vedge_new2 (P2trEdge  *real)
+p2tr_vedge_new2 (P2trEdge *real)
 {
-  return p2tr_vedge_new (P2TR_EDGE_START (real), real->end);
+  return p2tr_vedge_new (P2TR_EDGE_START (real), real->end,
+      real->constrained);
 }
 
 P2trVEdge*
@@ -90,6 +94,36 @@ p2tr_vedge_is_real (P2trVEdge *self)
   return p2tr_point_has_edge_to (self->start, self->end);
 }
 
+void
+p2tr_vedge_create (P2trVEdge *self)
+{
+  P2trMesh *mesh;
+  P2trEdge *edge;
+
+  g_assert (! p2tr_vedge_is_real (self));
+
+  mesh = p2tr_vedge_get_mesh (self);
+  if (mesh != NULL)
+    {
+      edge = p2tr_mesh_new_edge (mesh, self->start, self->end, self->constrained);
+      p2tr_mesh_unref (mesh);
+    }
+  else
+    edge = p2tr_edge_new (self->start, self->end, self->constrained);
+
+  p2tr_edge_unref (edge);
+}
+
+void
+p2tr_vedge_remove (P2trVEdge *self)
+{
+  P2trEdge *edge = p2tr_vedge_is_real (self);
+
+  g_assert (edge != NULL);
+
+  p2tr_edge_remove (edge);
+}
+
 void
 p2tr_vedge_free (P2trVEdge *self)
 {

diff --git a/poly2tri-c/refine/vedge.h b/poly2tri-c/refine/vedge.h
index ae11b6ee98230db06a150bb2e2e285695d6142a1..5685c3e97dfcbf23461d32141df36cc8b69f192c 100644 (file)
--- a/poly2tri-c/refine/vedge.h
+++ b/poly2tri-c/refine/vedge.h
@@ -48,13 +48,15 @@ struct P2trVEdge_
   P2trPoint *start;
   /** The end point of this virtual edge */
   P2trPoint *end;
-
+  /** A flag to make whether this is a constrained edge */
+  gboolean   constrained;
   /** A count of references to the virtual edge */
-  guint         refcount;
+  guint      refcount;
 };
 
 P2trVEdge*  p2tr_vedge_new       (P2trPoint *start,
-                                  P2trPoint *end);
+                                  P2trPoint *end,
+                                  gboolean   constrained);
 
 P2trVEdge*  p2tr_vedge_new2      (P2trEdge  *real);
 
@@ -68,6 +70,10 @@ P2trMesh*   p2tr_vedge_get_mesh  (P2trVEdge *self);
 
 P2trEdge*   p2tr_vedge_is_real   (P2trVEdge *self);
 
+void        p2tr_vedge_create    (P2trVEdge *self);
+
+void        p2tr_vedge_remove    (P2trVEdge *self);
+
 P2trEdge*   p2tr_vedge_get       (P2trVEdge *self);
 
 /**
@@ -100,28 +106,28 @@ P2trVEdgeSet* p2tr_vedge_set_new  ();
  * Add the given edge to the flip set. THE EDGE MUST HAVE BEEN REFFED
  * BEFORE THE CALL TO THIS FUNCTION!
  */
-void         p2tr_vedge_set_add  (P2trVEdgeSet *self,
-                                 P2trEdge    *to_flip);
+void         p2tr_vedge_set_add  (P2trVEdgeSet  *self,
+                                  P2trEdge      *to_flip);
 
 /**
  * Add the given virtual edge to the flip set. THE VIRTUAL EDGE MUST
  * HAVE BEEN REFFED BEFORE THE CALL TO THIS FUNCTION!
  */
-void         p2tr_vedge_set_add2 (P2trVEdgeSet *self,
-                                 P2trVEdge   *to_flip);
+void         p2tr_vedge_set_add2 (P2trVEdgeSet  *self,
+                                  P2trVEdge     *to_flip);
 
 /**
  * Try popping a virtual edge from the set. If succeeds, THE RETURNED
  * VIRTUAL EDGE MUST BE UNREFFED!
  */
 gboolean     p2tr_vedge_set_pop  (P2trVEdgeSet  *self,
-                                 P2trVEdge   **value);
+                                  P2trVEdge    **value);
 
 /**
  * Free the flip set. IT IS THE REPONSIBILITY OF THE CALLER TO MAKE
  * SURE NO VIRTUAL EDGES WERE LEFT IN THE SET!
  */
-void         p2tr_vedge_set_free (P2trVEdgeSet *self);
+void         p2tr_vedge_set_free (P2trVEdgeSet  *self);
 
 gboolean     p2tr_vedge_undirected_equals (const P2trVEdge *e1,
                                            const P2trVEdge *e2);

diff --git a/poly2tri-c/refine/vtriangle.c b/poly2tri-c/refine/vtriangle.c
index 2666479bba959e413dbf2f7c6cb030fbc089e580..e213372cf1b7a1c0def5600184ef07e954b4e0e1 100644 (file)
--- a/poly2tri-c/refine/vtriangle.c
+++ b/poly2tri-c/refine/vtriangle.c
@@ -100,6 +100,41 @@ p2tr_vtriangle_is_real (P2trVTriangle *self)
     return NULL;
 }
 
+void
+p2tr_vtriangle_create (P2trVTriangle *self)
+{
+  P2trMesh     *mesh;
+  P2trEdge     *e1, *e2, *e3;
+  P2trTriangle *tri;
+
+  g_assert (! p2tr_vtriangle_is_real (self));
+
+  mesh = p2tr_vtriangle_get_mesh (self);
+  e1 = p2tr_point_get_edge_to (self->points[0], self->points[1], FALSE);
+  e2 = p2tr_point_get_edge_to (self->points[1], self->points[2], FALSE);
+  e3 = p2tr_point_get_edge_to (self->points[2], self->points[0], FALSE);
+
+  if (mesh != NULL)
+    {
+      tri = p2tr_mesh_new_triangle (mesh, e1, e2, e3);
+      p2tr_mesh_unref (mesh);
+    }
+  else
+    tri = p2tr_triangle_new (e1, e2, e3);
+
+  p2tr_triangle_unref (tri);
+}
+
+void
+p2tr_vtriangle_remove (P2trVTriangle *self)
+{
+  P2trTriangle *tri = p2tr_vtriangle_is_real (self);
+
+  g_assert (tri != NULL);
+
+  p2tr_triangle_remove (tri);
+}
+
 P2trTriangle*
 p2tr_vtriangle_get (P2trVTriangle *self)
 {

diff --git a/poly2tri-c/refine/vtriangle.h b/poly2tri-c/refine/vtriangle.h
index a1dd0a1d493fe8ae475320f003107089d44b9c69..5e63251faeb49f5b7a29fd274427fcb02a9c91cd 100644 (file)
--- a/poly2tri-c/refine/vtriangle.h
+++ b/poly2tri-c/refine/vtriangle.h
@@ -61,6 +61,10 @@ P2trMesh*        p2tr_vtriangle_get_mesh     (P2trVTriangle *self);
 
 P2trTriangle*    p2tr_vtriangle_is_real      (P2trVTriangle *self);
 
+void             p2tr_vtriangle_create       (P2trVTriangle *self);
+
+void             p2tr_vtriangle_remove       (P2trVTriangle *self);
+
 P2trTriangle*    p2tr_vtriangle_get          (P2trVTriangle *self);
 
 #endif