Surfaces

GTS_SURFACE_CLASS()

#define     GTS_SURFACE_CLASS(klass)

Casts klass to GtsSurfaceClass.

GTS_SURFACE()

#define     GTS_SURFACE(obj)

Casts obj to GtsSurface.

GTS_IS_SURFACE()

#define     GTS_IS_SURFACE(obj)

Evaluates to TRUE if obj is a GtsSurface, FALSE otherwise.

struct GtsSurfaceClass

struct GtsSurfaceClass {

  GtsObjectClass parent_class;

  void (* add_face)    (GtsSurface *, GtsFace *);
  void (* remove_face) (GtsSurface *, GtsFace *);
};

The surface class. No virtual function is defined.

struct GtsSurface

struct GtsSurface {

  GtsObject object;

#ifdef USE_SURFACE_BTREE
  GTree * faces;
#else /* not USE_SURFACE_BTREE */
  GHashTable * faces;
#endif /* not USE_SURFACE_BTREE */
  GtsFaceClass * face_class;
  GtsEdgeClass * edge_class;
  GtsVertexClass * vertex_class;
  gboolean keep_faces;
};

The surface structure derived from GtsObject. This structure should only be accessed through the following functions.

gts_surface_class ()

GtsSurfaceClass* gts_surface_class          (void);

gts_surface_new ()

GtsSurface* gts_surface_new                 (GtsSurfaceClass *klass,
                                             GtsFaceClass *face_class,
                                             GtsEdgeClass *edge_class,
                                             GtsVertexClass *vertex_class);

gts_surface_add_face ()

void        gts_surface_add_face            (GtsSurface *s,
                                             GtsFace *f);

Adds face f to surface s.

gts_surface_remove_face ()

void        gts_surface_remove_face         (GtsSurface *s,
                                             GtsFace *f);

Removes face f from surface s.

gts_surface_copy ()

GtsSurface* gts_surface_copy                (GtsSurface *s1,
                                             GtsSurface *s2);

Add a copy of all the faces, edges and vertices of s2 to s1.

gts_surface_merge ()

void        gts_surface_merge               (GtsSurface *s,
                                             GtsSurface *with);

Adds all the faces of with which do not already belong to s to s.

gts_surface_read ()

guint       gts_surface_read                (GtsSurface *surface,
                                             GtsFile *f);

Add to surface the data read from f. The format of the file pointed to by f is as described in gts_surface_write().

gts_surface_is_manifold ()

gboolean    gts_surface_is_manifold         (GtsSurface *s);

gts_surface_is_orientable ()

gboolean    gts_surface_is_orientable       (GtsSurface *s);

gts_surface_is_closed ()

gboolean    gts_surface_is_closed           (GtsSurface *s);

gts_surface_vertex_number ()

guint       gts_surface_vertex_number       (GtsSurface *s);

gts_surface_edge_number ()

guint       gts_surface_edge_number         (GtsSurface *s);

gts_surface_face_number ()

guint       gts_surface_face_number         (GtsSurface *s);

gts_surface_boundary ()

GSList*     gts_surface_boundary            (GtsSurface *surface);

gts_surface_area ()

gdouble     gts_surface_area                (GtsSurface *s);

gts_surface_volume ()

gdouble     gts_surface_volume              (GtsSurface *s);

gts_surface_center_of_mass ()

gdouble     gts_surface_center_of_mass      (GtsSurface *s,
                                             GtsVector cm);

Fills cm with the coordinates of the center of mass of s.

gts_surface_center_of_area ()

gdouble     gts_surface_center_of_area      (GtsSurface *s,
                                             GtsVector cm);

Fills cm with the coordinates of the center of area of s.

struct GtsSurfaceStats

struct GtsSurfaceStats {

  guint n_faces;
  guint n_incompatible_faces;
  guint n_duplicate_faces;
  guint n_duplicate_edges;
  guint n_boundary_edges;
  guint n_non_manifold_edges;
  GtsRange edges_per_vertex, faces_per_edge;
  GtsSurface * parent;
};

Connectivity statistics.

struct GtsSurfaceQualityStats

struct GtsSurfaceQualityStats {

  GtsRange face_quality;
  GtsRange face_area;
  GtsRange edge_length;
  GtsRange edge_angle;
  GtsSurface * parent;
};

Quality and geometry statistics.

gts_surface_stats ()

void        gts_surface_stats               (GtsSurface *s,
                                             GtsSurfaceStats *stats);

Fills stats with the statistics relevant to surface s.

gts_surface_quality_stats ()

void        gts_surface_quality_stats       (GtsSurface *s,
                                             GtsSurfaceQualityStats *stats);

Fills stats with quality statistics relevant to surface s.

gts_surface_print_stats ()

void        gts_surface_print_stats         (GtsSurface *s,
                                             FILE *fptr);

Writes in the file pointed to by fptr the statistics for surface s.

gts_surface_write ()

void        gts_surface_write               (GtsSurface *s,
                                             FILE *fptr);

Writes in the file fptr an ASCII representation of s. The file format is as follows.

All the lines beginning with GTS_COMMENTS are ignored. The first line contains three unsigned integers separated by spaces. The first integer is the number of vertices, nv, the second is the number of edges, ne and the third is the number of faces, nf.

Follows nv lines containing the x, y and z coordinates of the vertices. Follows ne lines containing the two indices (starting from one) of the vertices of each edge. Follows nf lines containing the three ordered indices (also starting from one) of the edges of each face.

The format described above is the least common denominator to all GTS files. Consistent with an object-oriented approach, the GTS file format is extensible. Each of the lines of the file can be extended with user-specific attributes accessible through the read() and write() virtual methods of each of the objects written (surface, vertices, edges or faces). When read with different object classes, these extra attributes are just ignored.

gts_surface_write_oogl ()

void        gts_surface_write_oogl          (GtsSurface *s,
                                             FILE *fptr);

Writes in the file fptr an OOGL (Geomview) representation of s.

gts_surface_write_oogl_boundary ()

void        gts_surface_write_oogl_boundary (GtsSurface *s,
                                             FILE *fptr);

Writes in the file fptr an OOGL (Geomview) representation of the boundary of s.

gts_surface_write_vtk ()

void        gts_surface_write_vtk           (GtsSurface *s,
                                             FILE *fptr);

Writes in the file fptr a VTK representation of s.

GtsFunc ()

gint        (*GtsFunc)                      (gpointer item,
                                             gpointer data);

A user function called for each item of a collection.

gts_surface_foreach_vertex ()

void        gts_surface_foreach_vertex      (GtsSurface *s,
                                             GtsFunc func,
                                             gpointer data);

Calls func once for each vertex of s.

gts_surface_foreach_edge ()

void        gts_surface_foreach_edge        (GtsSurface *s,
                                             GtsFunc func,
                                             gpointer data);

Calls func once for each edge of s.

gts_surface_foreach_face ()

void        gts_surface_foreach_face        (GtsSurface *s,
                                             GtsFunc func,
                                             gpointer data);

Calls func once for each face of s.

gts_surface_foreach_face_remove ()

guint       gts_surface_foreach_face_remove (GtsSurface *s,
                                             GtsFunc func,
                                             gpointer data);

Calls func once for each face of s. If func returns TRUE the corresponding face is removed from s (and destroyed if it does not belong to any other surface and gts_allow_floating_faces is set to FALSE).

gts_surface_foreach_intersecting_face ()

gboolean    gts_surface_foreach_intersecting_face
                                            (GtsSurface *s,
                                             GtsBBTreeTraverseFunc func,
                                             gpointer data);

Calls func for each intersecting pair of faces of s.

struct GtsSurfaceTraverse

struct GtsSurfaceTraverse;

gts_surface_traverse_new ()

GtsSurfaceTraverse* gts_surface_traverse_new
                                            (GtsSurface *s,
                                             GtsFace *f);

gts_surface_traverse_next ()

GtsFace*    gts_surface_traverse_next       (GtsSurfaceTraverse *t,
                                             guint *level);

gts_surface_traverse_destroy ()

void        gts_surface_traverse_destroy    (GtsSurfaceTraverse *t);

Frees all the memory allocated for t.

gts_surface_distance ()

void        gts_surface_distance            (GtsSurface *s1,
                                             GtsSurface *s2,
                                             gdouble delta,
                                             GtsRange *face_range,
                                             GtsRange *boundary_range);

Using the gts_bb_tree_surface_distance() and gts_bb_tree_surface_boundary_distance() functions fills face_range and boundary_range with the min, max and average Euclidean (minimum) distances between the faces of s1 and the faces of s2 and between the boundary edges of s1 and s2.

gts_surface_strip ()

GSList*     gts_surface_strip               (GtsSurface *s);

Decompose s into triangle strips for fast-rendering.

gts_surface_tessellate ()

void        gts_surface_tessellate          (GtsSurface *s,
                                             GtsRefineFunc refine_func,
                                             gpointer refine_data);

Tessellate each triangle of s with 4 triangles: the number of triangles is increased by a factor of 4. http://mathworld.wolfram.com/GeodesicDome.html

If refine_func is set to NULL a mid arc function is used: if the surface is a polyhedron with the unit sphere as circum sphere, then gts_surface_tessellate() corresponds to a geodesation step (see gts_surface_generate_sphere()).

gts_surface_generate_sphere ()

GtsSurface* gts_surface_generate_sphere     (GtsSurface *s,
                                             guint geodesation_order);

Add a triangulated unit sphere generated by recursive subdivision to s. First approximation is an isocahedron; each level of refinement (geodesation_order) increases the number of triangles by a factor of 4. http://mathworld.wolfram.com/GeodesicDome.html

gts_surface_split ()

GSList*     gts_surface_split               (GtsSurface *s);

Splits a surface into connected and manifold components.