/* GTS - Library for the manipulation of triangulated surfaces * Copyright (C) 1999 Stéphane Popinet * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #include #include #include #include "gts.h" static void prepend_triangle_bbox (GtsTriangle * t, GSList ** bboxes) { *bboxes = g_slist_prepend (*bboxes, gts_bbox_triangle (gts_bbox_class (), t)); } static void check_edge (GtsEdge * e, gpointer * data) { GtsSurface * s1 = data[0]; GtsSurface * s2 = data[1]; guint * nf = data[2]; if (gts_edge_is_boundary (e, s1) && !gts_edge_is_boundary (e, s2)) { GtsPoint * p1 = GTS_POINT (GTS_SEGMENT (e)->v1); GtsPoint * p2 = GTS_POINT (GTS_SEGMENT (e)->v2); printf ("VECT 1 2 0 2 0 %g %g %g %g %g %g\n", p1->x, p1->y, p1->z, p2->x, p2->y, p2->z); (*nf)++; } } int main (int argc, char * argv[]) { GtsSurface * s1, * s2; GtsSurface * s1out2, * s1in2, * s2out1, * s2in1; GtsSurfaceInter * si; GNode * tree1, * tree2; gboolean is_open1, is_open2; GSList * bboxes; FILE * fptr; GtsFile * fp; guint n; gboolean closed = TRUE; if (argc != 3) { fprintf (stderr, "%s: test boolean operations between surfaces\n" "usage: %s FILE1 FILE2\n", argv[0], argv[0]); return 1; } /* open first file */ if ((fptr = fopen (argv[1], "rt")) == NULL) { fprintf (stderr, "%s: can not open file `%s'\n", argv[0], argv[2]); return 1; } /* reads in first surface file */ s1 = gts_surface_new (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 (s1, fp)) { fprintf (stderr, "boole: `%s' is not a valid GTS surface file\n", argv[1]); fprintf (stderr, "%s:%d:%d: %s\n", argv[1], fp->line, fp->pos, fp->error); return 1; } gts_file_destroy (fp); fclose (fptr); /* open second file */ if ((fptr = fopen (argv[2], "rt")) == NULL) { fprintf (stderr, "%s: can not open file `%s'\n", argv[0], argv[3]); return 1; } /* reads in second surface file */ s2 = gts_surface_new (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 (s2, fp)) { fprintf (stderr, "boole: `%s' is not a valid GTS surface file\n", argv[2]); fprintf (stderr, "%s:%d:%d: %s\n", argv[2], fp->line, fp->pos, fp->error); return 1; } gts_file_destroy (fp); fclose (fptr); /* display summary information about both surfaces */ #if 0 gts_surface_print_stats (s1, stderr); gts_surface_print_stats (s2, stderr); #endif /* check surfaces */ g_assert (gts_surface_is_orientable (s1)); g_assert (gts_surface_is_orientable (s2)); g_assert (!gts_surface_is_self_intersecting (s1)); g_assert (!gts_surface_is_self_intersecting (s2)); /* build bounding boxes for first surface */ bboxes = NULL; gts_surface_foreach_face (s1, (GtsFunc) prepend_triangle_bbox, &bboxes); /* build bounding box tree for first surface */ tree1 = gts_bb_tree_new (bboxes); /* free list of bboxes */ g_slist_free (bboxes); is_open1 = gts_surface_volume (s1) < 0. ? TRUE : FALSE; /* build bounding boxes for second surface */ bboxes = NULL; gts_surface_foreach_face (s2, (GtsFunc) prepend_triangle_bbox, &bboxes); /* build bounding box tree for second surface */ tree2 = gts_bb_tree_new (bboxes); /* free list of bboxes */ g_slist_free (bboxes); is_open2 = gts_surface_volume (s2) < 0. ? TRUE : FALSE; si = gts_surface_inter_new (gts_surface_inter_class (), s1, s2, tree1, tree2, is_open1, is_open2); g_assert (gts_surface_inter_check (si, &closed)); s1out2 = gts_surface_new (gts_surface_class (), gts_face_class (), gts_edge_class (), gts_vertex_class ()); s1in2 = gts_surface_new (gts_surface_class (), gts_face_class (), gts_edge_class (), gts_vertex_class ()); s2out1 = gts_surface_new (gts_surface_class (), gts_face_class (), gts_edge_class (), gts_vertex_class ()); s2in1 = gts_surface_new (gts_surface_class (), gts_face_class (), gts_edge_class (), gts_vertex_class ()); if (closed) { GtsSurfaceStats st1out2, st1in2, st2out1, st2in1; gpointer data[3]; guint nf = 0; gdouble a, ain, aout; gts_surface_inter_boolean (si, s1out2, GTS_1_OUT_2); gts_surface_inter_boolean (si, s1in2, GTS_1_IN_2); gts_surface_inter_boolean (si, s2out1, GTS_2_OUT_1); gts_surface_inter_boolean (si, s2in1, GTS_2_IN_1); gts_surface_stats (s1out2, &st1out2); fprintf (stderr, "----------- 1 out 2 -----------\n"); gts_surface_print_stats (s1out2, stderr); g_assert (st1out2.n_incompatible_faces == 0 && st1out2.n_non_manifold_edges == 0); gts_surface_stats (s1in2, &st1in2); fprintf (stderr, "----------- 1 in 2 -----------\n"); gts_surface_print_stats (s1in2, stderr); g_assert (st1in2.n_incompatible_faces == 0 && st1in2.n_non_manifold_edges == 0 && st1in2.n_boundary_edges == st1out2.n_boundary_edges); a = gts_surface_area (s1); aout = gts_surface_area (s1out2); ain = gts_surface_area (s1in2); if (a > 0.) { a = fabs (a - aout - ain)/a; g_assert (a < 1e-9); } gts_surface_stats (s2out1, &st2out1); fprintf (stderr, "----------- 2 out 1 -----------\n"); gts_surface_print_stats (s2out1, stderr); g_assert (st2out1.n_incompatible_faces == 0 && st2out1.n_non_manifold_edges == 0); gts_surface_stats (s2in1, &st2in1); fprintf (stderr, "----------- 2 in 1 -----------\n"); gts_surface_print_stats (s2in1, stderr); g_assert (st2in1.n_incompatible_faces == 0 && st2in1.n_non_manifold_edges == 0 && st2in1.n_boundary_edges == st2out1.n_boundary_edges); a = gts_surface_area (s2); aout = gts_surface_area (s2out1); ain = gts_surface_area (s2in1); if (a > 0.) { a = fabs (a - aout - ain)/a; g_assert (a < 1e-9); } n = g_slist_length (si->edges); g_assert (n == st1in2.n_boundary_edges && n == st2in1.n_boundary_edges); data[0] = s1out2; data[1] = s1in2; data[2] = &nf; printf ("(geometry \"s1 failed\" = LIST {\n"); gts_surface_foreach_edge (s1out2, (GtsFunc) check_edge, data); printf ("})\n"); data[0] = s2out1; data[1] = s2in1; data[2] = &nf; printf ("(geometry \"s2 failed\" = LIST {\n"); gts_surface_foreach_edge (s2out1, (GtsFunc) check_edge, data); printf ("})\n"); g_assert (nf == 0); } else { fprintf (stderr, "----------- 1 out 2 -----------\n"); gts_surface_print_stats (s1out2, stderr); fprintf (stderr, "----------- 1 in 2 -----------\n"); gts_surface_print_stats (s1in2, stderr); fprintf (stderr, "----------- 2 out 1 -----------\n"); gts_surface_print_stats (s2out1, stderr); fprintf (stderr, "----------- 2 in 1 -----------\n"); gts_surface_print_stats (s2in1, stderr); } printf ("(geometry \"1out2\" { =\n"); gts_surface_write_oogl (s1out2, stdout); printf ("})\n" "(normalization \"1out2\" none)\n"); printf ("(geometry \"1in2\" { =\n"); gts_surface_write_oogl (s1in2, stdout); printf ("})\n" "(normalization \"1in2\" none)\n"); printf ("(geometry \"2out1\" { =\n"); gts_surface_write_oogl (s2out1, stdout); printf ("})\n" "(normalization \"2out1\" none)\n"); printf ("(geometry \"2in1\" { =\n"); gts_surface_write_oogl (s2in1, stdout); printf ("})\n" "(normalization \"2in1\" none)\n"); /* destroy surfaces and intersection */ gts_object_destroy (GTS_OBJECT (s1)); gts_object_destroy (GTS_OBJECT (s2)); 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); return 0; }