gts/face.c

   1 /* GTS - Library for the manipulation of triangulated surfaces
   2  * Copyright (C) 1999 Stéphane Popinet
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "gts.h"
  21
  22 gboolean gts_allow_floating_faces = FALSE;
  23
  24 static void face_destroy (GtsObject * object)
  25 {
  26   GtsFace * face = GTS_FACE (object);
  27   GSList * i;
  28
  29   i = face->surfaces;
  30   while (i) {
  31     GSList * next = i->next;
  32     gts_surface_remove_face (i->data, face);
  33     i = next;
  34   }
  35   g_assert (face->surfaces == NULL);
  36
  37   (* GTS_OBJECT_CLASS (gts_face_class ())->parent_class->destroy) (object);
  38 }
  39
  40 static void face_clone (GtsObject * clone, GtsObject * object)
  41 {
  42   (* GTS_OBJECT_CLASS (gts_face_class ())->parent_class->clone) (clone,
  43                                                                  object);
  44   GTS_FACE (clone)->surfaces = NULL;
  45 }
  46
  47 static void face_class_init (GtsFaceClass * klass)
  48 {
  49   GTS_OBJECT_CLASS (klass)->clone = face_clone;
  50   GTS_OBJECT_CLASS (klass)->destroy = face_destroy;
  51 }
  52
  53 static void face_init (GtsFace * face)
  54 {
  55   face->surfaces = NULL;
  56 }
  57
  58 /**
  59  * gts_face_class:
  60  *
  61  * Returns: the #GtsFaceClass.
  62  */
  63 GtsFaceClass * gts_face_class (void)
  64 {
  65   static GtsFaceClass * klass = NULL;
  66
  67   if (klass == NULL) {
  68     GtsObjectClassInfo face_info = {
  69       "GtsFace",
  70       sizeof (GtsFace),
  71       sizeof (GtsFaceClass),
  72       (GtsObjectClassInitFunc) face_class_init,
  73       (GtsObjectInitFunc) face_init,
  74       (GtsArgSetFunc) NULL,
  75       (GtsArgGetFunc) NULL
  76     };
  77     klass = gts_object_class_new (GTS_OBJECT_CLASS (gts_triangle_class ()),
  78                                   &face_info);
  79   }
  80
  81   return klass;
  82 }
  83
  84 /**
  85  * gts_face_new:
  86  * @klass: a #GtsFaceClass.
  87  * @e1: a #GtsEdge.
  88  * @e2: a #GtsEdge.
  89  * @e3: a #GtsEdge.
  90  *
  91  * Returns: a new #GtsFace using @e1, @e2 and @e3 as edges.
  92  */
  93 GtsFace * gts_face_new (GtsFaceClass * klass,
  94                         GtsEdge * e1, GtsEdge * e2, GtsEdge * e3)
  95 {
  96   GtsFace * f;
  97
  98   f = GTS_FACE (gts_object_new (GTS_OBJECT_CLASS (klass)));
  99   gts_triangle_set (GTS_TRIANGLE (f), e1, e2, e3);
 100
 101   return f;
 102 }
 103
 104 /**
 105  * gts_face_has_parent_surface:
 106  * @f: a #GtsFace.
 107  * @s: a #GtsSurface.
 108  *
 109  * Returns: %TRUE if @f belongs to @s, %FALSE otherwise.
 110  */
 111 gboolean gts_face_has_parent_surface (GtsFace * f, GtsSurface * s)
 112 {
 113   GSList * i;
 114
 115   g_return_val_if_fail (f != NULL, FALSE);
 116
 117   i = f->surfaces;
 118   while (i) {
 119     if (i->data == s)
 120       return TRUE;
 121     i = i->next;
 122   }
 123   return FALSE;
 124 }
 125
 126 /**
 127  * gts_faces_from_edges:
 128  * @edges: a list of #GtsEdge.
 129  * @s: a #GtsSurface or %NULL.
 130  *
 131  * Builds a list of unique faces which belong to @s and have
 132  * one of their edges in @edges.
 133  *
 134  * Returns: the list of faces.
 135  */
 136 GSList * gts_faces_from_edges (GSList * edges, GtsSurface * s)
 137 {
 138   GHashTable * hash;
 139   GSList * faces = NULL, * i;
 140
 141   hash = g_hash_table_new (NULL, NULL);
 142   i = edges;
 143   while (i) {
 144     GSList * j = GTS_EDGE (i->data)->triangles;
 145     while (j) {
 146       GtsTriangle * t = j->data;
 147       if (GTS_IS_FACE (t) &&
 148           (!s || gts_face_has_parent_surface (GTS_FACE (t), s)) &&
 149           g_hash_table_lookup (hash, t) == NULL) {
 150         faces = g_slist_prepend (faces, t);
 151         g_hash_table_insert (hash, t, i);
 152       }
 153       j = j->next;
 154     }
 155     i = i->next;
 156   }
 157   g_hash_table_destroy (hash);
 158
 159   return faces;
 160 }
 161
 162 /**
 163  * gts_face_neighbor_number:
 164  * @f: a #GtsFace.
 165  * @s: a #GtsSurface or %NULL.
 166  *
 167  * Returns: the number of faces neighbors of @f and belonging to @s.
 168  */
 169 guint gts_face_neighbor_number (GtsFace * f, GtsSurface * s)
 170 {
 171   GSList * i;
 172   guint nn = 0;
 173   GtsEdge * e[4], ** e1 = e;
 174
 175   g_return_val_if_fail (f != NULL, 0);
 176
 177   e[0] = GTS_TRIANGLE (f)->e1;
 178   e[1] = GTS_TRIANGLE (f)->e2;
 179   e[2] = GTS_TRIANGLE (f)->e3;
 180   e[3] = NULL;
 181   while (*e1) {
 182     i = (*e1++)->triangles;
 183     while (i) {
 184       GtsTriangle * t = i->data;
 185       if (GTS_FACE (t) != f &&
 186           GTS_IS_FACE (t) &&
 187           (!s || gts_face_has_parent_surface (GTS_FACE (t), s)))
 188         nn++;
 189       i = i->next;
 190     }
 191   }
 192
 193   return nn;
 194 }
 195
 196 /**
 197  * gts_face_neighbors:
 198  * @f: a #GtsFace.
 199  * @s: a #GtsSurface or %NULL.
 200  *
 201  * Returns: a list of unique #GtsFace neighbors of @f and belonging to @s.
 202  */
 203 GSList * gts_face_neighbors (GtsFace * f, GtsSurface * s)
 204 {
 205   GSList * i, * list = NULL;
 206   GtsEdge * e[4], ** e1 = e;
 207
 208   g_return_val_if_fail (f != NULL, NULL);
 209
 210   e[0] = GTS_TRIANGLE (f)->e1;
 211   e[1] = GTS_TRIANGLE (f)->e2;
 212   e[2] = GTS_TRIANGLE (f)->e3;
 213   e[3] = NULL;
 214   while (*e1) {
 215     i = (*e1++)->triangles;
 216     while (i) {
 217       GtsTriangle * t = i->data;
 218       if (GTS_FACE (t) != f &&
 219           GTS_IS_FACE (t) &&
 220           (!s || gts_face_has_parent_surface (GTS_FACE (t), s)))
 221         list = g_slist_prepend (list, t);
 222       i = i->next;
 223     }
 224   }
 225
 226   return list;
 227 }
 228
 229 /**
 230  * gts_face_foreach_neighbor:
 231  * @f: a #GtsFace.
 232  * @s: a #GtsSurface or %NULL.
 233  * @func: a #GtsFunc.
 234  * @data: user data to pass to @func.
 235  *
 236  * Calls @func for each neighbor of @f belonging to @s (if not %NULL).
 237  */
 238 void gts_face_foreach_neighbor (GtsFace * f,
 239                                 GtsSurface * s,
 240                                 GtsFunc func,
 241                                 gpointer data)
 242 {
 243   GSList * i;
 244   GtsEdge * e[4], ** e1 = e;
 245
 246   g_return_if_fail (f != NULL);
 247   g_return_if_fail (func != NULL);
 248
 249   e[0] = GTS_TRIANGLE (f)->e1;
 250   e[1] = GTS_TRIANGLE (f)->e2;
 251   e[2] = GTS_TRIANGLE (f)->e3;
 252   e[3] = NULL;
 253   while (*e1) {
 254     i = (*e1++)->triangles;
 255     while (i) {
 256       GtsTriangle * t = i->data;
 257       if (GTS_FACE (t) != f &&
 258           GTS_IS_FACE (t) &&
 259           (!s || gts_face_has_parent_surface (GTS_FACE (t), s)))
 260         (* func) (t, data);
 261       i = i->next;
 262     }
 263   }
 264 }
 265
 266 static gboolean triangle_is_incompatible (GtsTriangle * t, GtsEdge * e, GtsSurface * s)
 267 {
 268   GSList * i = e->triangles;
 269
 270   while (i) {
 271     if (i->data != t &&
 272         GTS_IS_FACE (i->data) &&
 273         gts_face_has_parent_surface (i->data, s) &&
 274         !gts_triangles_are_compatible (t, i->data, e))
 275       return TRUE;
 276     i = i->next;
 277   }
 278   return FALSE;
 279 }
 280
 281 /**
 282  * gts_face_is_compatible:
 283  * @f: a #GtsFace.
 284  * @s: a #GtsSurface.
 285  *
 286  * Returns: %TRUE if @f is compatible with all its neighbors belonging
 287  * to @s, %FALSE otherwise.
 288  */
 289 gboolean gts_face_is_compatible (GtsFace * f, GtsSurface * s)
 290 {
 291   g_return_val_if_fail (f != NULL, FALSE);
 292   g_return_val_if_fail (s != NULL, FALSE);
 293
 294   return !(triangle_is_incompatible (GTS_TRIANGLE (f), GTS_TRIANGLE (f)->e1, s) ||
 295            triangle_is_incompatible (GTS_TRIANGLE (f), GTS_TRIANGLE (f)->e2, s) ||
 296            triangle_is_incompatible (GTS_TRIANGLE (f), GTS_TRIANGLE (f)->e3, s));
 297 }