/**
* gts_edges_merge:
* @edges: a list of #GtsEdge.
*
* For each edge in @edges check if it is duplicated (as
* returned by gts_edge_is_duplicate()). If it is replace it by its
* duplicate, destroy it and remove it from the list.
*
* Returns: the updated @edges list.
*/
GList * gts_edges_merge (GList * edges)
{
GList * i = edges;
/* we want to control edge destruction */
gts_allow_floating_edges = TRUE;
while (i) {
GtsEdge * e = i->data;
GtsEdge * de = gts_edge_is_duplicate (e);
if (de) {
GList * next = i->next;
edges = g_list_remove_link (edges, i);
g_list_free_1 (i);
i = next;
gts_edge_replace (e, de);
gts_object_destroy (GTS_OBJECT (e));
}
else
i = i->next;
}
gts_allow_floating_edges = FALSE;;
return edges;
}
void
pygts_edge_cleanup(GtsSurface *s)
{
GSList *edges = NULL;
GSList *i, *ii, *cur, *parents=NULL;
PygtsEdge *edge;
GtsEdge *e, *duplicate;
g_return_if_fail(s != NULL);
/* build list of edges */
gts_surface_foreach_edge(s, (GtsFunc)build_list, &edges);
/* remove degenerate and duplicate edges.
Note: we could use gts_edges_merge() to remove the duplicates and then
remove the degenerate edges but it is more efficient to do everything
at once (and it's more pedagogical too ...) */
/* We want to control manually the destruction of edges */
gts_allow_floating_edges = TRUE;
i = edges;
while(i) {
e = (GtsEdge*)i->data;
if(GTS_SEGMENT(e)->v1 == GTS_SEGMENT(e)->v2) {
/* edge is degenerate */
if( !g_hash_table_lookup(obj_table,GTS_OBJECT(e)) ) {
/* destroy e */
gts_object_destroy(GTS_OBJECT(e));
}
}
else {
if((duplicate = gts_edge_is_duplicate(e))) {
/* Detach and save any parent triangles */
if( (edge = PYGTS_EDGE(g_hash_table_lookup(obj_table,GTS_OBJECT(e))))
!=NULL ) {
ii = e->triangles;
while(ii!=NULL) {
cur = ii;
ii = g_slist_next(ii);
if(PYGTS_IS_PARENT_TRIANGLE(cur->data)) {
e->triangles = g_slist_remove_link(e->triangles, cur);
parents = g_slist_prepend(parents,cur->data);
g_slist_free_1(cur);
}
}
}
/* replace e with its duplicate */
gts_edge_replace(e, duplicate);
/* Reattach the parent segments */
if( edge != NULL ) {
ii = parents;
while(ii!=NULL) {
e->triangles = g_slist_prepend(e->triangles, ii->data);
ii = g_slist_next(ii);
}
g_slist_free(parents);
parents = NULL;
}
if( !g_hash_table_lookup(obj_table,GTS_OBJECT(e)) ) {
/* destroy e */
gts_object_destroy(GTS_OBJECT (e));
}
}
}
i = g_slist_next(i);
}
/* don't forget to reset to default */
gts_allow_floating_edges = FALSE;
/* free list of edges */
g_slist_free (edges);
}
static void gts_constraint_split (GtsConstraint * c,
GtsSurface * s,
GtsFifo * fifo)
{
GSList * i;
GtsVertex * v1, * v2;
GtsEdge * e;
g_return_if_fail (c != NULL);
g_return_if_fail (s != NULL);
v1 = GTS_SEGMENT (c)->v1;
v2 = GTS_SEGMENT (c)->v2;
e = GTS_EDGE (c);
i = e->triangles;
while (i) {
GtsFace * f = i->data;
if (GTS_IS_FACE (f) && gts_face_has_parent_surface (f, s)) {
GtsVertex * v = gts_triangle_vertex_opposite (GTS_TRIANGLE (f), e);
if (gts_point_orientation (GTS_POINT (v1),
GTS_POINT (v2),
GTS_POINT (v)) == 0.) {
GSList * j = e->triangles;
GtsFace * f1 = NULL;
GtsEdge * e1, * e2;
/* replaces edges with constraints */
gts_triangle_vertices_edges (GTS_TRIANGLE (f), e,
&v1, &v2, &v, &e, &e1, &e2);
if (!GTS_IS_CONSTRAINT (e1)) {
GtsEdge * ne1 =
gts_edge_new (GTS_EDGE_CLASS (GTS_OBJECT (c)->klass), v2, v);
gts_edge_replace (e1, ne1);
gts_object_destroy (GTS_OBJECT (e1));
e1 = ne1;
if (fifo) gts_fifo_push (fifo, e1);
}
if (!GTS_IS_CONSTRAINT (e2)) {
GtsEdge * ne2 =
gts_edge_new (GTS_EDGE_CLASS (GTS_OBJECT (c)->klass), v, v1);
gts_edge_replace (e2, ne2);
gts_object_destroy (GTS_OBJECT (e2));
e2 = ne2;
if (fifo) gts_fifo_push (fifo, e2);
}
/* look for face opposite */
while (j && !f1) {
if (GTS_IS_FACE (j->data) &&
gts_face_has_parent_surface (j->data, s))
f1 = j->data;
j = j->next;
}
if (f1) { /* c is not a boundary of s */
GtsEdge * e3, * e4, * e5;
GtsVertex * v3;
gts_triangle_vertices_edges (GTS_TRIANGLE (f1), e,
&v1, &v2, &v3, &e, &e3, &e4);
e5 = gts_edge_new (s->edge_class, v, v3);
gts_surface_add_face (s, gts_face_new (s->face_class, e5, e2, e3));
gts_surface_add_face (s, gts_face_new (s->face_class, e5, e4, e1));
gts_object_destroy (GTS_OBJECT (f1));
}
gts_object_destroy (GTS_OBJECT (f));
return;
}
}
i = i->next;
}
}
