Progressive surfaces

GTS_PSURFACE_CLASS()

#define     GTS_PSURFACE_CLASS(klass)

Casts klass to GtsPSurfaceClass.

GTS_PSURFACE()

#define     GTS_PSURFACE(obj)

Casts obj to GtsPSurface.

GTS_IS_PSURFACE()

#define     GTS_IS_PSURFACE(obj)

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

GTS_PSURFACE_IS_CLOSED()

#define GTS_PSURFACE_IS_CLOSED(ps)  (!(ps)->vertices)

Evaluates to TRUE if ps has not been created with gts_psurface_open() or if it has been closed using gts_psurface_close().

struct GtsPSurfaceClass

struct GtsPSurfaceClass {

  GtsObjectClass parent_class;
};

The progressive surface class derived from GtsObjectClass.

struct GtsPSurface

struct GtsPSurface {

  GtsObject object;

  GtsSurface * s;
  GPtrArray * split;
  GtsSplitClass * split_class;
  guint pos, min;

  GPtrArray * vertices;
  GPtrArray * faces;
};

The progressive surface object. derived from GtsObject. The field s is the GtsSurface being refined or coarsened by operations on the progressive surface. All the other fields must be considered private and accessed only through the following functions.

gts_psurface_class ()

GtsPSurfaceClass* gts_psurface_class        (void);

gts_psurface_new ()

GtsPSurface* gts_psurface_new               (GtsPSurfaceClass *klass,
                                             GtsSurface *surface,
                                             GtsSplitClass *split_class,
                                             GtsKeyFunc cost_func,
                                             gpointer cost_data,
                                             GtsCoarsenFunc coarsen_func,
                                             gpointer coarsen_data,
                                             GtsStopFunc stop_func,
                                             gpointer stop_data,
                                             gdouble minangle);

This function works in exactly the same way as the gts_surface_coarsen() function, except that the history of edge collapse is saved in an array of GtsSplit objects. This allows for dynamic continuous multiresolution control of the input surface.

gts_psurface_add_vertex ()

GtsSplit*   gts_psurface_add_vertex         (GtsPSurface *ps);

Adds a vertex to the progressive surface ps by expanding the next available GtsSplit.

gts_psurface_remove_vertex ()

GtsSplit*   gts_psurface_remove_vertex      (GtsPSurface *ps);

Removes one vertex from the progressive surface ps by collapsing the first available GtsSplit.

gts_psurface_set_vertex_number ()

void        gts_psurface_set_vertex_number  (GtsPSurface *ps,
                                             guint n);

Performs the required number of collapses or expansions to set the number of vertices of ps to n.

gts_psurface_get_vertex_number ()

guint       gts_psurface_get_vertex_number  (GtsPSurface *ps);

gts_psurface_min_vertex_number ()

guint       gts_psurface_min_vertex_number  (GtsPSurface *ps);

gts_psurface_max_vertex_number ()

guint       gts_psurface_max_vertex_number  (GtsPSurface *ps);

gts_psurface_foreach_vertex ()

void        gts_psurface_foreach_vertex     (GtsPSurface *ps,
                                             GtsFunc func,
                                             gpointer data);

Calls func for each (potential) vertex of ps, whether actually used or not. The vertices are called in the order they were created during the edge collapse operation.

gts_psurface_open ()

GtsPSurface* gts_psurface_open              (GtsPSurfaceClass *klass,
                                             GtsSurface *s,
                                             GtsSplitClass *split_class,
                                             GtsFile *f);

Creates a new GtsPSurface prepared for input from the file f containing a valid GTS representation of a progressive surface. The initial shape of the progressive surface is loaded into s.

Before being usable as such this progressive surface must be closed using gts_psurface_close(). While open however, the functions gts_psurface_get_vertex_number(), gts_psurface_min_vertex_number() and gts_psurface_max_vertex_number() can still be used.

gts_psurface_read_vertex ()

GtsSplit*   gts_psurface_read_vertex        (GtsPSurface *ps,
                                             GtsFile *fp);

Reads in one vertex split operation from fp and performs the expansion.

If an error occurs while reading the file, the error field of fp is set.

gts_psurface_close ()

void        gts_psurface_close              (GtsPSurface *ps);

Closes a progressive surface.

gts_psurface_write ()

void        gts_psurface_write              (GtsPSurface *ps,
                                             FILE *fptr);

Writes to fptr a GTS progressive surface description.