/**
* gts_edge_is_contact:
* @e: a #GtsEdge.
*
* Returns: the number of sets of connected triangles sharing @e as a
* contact edge.
*/
guint gts_edge_is_contact (GtsEdge * e)
{
GSList * i, * triangles;
guint ncomponent = 0;
g_return_val_if_fail (e != NULL, 0);
triangles = gts_vertex_triangles (GTS_SEGMENT (e)->v1, NULL);
i = triangles = gts_vertex_triangles (GTS_SEGMENT (e)->v2, triangles);
while (i) {
GTS_OBJECT (i->data)->reserved = i;
i = i->next;
}
i = e->triangles;
while (i) {
GtsTriangle * t = i->data;
if (GTS_OBJECT (t)->reserved) {
GtsEdge * e1;
GTS_OBJECT (t)->reserved = NULL;
e1 = next_edge (t, NULL, e);
triangle_next (e1, e);
triangle_next (next_edge (t, e1, e), e);
ncomponent++;
}
i = i->next;
}
g_slist_foreach (triangles, (GFunc) gts_object_reset_reserved, NULL);
g_slist_free (triangles);
return ncomponent;
}
PygtsSegment *
pygts_segment_new(GtsSegment *s)
{
PyObject *args, *kwds;
PygtsObject *segment;
/* Check for Segment in the object table */
if( (segment=PYGTS_OBJECT(g_hash_table_lookup(obj_table,GTS_OBJECT(s))))
!= NULL ) {
Py_INCREF(segment);
return PYGTS_FACE(segment);
}
/* Build a new Segment */
args = Py_BuildValue("OO",Py_None,Py_None);
kwds = Py_BuildValue("{s:O}","alloc_gtsobj",Py_False);
segment = PYGTS_SEGMENT(PygtsSegmentType.tp_new(&PygtsSegmentType,
args, kwds));
Py_DECREF(args);
Py_DECREF(kwds);
if( segment == NULL ) {
PyErr_SetString(PyExc_MemoryError,"could not create Segment");
return NULL;
}
segment->gtsobj = GTS_OBJECT(s);
/* Register and return */
pygts_object_register(segment);
return PYGTS_SEGMENT(segment);
}
static void gfs_init_wave_destroy (GtsObject * object)
{
gts_object_destroy (GTS_OBJECT (GFS_INIT_WAVE (object)->d));
gts_object_destroy (GTS_OBJECT (GFS_INIT_WAVE (object)->hs));
(* GTS_OBJECT_CLASS (gfs_init_wave_class ())->parent_class->destroy) (object);
}
PygtsVertex *
pygts_vertex_new(GtsVertex *v)
{
PyObject *args, *kwds;
PygtsObject *vertex;
/* Check for Vertex in the object table */
if( (vertex = PYGTS_OBJECT(g_hash_table_lookup(obj_table,GTS_OBJECT(v))))
!=NULL ) {
Py_INCREF(vertex);
return PYGTS_VERTEX(vertex);
}
/* Build a new Vertex */
args = Py_BuildValue("ddd",0,0,0);
kwds = Py_BuildValue("{s:O}","alloc_gtsobj",Py_False);
vertex = PYGTS_VERTEX(PygtsVertexType.tp_new(&PygtsVertexType, args, kwds));
Py_DECREF(args);
Py_DECREF(kwds);
if( vertex == NULL ) {
PyErr_SetString(PyExc_MemoryError,"could not create Vertex");
return NULL;
}
vertex->gtsobj = GTS_OBJECT(v);
/* Attach the parent */
if( (vertex->gtsobj_parent=parent(v)) == NULL ) {
Py_DECREF(vertex);
return NULL;
}
/* Register and return */
pygts_object_register(vertex);
return PYGTS_VERTEX(vertex);
}
static void add_unused (GtsGNode * n, GtsGraph * g2)
{
if (GTS_OBJECT (n)->reserved)
GTS_OBJECT (n)->reserved = NULL;
else
gts_container_add (GTS_CONTAINER (g2), GTS_CONTAINEE (n));
}
/**
* gts_bb_tree_point_closest:
* @tree: a bounding box tree.
* @p: a #GtsPoint.
* @closest: a #GtsBBoxClosestFunc.
* @distance: if not %NULL is set to the distance between @p and the
* new #GtsPoint.
*
* Returns: a new #GtsPoint, closest point to @p and belonging to an object of
* @tree.
*/
GtsPoint * gts_bb_tree_point_closest (GNode * tree,
GtsPoint * p,
GtsBBoxClosestFunc closest,
gdouble * distance)
{
GSList * list, * i;
gdouble dmin = G_MAXDOUBLE;
GtsPoint * np = NULL;
g_return_val_if_fail (tree != NULL, NULL);
g_return_val_if_fail (p != NULL, NULL);
g_return_val_if_fail (closest != NULL, NULL);
i = list = gts_bb_tree_point_closest_bboxes (tree, p);
while (i) {
GtsPoint * tp = (*closest) (p, GTS_BBOX (i->data)->bounded);
gdouble d = gts_point_distance2 (tp, p);
if (d < dmin) {
if (np)
gts_object_destroy (GTS_OBJECT (np));
np = tp;
dmin = d;
}
else
gts_object_destroy (GTS_OBJECT (tp));
i = i->next;
}
g_slist_free (list);
if (distance)
*distance = dmin;
return np;
}
PygtsFace *
pygts_face_new(GtsFace *f)
{
PyObject *args, *kwds;
PygtsObject *face;
/* Check for Face in the object table */
if( (face=PYGTS_OBJECT(g_hash_table_lookup(obj_table,GTS_OBJECT(f))))
!= NULL ) {
Py_INCREF(face);
return PYGTS_FACE(face);
}
/* Build a new Face */
args = Py_BuildValue("OOO",Py_None,Py_None,Py_None);
kwds = Py_BuildValue("{s:O}","alloc_gtsobj",Py_False);
face = PYGTS_OBJECT(PygtsFaceType.tp_new(&PygtsFaceType, args, kwds));
Py_DECREF(args);
Py_DECREF(kwds);
if( face == NULL ) {
PyErr_SetString(PyExc_MemoryError, "could not create Face");
return NULL;
}
face->gtsobj = GTS_OBJECT(f);
/* Attach the parent */
if( (face->gtsobj_parent = parent(f)) == NULL ) {
Py_DECREF(face);
return NULL;
}
/* Register and return */
pygts_object_register(face);
return PYGTS_FACE(face);
}
void
pygts_face_cleanup(GtsSurface * s)
{
GSList *triangles = NULL;
GSList * i;
g_return_if_fail(s != NULL);
/* build list of triangles */
gts_surface_foreach_face(s, (GtsFunc) build_list, &triangles);
/* remove duplicate and degenerate triangles */
i = triangles;
while(i) {
GtsTriangle * t = (GtsTriangle*)i->data;
if (!gts_triangle_is_ok(t)) {
/* destroy t, its edges (if not used by any other triangle)
and its corners (if not used by any other edge) */
if( g_hash_table_lookup(obj_table,GTS_OBJECT(t))==NULL ) {
gts_object_destroy(GTS_OBJECT(t));
}
else {
gts_surface_remove_face(PYGTS_SURFACE_AS_GTS_SURFACE(s),GTS_FACE(t));
}
}
i = g_slist_next(i);
}
/* free list of triangles */
g_slist_free(triangles);
}
static void add_neighbor (GtsGNode * n, GtsEHeap * heap)
{
if (GTS_OBJECT (n)->reserved == n)
return;
if (GTS_OBJECT (n)->reserved)
gts_eheap_remove (heap, GTS_OBJECT (n)->reserved);
GTS_OBJECT (n)->reserved = gts_eheap_insert (heap, n);
}
static void write_edge (GtsSegment * s, guint * ne)
{
printf (" GtsEdge * e%u = gts_edge_new (gts_edge_class (), v%u, v%u);\n",
*ne,
GPOINTER_TO_UINT (GTS_OBJECT (s->v1)->reserved),
GPOINTER_TO_UINT (GTS_OBJECT (s->v2)->reserved));
GTS_OBJECT (s)->reserved = GUINT_TO_POINTER ((*ne)++);
}
static GtsSurface * happrox_list (GSList * points,
gboolean keep_enclosing,
gboolean closed,
CostFunc cost_func,
gpointer cost_data,
GtsStopFunc stop_func,
gpointer stop_data)
{
GtsSurface * s = gts_surface_new (gts_surface_class (),
GTS_FACE_CLASS (list_face_class ()),
gts_edge_class (),
gts_vertex_class ());
GtsTriangle * t;
GtsVertex * w1, * w2, * w3;
GtsListFace * f;
/* creates enclosing triangle */
t = gts_triangle_enclosing (gts_triangle_class (), points, 10.);
gts_triangle_vertices (t, &w1, &w2, &w3);
GTS_POINT (w1)->z = GTS_POINT (w2)->z = GTS_POINT (w3)->z =
keep_enclosing ? -10. : -1e30;
f = GTS_LIST_FACE (gts_face_new (s->face_class, t->e1, t->e2, t->e3));
gts_surface_add_face (s, GTS_FACE (f));
f->points = points;
/* refine surface */
surface_hf_refine (s, cost_func, cost_data, stop_func, stop_data);
/* destroy unused vertices */
gts_surface_foreach_face (s, (GtsFunc) destroy_unused, NULL);
/* destroy enclosing triangle */
if (!keep_enclosing) {
gts_allow_floating_vertices = TRUE;
gts_object_destroy (GTS_OBJECT (w1));
gts_object_destroy (GTS_OBJECT (w2));
gts_object_destroy (GTS_OBJECT (w3));
gts_allow_floating_vertices = FALSE;
}
else if (closed) {
GSList * l = gts_surface_boundary (s);
GtsFace * f;
g_assert (g_slist_length (l) == 3);
f = gts_face_new (s->face_class, l->data, l->next->data, l->next->next->data);
gts_surface_add_face (s, f);
if (!gts_face_is_compatible (f, s))
gts_triangle_revert (GTS_TRIANGLE (f));
g_slist_free (l);
gts_object_destroy (GTS_OBJECT (t));
}
else
gts_object_destroy (GTS_OBJECT (t));
return s;
}
static void write_face (GtsTriangle * t, guint * nf)
{
printf (" GtsFace * f%u = gts_face_new (gts_face_class (),\n"
" e%u, e%u, e%u);\n",
(*nf)++,
GPOINTER_TO_UINT (GTS_OBJECT (t->e1)->reserved),
GPOINTER_TO_UINT (GTS_OBJECT (t->e2)->reserved),
GPOINTER_TO_UINT (GTS_OBJECT (t->e3)->reserved));
}
int main (int argc, char * argv[])
{
GtsSurface * s;
GtsBBox * bbox;
gdouble delta;
GtsPoint * p1, * p2, * p3;
guint nt;
GtsRange cluster_stats;
GtsClusterGrid * cluster_grid;
if (argc != 2) {
fprintf (stderr, "usage: oocs DELTA < infile > outfile\n");
return 1;
}
s = gts_surface_new (gts_surface_class (),
gts_face_class (),
gts_edge_class (),
gts_vertex_class ());
bbox = gts_bbox_new (gts_bbox_class (), s, 0., 0., 0., 0., 0., 0.);
scanf ("%u", &nt);
scanf ("%lf %lf %lf", &bbox->x1, &bbox->y1, &bbox->z1);
scanf ("%lf %lf %lf", &bbox->x2, &bbox->y2, &bbox->z2);
delta = atof (argv[1])*sqrt (gts_bbox_diagonal2 (bbox));
cluster_grid = gts_cluster_grid_new (gts_cluster_grid_class (),
gts_cluster_class (),
s, bbox, delta);
p1 = gts_point_new (gts_point_class (), 0., 0., 0.);
p2 = gts_point_new (gts_point_class (), 0., 0., 0.);
p3 = gts_point_new (gts_point_class (), 0., 0., 0.);
while (scanf ("%lf %lf %lf", &p1->x, &p1->y, &p1->z) == 3 &&
scanf ("%lf %lf %lf", &p2->x, &p2->y, &p2->z) == 3 &&
scanf ("%lf %lf %lf", &p3->x, &p3->y, &p3->z) == 3)
gts_cluster_grid_add_triangle (cluster_grid, p1, p2, p3, NULL);
cluster_stats = gts_cluster_grid_update (cluster_grid);
gts_object_destroy (GTS_OBJECT (p1));
gts_object_destroy (GTS_OBJECT (p2));
gts_object_destroy (GTS_OBJECT (p3));
gts_object_destroy (GTS_OBJECT (cluster_grid));
fprintf (stderr, "Initial number of triangles: %u\n", nt);
fprintf (stderr, "%d clusters of size: min: %g avg: %.1f|%.1f max: %g\n",
cluster_stats.n,
cluster_stats.min,
cluster_stats.mean, cluster_stats.stddev,
cluster_stats.max);
gts_surface_print_stats (s, stderr);
gts_surface_write (s, stdout);
return 0;
}
/**
* gts_edge_swap:
* @e: a #GtsEdge.
* @s: a #GtsSurface.
*
* Performs an "edge swap" on the two triangles sharing @e and
* belonging to @s.
*/
void gts_edge_swap (GtsEdge * e, GtsSurface * s)
{
GtsTriangle * t1 = NULL, * t2 = NULL, * t;
GtsFace * f;
GSList * i;
GtsVertex * v1, * v2, * v3, * v4, * v5, * v6;
GtsEdge * e1, * e2, * e3, * e4;
GtsSegment * v3v6;
g_return_if_fail (e != NULL);
g_return_if_fail (s != NULL);
i = e->triangles;
while (i) {
if (GTS_IS_FACE (i->data) && gts_face_has_parent_surface (i->data, s)) {
if (!t1)
t1 = i->data;
else if (!t2)
t2 = i->data;
else
g_return_if_fail (gts_edge_face_number (e, s) == 2);
}
i = i->next;
}
g_assert (t1 && t2);
gts_triangle_vertices_edges (t1, e, &v1, &v2, &v3, &e, &e1, &e2);
gts_triangle_vertices_edges (t2, e, &v4, &v5, &v6, &e, &e3, &e4);
g_assert (v2 == v4 && v1 == v5);
v3v6 = gts_vertices_are_connected (v3, v6);
if (!GTS_IS_EDGE (v3v6))
v3v6 = GTS_SEGMENT (gts_edge_new (s->edge_class, v3, v6));
f = gts_face_new (s->face_class, e1, GTS_EDGE (v3v6), e4);
if ((t = gts_triangle_is_duplicate (GTS_TRIANGLE (f))) &&
GTS_IS_FACE (t)) {
gts_object_destroy (GTS_OBJECT (f));
f = GTS_FACE (t);
}
gts_surface_add_face (s, f);
f = gts_face_new (s->face_class, GTS_EDGE (v3v6), e2, e3);
if ((t = gts_triangle_is_duplicate (GTS_TRIANGLE (f))) &&
GTS_IS_FACE (t)) {
gts_object_destroy (GTS_OBJECT (f));
f = GTS_FACE (t);
}
gts_surface_add_face (s, f);
gts_surface_remove_face (s, GTS_FACE (t1));
gts_surface_remove_face (s, GTS_FACE (t2));
}
static void triangle_next (GtsEdge * e1, GtsEdge * e)
{
GSList * i;
i = e1->triangles;
while (i) {
GtsTriangle * t = i->data;
if (GTS_OBJECT (t)->reserved) {
GTS_OBJECT (t)->reserved = NULL;
triangle_next (next_edge (t, e1, e), e);
}
i = i->next;
}
}
ofxGtsSurface::~ofxGtsSurface() {
if(loaded) {
/* destroy surfaces and intersection */
gts_object_destroy(GTS_OBJECT(surface));
if(boolPerformed) {
gts_object_destroy(GTS_OBJECT(si));
/* destroy bounding box trees (including bounding boxes) */
gts_bb_tree_destroy(tree1, TRUE);
gts_bb_tree_destroy(tree2, TRUE);
}
}
}
/**
* gts_graph_bisection_destroy:
* @bg: a #GtsGraphBisection.
* @destroy_graphs: controls graph destruction.
*
* Frees all the memory allocated for @bg. If @destroy_graphs is %TRUE
* the graphs created by @bg are destroyed.
*/
void gts_graph_bisection_destroy (GtsGraphBisection * bg,
gboolean destroy_graphs)
{
g_return_if_fail (bg != NULL);
g_hash_table_destroy (bg->bg1);
g_hash_table_destroy (bg->bg2);
if (destroy_graphs) {
gts_object_destroy (GTS_OBJECT (bg->g1));
gts_object_destroy (GTS_OBJECT (bg->g2));
}
g_free (bg);
}
static void list_face_update (ListFace * f, gpointer * data)
{
if (IS_LIST_FACE (f)) {
GSList * i = GTS_LIST_FACE (f)->points;
GtsEHeap * heap = data[0];
CostFunc cost = data[1];
gpointer cost_data = data[2];
if (i) {
gdouble maxerr = 0.;
ListFaceClass * klass = LIST_FACE_CLASS (GTS_OBJECT (f)->klass);
(* klass->cost_init) (f);
f->best = NULL;
while (i) {
GtsPoint * v = i->data;
gdouble e = (* cost) (f, v, cost_data);
if (e > maxerr) {
maxerr = e;
f->best = GTS_VERTEX (v);
}
i = i->next;
}
if (f->heap) {
gts_eheap_remove (f->heap, f->pair);
f->heap = NULL;
}
if (maxerr > 0.) {
f->pair = gts_eheap_insert_with_key (heap, f, - maxerr);
f->heap = heap;
}
}
}
}
void ofxGtsSurface::setup(string filename) {
FILE * fptr;
GtsFile * fp;
string filePath = ofToDataPath(filename);
/* open first file */
if ((fptr = fopen (filePath.c_str(), "rt")) == NULL) {
ofLog(OF_LOG_ERROR, "Cannot open file: " + filePath);
return;
}
/* reads in first surface file */
surface = gts_surface_new(GTS_SURFACE_CLASS(gts_surface_class()),
GTS_FACE_CLASS(gts_nface_class()),
GTS_EDGE_CLASS(gts_nedge_class()),
GTS_VERTEX_CLASS(gts_nvertex_class()));
fp = gts_file_new(fptr);
if (gts_surface_read (surface, fp)) {
ofLog(OF_LOG_ERROR, filePath + " is not a valid GTS surface file");
loaded = false;
gts_object_destroy(GTS_OBJECT(surface));
} else {
ofLog(OF_LOG_NOTICE, "Gts surface file read: " + filePath);
loaded = true;
}
gts_file_destroy (fp);
fclose (fptr);
}
static void gts_triangulate_test_stuff()
{
gdouble v[4][3] = {
{0.0, 0.0, 0.0},
{0.0, 3.0, 0.0},
{3.0, 3.0, 0.0},
{1.0, 1.0, 0.0}
};
int i;
GtsVertex *vtx[4];
GCList *polygon = NULL;
GtsVector orient;
GCList *p;
for (i = 0; i < 4; ++i) {
vtx[i] = gts_vertex_new(gts_vertex_class(), v[i][0],v[i][1],v[i][2]);
polygon = g_clist_append(polygon, vtx[i]);
}
g_assert(g_clist_length(polygon));
g_assert(gts_polygon_orientation(polygon, orient));
g_assert(orient[0] == 0 && orient[1] == 0 && orient[2] < 0);
p = g_clist_next(polygon);
g_assert(is_convex(GTS_POINT(p->prev->data), GTS_POINT(p->data),GTS_POINT(p->next->data), orient));
g_assert(is_inside(GTS_POINT(vtx[0]), GTS_POINT(vtx[1]), GTS_POINT(vtx[2]), GTS_POINT(vtx[3])));
g_assert(!is_inside(GTS_POINT(vtx[0]), GTS_POINT(vtx[1]), GTS_POINT(vtx[3]), GTS_POINT(vtx[2])));
g_clist_free(p);
for (i = 0; i < 4; ++i)
gts_object_destroy(GTS_OBJECT(vtx[i]));
}
v_data *delaunay_triangulation(double *x, double *y, int n)
{
v_data *delaunay;
GtsSurface* s = tri(x, y, n, NULL, 0, 1);
int i, nedges;
int* edges;
estats stats;
if (!s) return NULL;
delaunay = N_GNEW(n, v_data);
for (i = 0; i < n; i++) {
delaunay[i].ewgts = NULL;
delaunay[i].nedges = 1;
}
stats.n = 0;
stats.delaunay = delaunay;
edgeStats (s, &stats);
nedges = stats.n;
edges = N_GNEW(2 * nedges + n, int);
for (i = 0; i < n; i++) {
delaunay[i].edges = edges;
edges += delaunay[i].nedges;
delaunay[i].edges[0] = i;
delaunay[i].nedges = 1;
}
gts_surface_foreach_edge (s, (GtsFunc) add_edge, delaunay);
gts_object_destroy (GTS_OBJECT (s));
return delaunay;
}
/**
* gts_triangle_is_ok:
* @t: a #GtsTriangle.
*
* Returns: %TRUE if @t is a non-degenerate, non-duplicate triangle,
* %FALSE otherwise.
*/
gboolean gts_triangle_is_ok (GtsTriangle * t)
{
g_return_val_if_fail (t != NULL, FALSE);
g_return_val_if_fail (t->e1 != NULL, FALSE);
g_return_val_if_fail (t->e2 != NULL, FALSE);
g_return_val_if_fail (t->e3 != NULL, FALSE);
g_return_val_if_fail (t->e1 != t->e2 && t->e1 != t->e3 && t->e2 != t->e3,
FALSE);
g_return_val_if_fail (gts_segments_touch (GTS_SEGMENT (t->e1),
GTS_SEGMENT (t->e2)),
FALSE);
g_return_val_if_fail (gts_segments_touch (GTS_SEGMENT (t->e1),
GTS_SEGMENT (t->e3)),
FALSE);
g_return_val_if_fail (gts_segments_touch (GTS_SEGMENT (t->e2),
GTS_SEGMENT (t->e3)),
FALSE);
g_return_val_if_fail (GTS_SEGMENT (t->e1)->v1 != GTS_SEGMENT (t->e1)->v2,
FALSE);
g_return_val_if_fail (GTS_SEGMENT (t->e2)->v1 != GTS_SEGMENT (t->e2)->v2,
FALSE);
g_return_val_if_fail (GTS_SEGMENT (t->e3)->v1 != GTS_SEGMENT (t->e3)->v2,
FALSE);
g_return_val_if_fail (GTS_OBJECT (t)->reserved == NULL, FALSE);
g_return_val_if_fail (!gts_triangle_is_duplicate (t), FALSE);
return TRUE;
}
static void gfs_refine_read (GtsObject ** o, GtsFile * fp)
{
GfsRefine * refine = GFS_REFINE (*o);
GtsObjectClass * klass;
gboolean class_changed = FALSE;
if (fp->type != GTS_STRING) {
gts_file_error (fp, "expecting a string (GfsRefineClass)");
return;
}
klass = gfs_object_class_from_name (fp->token->str);
if (klass == NULL) {
gts_file_error (fp, "unknown class `%s'", fp->token->str);
return;
}
if (!gts_object_class_is_from_class (klass, gfs_refine_class ())) {
gts_file_error (fp, "`%s' is not a GfsRefine", fp->token->str);
return;
}
if (klass != (*o)->klass) {
*o = gts_object_new (klass);
gts_object_destroy (GTS_OBJECT (refine));
refine = GFS_REFINE (*o);
class_changed = TRUE;
}
gts_file_next_token (fp);
gfs_function_read (refine->maxlevel, gfs_object_simulation (refine), fp);
if (fp->type == GTS_ERROR)
return;
if (class_changed && fp->type != '\n' && klass->read)
(* klass->read) (o, fp);
}
static void output_spectra_destroy ( GtsObject * o )
{
if (GFS_OUTPUT_SPECTRA (o)->cgd)
gts_object_destroy (GTS_OBJECT (GFS_OUTPUT_SPECTRA (o)->cgd));
(* GTS_OBJECT_CLASS (gfs_output_spectra_class ())->parent_class->destroy) (o);
}
/**
* gts_segment_is_ok:
* @s: a #GtsSegment.
*
* Returns: %TRUE if @s is not degenerate (i.e. @s->v1 != @s->v2) and not
* duplicate, %FALSE otherwise.
*/
gboolean gts_segment_is_ok (GtsSegment * s)
{
g_return_val_if_fail (s != NULL, FALSE);
g_return_val_if_fail (s->v1 != s->v2, FALSE);
g_return_val_if_fail (!gts_segment_is_duplicate (s), FALSE);
g_return_val_if_fail (GTS_OBJECT (s)->reserved == NULL, FALSE);
return TRUE;
}
static void refine_cut_cell (FttCell * cell, GfsGenericSurface * s, RefineCut * p)
{
GTS_OBJECT (s)->reserved = p->surface;
GFS_REFINE_SOLID (p->refine)->v->data = s;
if (ftt_cell_level (cell) < gfs_function_value (p->refine->maxlevel, cell))
ftt_cell_refine_single (cell, p->domain->cell_init, p->domain->cell_init_data);
GFS_REFINE_SOLID (p->refine)->v->data = NULL;
}
static void refine_surface_destroy (GtsObject * object)
{
GfsRefineSurface * d = GFS_REFINE_SURFACE (object);
gts_object_destroy (GTS_OBJECT (d->surface));
(* GTS_OBJECT_CLASS (gfs_refine_surface_class ())->parent_class->destroy) (object);
}
/**
* gts_bb_tree_triangle_distance:
* @tree: a bounding box tree.
* @t: a #GtsTriangle.
* @distance: a #GtsBBoxDistFunc.
* @delta: spatial scale of the sampling to be used.
* @range: a #GtsRange to be filled with the results.
*
* Given a triangle @t, points are sampled regularly on its surface
* using @delta as increment. The distance from each of these points
* to the closest object of @tree is computed using @distance and the
* gts_bb_tree_point_distance() function. The fields of @range are
* filled with the number of points sampled, the minimum, average and
* maximum value and the standard deviation.
*/
void gts_bb_tree_triangle_distance (GNode * tree,
GtsTriangle * t,
GtsBBoxDistFunc distance,
gdouble delta,
GtsRange * range)
{
GtsPoint * p1, * p2, * p3, * p;
GtsVector p1p2, p1p3;
gdouble l1, t1, dt1;
guint i, n1;
g_return_if_fail (tree != NULL);
g_return_if_fail (t != NULL);
g_return_if_fail (distance != NULL);
g_return_if_fail (delta > 0.);
g_return_if_fail (range != NULL);
gts_triangle_vertices (t,
(GtsVertex **) &p1,
(GtsVertex **) &p2,
(GtsVertex **) &p3);
gts_vector_init (p1p2, p1, p2);
gts_vector_init (p1p3, p1, p3);
gts_range_init (range);
p = GTS_POINT (gts_object_new (GTS_OBJECT_CLASS (gts_point_class ())));
l1 = sqrt (gts_vector_scalar (p1p2, p1p2));
n1 = l1/delta + 1;
dt1 = 1.0/(gdouble) n1;
t1 = 0.0;
for (i = 0; i <= n1; i++, t1 += dt1) {
gdouble t2 = 1. - t1;
gdouble x = t2*p1p3[0];
gdouble y = t2*p1p3[1];
gdouble z = t2*p1p3[2];
gdouble l2 = sqrt (x*x + y*y + z*z);
guint j, n2 = (guint) (l2/delta + 1);
gdouble dt2 = t2/(gdouble) n2;
x = t2*p1->x + t1*p2->x;
y = t2*p1->y + t1*p2->y;
z = t2*p1->z + t1*p2->z;
t2 = 0.0;
for (j = 0; j <= n2; j++, t2 += dt2) {
p->x = x + t2*p1p3[0];
p->y = y + t2*p1p3[1];
p->z = z + t2*p1p3[2];
gts_range_add_value (range,
gts_bb_tree_point_distance (tree, p, distance, NULL));
}
}
gts_object_destroy (GTS_OBJECT (p));
gts_range_update (range);
}
static void face_load (GtsTriangle * t, gpointer * data)
{
int *FaceSetList = (int *)data[0];
int *n = (int *)data[1];
GtsVertex * v1, * v2, * v3;
gts_triangle_vertices (t, &v1, &v2, &v3);
FaceSetList[*n*3] = (int)GPOINTER_TO_UINT (GTS_OBJECT (v1)->reserved);
FaceSetList[*n*3+1] =(int) GPOINTER_TO_UINT (GTS_OBJECT (v2)->reserved);
FaceSetList[*n*3+2] = (int)GPOINTER_TO_UINT (GTS_OBJECT (v3)->reserved);
if (debug) {
fprintf (stderr, "Triangle %d: %d %d %d\n",
*n, FaceSetList[*n*3],
FaceSetList[*n*3+1],
FaceSetList[*n*3+2]);
}
GTS_OBJECT (t)->reserved = GUINT_TO_POINTER ((*((guint *) data[1]))++);
*n++; /* does not work, but trick above does */
}
void gts_triangulate_convex_polygon_test()
{
int i;
gdouble v[5][3] = {
{0.0, 0.0, 1.0},
{0.0, 2.0, 2.0},
{2.0, 3.0, 1.0},
{4.0, 1.0, 1.0},
{2.0, 0.0, 0.0}
};
GtsEdgePool *pool = gts_edge_pool_new(gts_edge_pool_class());
GtsVertex *vtx[5];
GCList *polygon = NULL;
GCList *wired = NULL;
GtsSurfaceStats sstats;
for (i = 0; i < 5; ++i) {
vtx[i] = gts_vertex_new(gts_vertex_class(), v[i][0],v[i][1],v[i][2]);
polygon = g_clist_append(polygon, vtx[i]);
}
polygon = g_clist_append(polygon, vtx[0]);
polygon = g_clist_append(polygon, vtx[1]);
wired = g_clist_append(wired, vtx[0]);
wired = g_clist_append(wired, vtx[1]);
wired = g_clist_append(wired, vtx[0]);
wired = g_clist_append(wired, vtx[2]);
GtsSurface *s = gts_surface_new(gts_surface_class(),
gts_face_class(),
gts_edge_class(),
gts_vertex_class());
gts_triangulate_convex_polygon(s, pool, wired);
g_assert(gts_surface_face_number(s) == 0);
gts_triangulate_convex_polygon(s, pool, polygon);
g_message("gts_surface_face_number = %d", gts_surface_face_number(s));
g_assert(gts_surface_face_number(s) == 3);
gts_surface_stats(s, &sstats);
g_assert(sstats.n_incompatible_faces == 0);
g_assert(sstats.n_duplicate_faces == 0);
g_assert(sstats.n_duplicate_edges == 0);
g_assert(sstats.n_boundary_edges == 5);
g_assert(sstats.n_non_manifold_edges == 0);
g_assert(sstats.faces_per_edge.min == 1);
g_assert(sstats.faces_per_edge.max == 2);
g_message("Triangulate convex polygon PASS");
gts_object_destroy(GTS_OBJECT(pool));
}
