Vertex split

Details

GTS_SPLIT_CLASS()

#define     GTS_SPLIT_CLASS(klass)

Casts klass to GtsSplitClass.

klass :

a descendant of GtsSplitClass.

GTS_SPLIT()

#define     GTS_SPLIT(obj)

Casts obj to GtsSplit.

obj :

a descendant of GtsSplit.

GTS_IS_SPLIT()

#define     GTS_IS_SPLIT(obj)

Evaluates to TRUE if obj is a GtsSplit.

obj :

a pointer to test.

GTS_SPLIT_V1()

#define     GTS_SPLIT_V1(vs)

Evaluates to the first vertex of the edge collapsed by vs.

vs :

a GtsSplit.

GTS_SPLIT_V2()

#define     GTS_SPLIT_V2(vs)

Evaluates to the second vertex of the edge collapsed by vs.

vs :

a GtsSplit.

GtsSplitClass

typedef struct {
  GtsObjectClass parent_class;
} GtsSplitClass;

The vertex split class.

GtsSplitCFace

typedef struct _GtsSplitCFace GtsSplitCFace;

An opaque structure describing the faces collapsed by a vertex split.

GtsSplit

typedef struct {
  GtsObject object;

  GtsVertex * v;
  GtsObject * v1;
  GtsObject * v2;
  GtsSplitCFace * cfaces;
  guint ncf;
} GtsSplit;

The vertex split object. If v1 is a GtsSplit the corresponding vertex can be found in GTS_SPLIT(v1)->v. This conversion is performed directly by the two macros GTS_SPLIT_V1 and GTS_SPLIT_V2. Together with the current GtsSplit, v1 and v2 define one level of a vertex split tree. If v1 or v2 are both GtsVertex, the current vertex split is a leaf of the tree.

GtsObject `object`;
GtsVertex *`v`;	Vertex to be split.
GtsObject *`v1`;	Either a GtsSplit or GtsVertex, first vertex of the edge to be expanded.
GtsObject *`v2`;	Either a GtsSplit or GtsVertex, second vertex of the edge to be expanded.
GtsSplitCFace *`cfaces`;	An array of GtsSplitCFace describing the faces collapsed by the vertex split.
guint `ncf`;	Number of faces collapsed in `cfaces`.

gts_split_class ()

GtsSplitClass* gts_split_class              (void);

Returns :

the GtsSplitClass.

gts_split_new ()

GtsSplit*   gts_split_new                   (GtsSplitClass *klass,
                                             GtsVertex *v,
                                             GtsObject *o1,
                                             GtsObject *o2);

Creates a new GtsSplit which would collapse o1 and o2 into v. The collapse itself is not performed.

`klass` :	a GtsSplitClass.
`v` :	a GtsVertex.
`o1` :	either a GtsVertex or a GtsSplit.
`o2` :	either a GtsVertex or a GtsSplit.
Returns :	the new GtsSplit.

gts_split_collapse ()

void        gts_split_collapse              (GtsSplit *vs,
                                             GtsEdgeClass *klass,
                                             GtsEHeap *heap);

Collapses the vertex split vs. Any new edge created during the process will be of class klass. If heap is not NULL, the new edges will be inserted into it and the destroyed edges will be removed from it.

`vs` :	a GtsSplit.
`klass` :	a GtsEdgeClass.
`heap` :	a GtsEHeap or `NULL`.

gts_split_expand ()

void        gts_split_expand                (GtsSplit *vs,
                                             GtsSurface *s,
                                             GtsEdgeClass *klass);

Expands the vertex split vs adding the newly created faces to s. Any new edge will be of class klass.

`vs` :	a GtsSplit.
`s` :	a GtsSurface.
`klass` :	a GtsEdgeClass.

gts_split_height ()

guint       gts_split_height                (GtsSplit *root);

`root` :	a GtsSplit.
Returns :	the maximum height of the vertex split tree having `root` as root.

GtsSplitTraverseFunc ()

gboolean    (*GtsSplitTraverseFunc)         (GtsSplit *vs,
                                             gpointer data);

A user-defined function to be called when traversing a vertex split tree.

`vs` :	the GtsSplit for which this function is called.
`data` :	user data passed to the function.
Returns :	`TRUE` to stop the traversal, `FALSE` to continue.

gts_split_traverse ()

void        gts_split_traverse              (GtsSplit *root,
                                             GTraverseType order,
                                             gint depth,
                                             GtsSplitTraverseFunc func,
                                             gpointer data);

Traverses the GtsSplit tree having root as root. Calls func for each GtsSplit of the tree in the order specified by order. If order is set to G_PRE_ORDER func is called for the GtsSplit then its children, if order is set to G_POST_ORDER func is called for the children and then for the GtsSplit.

`root` :	the GtsSplit to start the traversal from.
`order` :	the order in which nodes are visited - G_PRE_ORDER or G_POST_ORDER.
`depth` :	the maximum depth of the traversal. Nodes below this depth will not be visited. If depth is -1 all nodes in the tree are visited. If depth is 1, only the root is visited. If depth is 2, the root and its children are visited. And so on.
`func` :	the function to call for each visited GtsHSplit.
`data` :	user data to pass to the function.