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);
}
int main (int argc, char * argv[])
{
GtsSurface * s;
guint i;
GtsFile * fp;
guint nv = 1, ne = 1, nf = 1;
if (!setlocale (LC_ALL, "POSIX"))
g_warning ("cannot set locale to POSIX");
s = gts_surface_new (gts_surface_class (),
gts_face_class (),
gts_edge_class (),
gts_vertex_class ());
fp = gts_file_new (stdin);
if (gts_surface_read (s, fp)) {
fputs ("gtstoc: file on standard input is not a valid GTS file\n",
stderr);
fprintf (stderr, "stdin:%d:%d: %s\n", fp->line, fp->pos, fp->error);
return 1; /* failure */
}
printf (" GtsSurface * surface = gts_surface_new (gts_surface_class (),\n"
" gts_face_class (),\n"
" gts_edge_class (),\n"
" gts_vertex_class ());\n\n");
gts_surface_foreach_vertex (s, (GtsFunc) write_vertex, &nv);
printf ("\n");
gts_surface_foreach_edge (s, (GtsFunc) write_edge, &ne);
printf ("\n");
gts_surface_foreach_face (s, (GtsFunc) write_face, &nf);
printf (" \n");
for (i = 1; i < nf; i++)
printf (" gts_surface_add_face (surface, f%u);\n", i);
return 0;
}
int main (int argc, char * argv[])
{
GtsSurface * s;
GtsFile * fp;
GtsMatrix * m;
int c = 0;
gboolean verbose = FALSE;
gboolean revert = FALSE;
gboolean normalize = FALSE;
if (!setlocale (LC_ALL, "POSIX"))
g_warning ("cannot set locale to POSIX");
m = gts_matrix_identity (NULL);
/* parse options using getopt */
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"rx", required_argument, NULL, 'r'},
{"ry", required_argument, NULL, 'm'},
{"rz", required_argument, NULL, 'n'},
{"scale", required_argument, NULL, 's'},
{"sx", required_argument, NULL, 'R'},
{"sy", required_argument, NULL, 'M'},
{"sz", required_argument, NULL, 'N'},
{"tx", required_argument, NULL, 't'},
{"ty", required_argument, NULL, 'u'},
{"tz", required_argument, NULL, 'w'},
{"revert", no_argument, NULL, 'i'},
{"normalize", no_argument, NULL, 'o'},
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'},
{ NULL }
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "hvr:m:n:s:R:M:N:it:u:w:o",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "hvr:m:n:s:R:M:N:it:u:w:o"))) {
#endif /* not HAVE_GETOPT_LONG */
case 'o': /* normalize */
normalize = TRUE;
break;
case 'r': { /* rotate around x-axis */
gdouble angle, cosa, sina;
GtsMatrix * rot, * p;
rot = gts_matrix_identity (NULL);
angle = atof (optarg)*PI/180.;
cosa = cos (angle);
sina = sin (angle);
rot[1][1] = cosa; rot[1][2] = -sina;
rot[2][1] = sina; rot[2][2] = cosa;
p = gts_matrix_product (m, rot);
gts_matrix_destroy (rot);
gts_matrix_destroy (m);
m = p;
break;
}
case 'm': { /* rotate around y-axis */
gdouble angle, cosa, sina;
GtsMatrix * rot, * p;
rot = gts_matrix_identity (NULL);
angle = atof (optarg)*PI/180.;
cosa = cos (angle);
sina = sin (angle);
rot[0][0] = cosa; rot[0][2] = sina;
rot[2][0] = -sina; rot[2][2] = cosa;
p = gts_matrix_product (m, rot);
gts_matrix_destroy (rot);
gts_matrix_destroy (m);
m = p;
break;
}
case 'n': { /* rotate around z-axis */
gdouble angle, cosa, sina;
GtsMatrix * rot, * p;
rot = gts_matrix_identity (NULL);
angle = atof (optarg)*PI/180.;
cosa = cos (angle);
sina = sin (angle);
rot[0][0] = cosa; rot[0][1] = -sina;
rot[1][0] = sina; rot[1][1] = cosa;
p = gts_matrix_product (m, rot);
gts_matrix_destroy (rot);
gts_matrix_destroy (m);
m = p;
break;
}
case 's': { /* scale */
GtsMatrix * scale, * p;
gdouble s = atof (optarg);
scale = gts_matrix_identity (NULL);
scale[0][0] = scale[1][1] = scale[2][2] = s;
p = gts_matrix_product (m, scale);
gts_matrix_destroy (scale);
gts_matrix_destroy (m);
m = p;
break;
}
case 'R': { /* sx */
GtsMatrix * scale, * p;
gdouble s = atof (optarg);
scale = gts_matrix_identity (NULL);
scale[0][0] = s;
p = gts_matrix_product (m, scale);
gts_matrix_destroy (scale);
gts_matrix_destroy (m);
m = p;
break;
}
case 'M': { /* sy */
GtsMatrix * scale, * p;
gdouble s = atof (optarg);
scale = gts_matrix_identity (NULL);
scale[1][1] = s;
p = gts_matrix_product (m, scale);
gts_matrix_destroy (scale);
gts_matrix_destroy (m);
m = p;
break;
}
case 'N': { /* sz */
GtsMatrix * scale, * p;
gdouble s = atof (optarg);
scale = gts_matrix_identity (NULL);
scale[2][2] = s;
p = gts_matrix_product (m, scale);
gts_matrix_destroy (scale);
gts_matrix_destroy (m);
m = p;
break;
}
case 't': /* tx */
m[0][3] += atof (optarg);
break;
case 'u': /* ty */
m[1][3] += atof (optarg);
break;
case 'w': /* tz */
m[2][3] += atof (optarg);
break;
case 'i': /* revert */
revert = TRUE;
break;
case 'v': /* verbose */
verbose = TRUE;
break;
case 'h': /* help */
fprintf (stderr,
"Usage: transform [OPTION] < file.gts\n"
"Apply geometric transformations to the input.\n"
"\n"
" -r ANGLE --rx=ANGLE rotate around x-axis (angle in degrees)\n"
" -m ANGLE --ry=ANGLE rotate around y-axis\n"
" -n ANGLE --rz=ANGLE rotate around z-axis\n"
" -s FACTOR --scale=FACTOR scale by FACTOR\n"
" -R FACTOR --sx=FACTOR scale x-axis by FACTOR\n"
" -M FACTOR --sy=FACTOR scale y-axis by FACTOR\n"
" -N FACTOR --sz=FACTOR scale z-axis by FACTOR\n"
" -t V --tx=V translate of V along x-axis\n"
" -u V --ty=V translate of V along y-axis\n"
" -w V --tz=V translate of V along z-axis\n"
" -i --revert turn surface inside out\n"
" -o --normalize fit the resulting surface in a cube of\n"
" size 1 centered at the origin\n"
" -v --verbose print statistics about the surface\n"
" -h --help display this help and exit\n"
"\n"
"Reports bugs to %s\n",
GTS_MAINTAINER);
return 0; /* success */
break;
case '?': /* wrong options */
fprintf (stderr, "Try `transform --help' for more information.\n");
return 1; /* failure */
}
}
s = gts_surface_new (gts_surface_class (),
gts_face_class (),
gts_edge_class (),
gts_vertex_class ());
fp = gts_file_new (stdin);
if (gts_surface_read (s, fp)) {
fputs ("transform: file on standard input is not a valid GTS file\n",
stderr);
fprintf (stderr, "stdin:%d:%d: %s\n", fp->line, fp->pos, fp->error);
return 1; /* failure */
}
if (verbose)
gts_surface_print_stats (s, stderr);
if (revert)
gts_surface_foreach_face (s, (GtsFunc) gts_triangle_revert, NULL);
gts_surface_foreach_vertex (s, (GtsFunc) gts_point_transform, m);
if (normalize) {
GtsBBox * bb = gts_bbox_surface (gts_bbox_class (), s);
gdouble scale = bb->x2 - bb->x1;
GtsMatrix * sc;
if (bb->y2 - bb->y1 > scale) scale = bb->y2 - bb->y1;
if (bb->z2 - bb->z1 > scale) scale = bb->z2 - bb->z1;
if (scale > 0.) scale = 1./scale;
else scale = 1.;
sc = gts_matrix_identity (NULL);
sc[0][3] = - (bb->x1 + bb->x2)/2.;
sc[1][3] = - (bb->y1 + bb->y2)/2.;
sc[2][3] = - (bb->z1 + bb->z2)/2.;
gts_surface_foreach_vertex (s, (GtsFunc) gts_point_transform, sc);
sc[0][0] = sc[1][1] = sc[2][2] = scale;
sc[0][3] = sc[1][3] = sc[2][3] = 0.;
gts_surface_foreach_vertex (s, (GtsFunc) gts_point_transform, sc);
gts_matrix_destroy (sc);
}
gts_surface_write (s, stdout);
return 0;
}
/* stripe - Turns the input surface into triangle strips and outputs a
Geomview representation of the result. */
int main (int argc, char * argv[])
{
GtsSurface * s;
GSList * strips = NULL, * i;
gboolean verbose = FALSE;
int c = 0;
GtsFile * fp;
/* parse options using getopt */
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'}
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "hv",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "hv"))) {
#endif /* not HAVE_GETOPT_LONG */
case 'v': /* verbose */
verbose = TRUE;
break;
case 'h': /* help */
fprintf (stderr,
"Usage: stripe [OPTION] < FILE\n"
"Turns the input surface into triangle strips and outputs a\n"
"Geomview representation of the result.\n"
"\n"
" -v --verbose print statistics about the surface and strips\n"
" -h --help display this help and exit\n"
"\n"
"Report bugs to %s\n",
GTS_MAINTAINER);
return 0; /* success */
break;
case '?': /* wrong options */
fprintf (stderr, "Try `stripe --help' for more information.\n");
return 1; /* failure */
}
}
/* read surface in */
s = gts_surface_new (gts_surface_class (),
gts_face_class (),
gts_edge_class (),
gts_vertex_class ());
fp = gts_file_new (stdin);
if (gts_surface_read (s, fp)) {
fputs ("stripe: file on standard input is not a valid GTS file\n",
stderr);
fprintf (stderr, "stdin:%d:%d: %s\n", fp->line, fp->pos, fp->error);
return 1; /* failure */
}
gts_file_destroy (fp);
if (verbose)
gts_surface_print_stats (s, stderr);
strips = gts_surface_strip (s);
/* if verbose on print stats */
if (verbose) {
GtsRange l;
gts_range_init (&l);
i = strips;
while (i) {
gts_range_add_value (&l, g_slist_length (i->data));
i = i->next;
}
gts_range_update (&l);
fprintf (stderr, "# Strips: %d\n# length : ", l.n);
gts_range_print (&l, stderr);
fputc ('\n', stderr);
}
puts ("LIST {\n");
i = strips;
while (i) {
GList * j = i->data;
GtsTriangle * oldt = NULL;
GtsColor c;
c.r = rand ()/(gdouble) RAND_MAX;
c.g = rand ()/(gdouble) RAND_MAX;
c.b = rand ()/(gdouble) RAND_MAX;
while (j) {
GtsTriangle * t = j->data;
GtsPoint
* p1 = GTS_POINT (GTS_SEGMENT (t->e1)->v1),
* p2 = GTS_POINT (GTS_SEGMENT (t->e1)->v2),
* p3 = GTS_POINT (gts_triangle_vertex (t));
printf ("OFF 3 1 3\n%g %g %g\n%g %g %g\n%g %g %g\n3 0 1 2 %g %g %g\n",
p1->x, p1->y, p1->z,
p2->x, p2->y, p2->z,
p3->x, p3->y, p3->z,
c.r, c.g, c.b);
if (oldt) {
GtsSegment * cs = GTS_SEGMENT (gts_triangles_common_edge (t, oldt));
GtsPoint
* op1 = GTS_POINT (GTS_SEGMENT (oldt->e1)->v1),
* op2 = GTS_POINT (GTS_SEGMENT (oldt->e1)->v2),
* op3 = GTS_POINT (gts_triangle_vertex (oldt));
printf ("VECT 1 3 0 3 0 %g %g %g %g %g %g %g %g %g\n",
(op1->x + op2->x + op3->x)/3.,
(op1->y + op2->y + op3->y)/3.,
(op1->z + op2->z + op3->z)/3.,
(GTS_POINT (cs->v1)->x + GTS_POINT (cs->v2)->x)/2.,
(GTS_POINT (cs->v1)->y + GTS_POINT (cs->v2)->y)/2.,
(GTS_POINT (cs->v1)->z + GTS_POINT (cs->v2)->z)/2.,
(p1->x + p2->x + p3->x)/3.,
(p1->y + p2->y + p3->y)/3.,
(p1->z + p2->z + p3->z)/3.);
}
oldt = t;
j = j->next;
}
i = i->next;
}
puts ("}\n");
return 0; /* success */
}
int main (int argc, char * argv[])
{
GtsSurface * s;
GtsFile * fp;
int c = 0;
gboolean verbose = FALSE;
guint n, niter;
gdouble lambda;
gpointer data[4];
gboolean fold = FALSE;
gdouble maxcosine2 = 0.;
guint nfold = 1;
if (!setlocale (LC_ALL, "POSIX"))
g_warning ("cannot set locale to POSIX");
/* parse options using getopt */
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"fold", required_argument, NULL, 'f'},
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'}
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "hvf:",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "hvf:"))) {
#endif /* not HAVE_GETOPT_LONG */
case 'f': /* fold */
fold = TRUE;
maxcosine2 = cos (atof (optarg)*3.14159265359/180.);
maxcosine2 *= maxcosine2;
break;
case 'v': /* verbose */
verbose = TRUE;
break;
case 'h': /* help */
fprintf (stderr,
"Usage: smooth [OPTION] LAMBDA NITER < file.gts > smooth.gts\n"
"Smooth a GTS file by applying NITER iterations of a Laplacian filter\n"
"of parameter LAMBDA.\n"
"\n"
" -f VAL --fold=VAL smooth only folds\n"
" -v --verbose print statistics about the surface\n"
" -h --help display this help and exit\n"
"\n"
"Reports bugs to %s\n",
GTS_MAINTAINER);
return 0; /* success */
break;
case '?': /* wrong options */
fprintf (stderr, "Try `smooth --help' for more information.\n");
return 1; /* failure */
}
}
if (optind >= argc) { /* missing lambda */
fprintf (stderr,
"smooth: missing LAMBDA\n"
"Try `smooth --help' for more information.\n");
return 1; /* failure */
}
lambda = atof (argv[optind++]);
if (optind >= argc) { /* missing niter */
fprintf (stderr,
"smooth: missing NITER\n"
"Try `smooth --help' for more information.\n");
return 1; /* failure */
}
niter = atoi (argv[optind++]);
s = gts_surface_new (gts_surface_class (),
gts_face_class (),
gts_edge_class (),
gts_vertex_class ());
fp = gts_file_new (stdin);
if (gts_surface_read (s, fp)) {
fputs ("smooth: file on standard input is not a valid GTS file\n",
stderr);
fprintf (stderr, "stdin:%d:%d: %s\n", fp->line, fp->pos, fp->error);
return 1; /* failure */
}
if (verbose)
gts_surface_print_stats (s, stderr);
data[0] = s;
data[1] = λ
data[2] = &maxcosine2;
data[3] = &nfold;
for (n = 1; n <= niter && (!fold || nfold > 0); n++) {
if (fold) {
nfold = 0;
gts_surface_foreach_vertex (s, (GtsFunc) smooth_fold, data);
}
else
gts_surface_foreach_vertex (s, (GtsFunc) smooth_vertex, data);
if (verbose)
fprintf (stderr, "\rIteration: %10u %3.0f%% ",
n,
100.*n/niter);
}
if (verbose) {
fputc ('\n', stderr);
gts_surface_print_stats (s, stderr);
}
gts_surface_write (s, stdout);
return 0;
}
/* coarsen - produce a coarsened version of the input */
int main (int argc, char * argv[])
{
GtsSurface * s;
GtsPSurface * ps = NULL;
gboolean verbose = FALSE;
gboolean progressive = FALSE;
gboolean log_cost = FALSE;
guint number = 0;
gdouble cmax = 0.0;
StopOptions stop = NUMBER;
CostOptions cost = COST_OPTIMIZED;
MidvertexOptions mid = OPTIMIZED;
GtsKeyFunc cost_func = NULL;
GtsCoarsenFunc coarsen_func = NULL;
GtsStopFunc stop_func = NULL;
gpointer stop_data = NULL;
int c = 0;
GtsFile * fp;
gdouble fold = PI/180.;
GtsVolumeOptimizedParams params = { 0.5, 0.5, 0. };
gpointer coarsen_data = NULL, cost_data = NULL;
if (!setlocale (LC_ALL, "POSIX"))
g_warning ("cannot set locale to POSIX");
/* parse options using getopt */
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"angle", no_argument, NULL, 'a'},
{"progressive", no_argument, NULL, 'p'},
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'},
{"number", required_argument, NULL, 'n'},
{"length", no_argument, NULL, 'l'},
{"midvertex", no_argument, NULL, 'm'},
{"cost", required_argument, NULL, 'c'},
{"fold", required_argument, NULL, 'f'},
{"vweight", required_argument, NULL, 'w'},
{"bweight", required_argument, NULL, 'b'},
{"sweight", required_argument, NULL, 's'},
{"log", no_argument, NULL, 'L'}
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "hvmc:n:lpf:w:b:s:La",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "hvmc:n:lpf:w:b:s:La"))) {
#endif /* not HAVE_GETOPT_LONG */
case 'a': /* angle */
cost = COST_ANGLE;
break;
case 'L': /* log */
log_cost = TRUE;
break;
case 'p': /* write progressive surface */
progressive = TRUE;
break;
case 'n': /* stop by number */
stop = NUMBER;
number = atoi (optarg);
break;
case 'c': /* stop by cost */
stop = COST;
cmax = atof (optarg);
break;
case 'v': /* verbose */
verbose = TRUE;
break;
case 'm': /* midvertex */
mid = MIDVERTEX;
break;
case 'l': /* cost is length */
cost = COST_LENGTH;
break;
case 'f': /* fold angle */
fold = atof (optarg)*PI/180.;
break;
case 'w': /* volume optimized weight */
params.volume_weight = atof (optarg);
break;
case 'b': /* boundary optimized weight */
params.boundary_weight = atof (optarg);
break;
case 's': /* shape optimized weight */
params.shape_weight = atof (optarg);
break;
case 'h': /* help */
fprintf (stderr,
"Usage: coarsen [OPTION] < file.gts\n"
"Construct a coarsened version of the input.\n"
"\n"
" -n N, --number=N stop the coarsening process if the number of\n"
" edges was to fall below N\n"
" -c C, --cost=C stop the coarsening process if the cost of collapsing\n"
" an edge is larger than C\n"
" -m --midvertex use midvertex as replacement vertex\n"
" default is volume optimized point\n"
" -l --length use length^2 as cost function\n"
" default is optimized point cost\n"
" -f F, --fold=F set maximum fold angle to F degrees\n"
" default is one degree\n"
" -w W, --vweight=W set weight used for volume optimization\n"
" default is 0.5\n"
" -b W, --bweight=W set weight used for boundary optimization\n"
" default is 0.5\n"
" -s W, --sweight=W set weight used for shape optimization\n"
" default is 0.0\n"
" -p --progressive write progressive surface file\n"
" -L --log logs the evolution of the cost\n"
" -v --verbose print statistics about the surface\n"
" -h --help display this help and exit\n"
"\n"
"Reports bugs to %s\n",
GTS_MAINTAINER);
return 0; /* success */
break;
case '?': /* wrong options */
fprintf (stderr, "Try `coarsen --help' for more information.\n");
return 1; /* failure */
}
}
/* read surface in */
s = gts_surface_new (gts_surface_class (),
gts_face_class (),
gts_edge_class (),
gts_vertex_class ());
fp = gts_file_new (stdin);
if (gts_surface_read (s, fp)) {
fputs ("coarsen: the file on standard input is not a valid GTS file\n",
stderr);
fprintf (stderr, "stdin:%d:%d: %s\n", fp->line, fp->pos, fp->error);
return 1; /* failure */
}
/* if verbose on print stats */
if (verbose) {
gts_surface_print_stats (s, stderr);
fprintf (stderr, "# volume: %g area: %g\n",
gts_surface_volume (s), gts_surface_area (s));
}
/* select the right coarsening process */
switch (cost) {
case COST_OPTIMIZED:
cost_func = (GtsKeyFunc) gts_volume_optimized_cost;
cost_data = ¶ms;
break;
case COST_LENGTH:
cost_func = NULL; break;
case COST_ANGLE:
cost_func = (GtsKeyFunc) cost_angle; break;
default:
g_assert_not_reached ();
}
switch (mid) {
case MIDVERTEX:
coarsen_func = NULL;
break;
case OPTIMIZED:
coarsen_func = (GtsCoarsenFunc) gts_volume_optimized_vertex;
coarsen_data = ¶ms;
break;
default:
g_assert_not_reached ();
}
if (log_cost)
stop_func = (GtsStopFunc) stop_log_cost;
else {
switch (stop) {
case NUMBER:
if (verbose)
stop_func = (GtsStopFunc) stop_number_verbose;
else
stop_func = (GtsStopFunc) gts_coarsen_stop_number;
stop_data = &number;
break;
case COST:
if (verbose)
stop_func = (GtsStopFunc) stop_cost_verbose;
else
stop_func = (GtsStopFunc) gts_coarsen_stop_cost;
stop_data = &cmax;
break;
default:
g_assert_not_reached ();
}
}
if (progressive)
ps = gts_psurface_new (gts_psurface_class (),
s, gts_split_class (),
cost_func, cost_data,
coarsen_func, coarsen_data,
stop_func, stop_data,
fold);
else
gts_surface_coarsen (s,
cost_func, cost_data,
coarsen_func, coarsen_data,
stop_func, stop_data, fold);
/* if verbose on print stats */
if (verbose) {
fputc ('\n', stderr);
gts_surface_print_stats (s, stderr);
fprintf (stderr, "# volume: %g area: %g\n",
gts_surface_volume (s), gts_surface_area (s));
}
/* write resulting surface to standard output */
if (progressive)
gts_psurface_write (ps, stdout);
else
gts_surface_write (s, stdout);
return 0; /* success */
}
int main (int argc, char * argv[])
{
GtsSurface * s;
gboolean verbose = FALSE;
gdouble threshold;
int c = 0;
GtsFile * fp;
GtsRange angle;
if (!setlocale (LC_ALL, "POSIX"))
g_warning ("cannot set locale to POSIX");
/* parse options using getopt */
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'},
{ NULL }
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "hv",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "hv"))) {
#endif /* not HAVE_GETOPT_LONG */
case 'v': /* verbose */
verbose = TRUE;
break;
case 'h': /* help */
fprintf (stderr,
"Usage: optimize [OPTION] THRESHOLD < FILE\n"
"\n"
" -v --verbose print statistics about the surface\n"
" -h --help display this help and exit\n"
"\n"
"Report bugs to %s\n",
GTS_MAINTAINER);
return 0; /* success */
break;
case '?': /* wrong options */
fprintf (stderr, "Try `optimize --help' for more information.\n");
return 1; /* failure */
}
}
if (optind >= argc) { /* missing threshold */
fprintf (stderr,
"optimize: missing THRESHOLD\n"
"Try `optimize --help' for more information.\n");
return 1; /* failure */
}
threshold = strtod (argv[optind], NULL);
if (threshold < 0.0) { /* threshold must be positive */
fprintf (stderr,
"optimize: THRESHOLD must be >= 0.0\n"
"Try `optimize --help' for more information.\n");
return 1; /* failure */
}
/* read surface in */
s = gts_surface_new (gts_surface_class (),
gts_face_class (),
gts_edge_class (),
gts_vertex_class ());
fp = gts_file_new (stdin);
if (gts_surface_read (s, fp)) {
fputs ("optimize: file on standard input is not a valid GTS file\n",
stderr);
fprintf (stderr, "stdin:%d:%d: %s\n", fp->line, fp->pos, fp->error);
return 1; /* failure */
}
/* if verbose on print stats */
if (verbose) {
gts_surface_print_stats (s, stderr);
gts_range_init (&angle);
gts_surface_foreach_edge (s, (GtsFunc) angle_stats, &angle);
gts_range_update (&angle);
fputs ("# angle : ", stderr);
gts_range_print (&angle, stderr);
fputc ('\n', stderr);
}
surface_optimize (s, -threshold);
/* if verbose on print stats */
if (verbose) {
gts_surface_print_stats (s, stderr);
gts_range_init (&angle);
gts_surface_foreach_edge (s, (GtsFunc) angle_stats, &angle);
gts_range_update (&angle);
fputs ("# angle : ", stderr);
gts_range_print (&angle, stderr);
fputc ('\n', stderr);
}
/* write surface */
gts_surface_write (s, stdout);
return 0; /* success */
}
/* inside - check if points are inside a surface */
int main (int argc, char * argv[])
{
GtsSurface * s1;
GNode * tree1;
GtsPoint P;
FILE * fptr;
GtsFile * fp;
int c = 0, cnt = 0;
double x,y,z;
gboolean verbose = FALSE;
gchar * file1, * file2;
gboolean is_open1, is_inside;
if (!setlocale (LC_ALL, "POSIX"))
g_warning ("cannot set locale to POSIX");
/* parse options using getopt */
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'}
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "shv",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "shv"))) {
#endif /* not HAVE_GETOPT_LONG */
case 'v': /* verbose */
verbose = TRUE;
break;
case 'h': /* help */
fprintf (stderr,
"Usage: gtsinside [OPTION] FILE1 FILE2\n"
"Test whether points are inside a closed surface.\n"
"FILE1 is a surface file. FILE2 is a text file where each line\n"
"contains the three coordinates of a point, separated with blanks.\n"
"\n"
" -v --verbose print statistics about the surface\n"
" -h --help display this help and exit\n"
"\n"
"Reports bugs to %s\n",
"https://savannah.nongnu.org/projects/pyformex/");
return 0; /* success */
break;
case '?': /* wrong options */
fprintf (stderr, "Try `gtsinside --help' for more information.\n");
return 1; /* failure */
}
}
if (optind >= argc) { /* missing FILE1 */
fprintf (stderr,
"gtsinside: missing FILE1\n"
"Try `inside --help' for more information.\n");
return 1; /* failure */
}
file1 = argv[optind++];
if (optind >= argc) { /* missing FILE2 */
fprintf (stderr,
"gtsinside: missing FILE2\n"
"Try `gtsinside --help' for more information.\n");
return 1; /* failure */
}
file2 = argv[optind++];
/* open first file */
if ((fptr = fopen (file1, "rt")) == NULL) {
fprintf (stderr, "gtsinside: can not open file `%s'\n", file1);
return 1;
}
/* reads in first surface file */
s1 = GTS_SURFACE (gts_object_new (GTS_OBJECT_CLASS (gts_surface_class ())));
fp = gts_file_new (fptr);
if (gts_surface_read (s1, fp)) {
fprintf (stderr, "gtsinside: `%s' is not a valid GTS surface file\n",
file1);
fprintf (stderr, "%s:%d:%d: %s\n", file1, fp->line, fp->pos, fp->error);
return 1;
}
gts_file_destroy (fp);
fclose (fptr);
/* open second file */
if ((fptr = fopen (file2, "rt")) == NULL) {
fprintf (stderr, "gtsinside: can not open file `%s'\n", file2);
return 1;
}
/* display summary information about the surface */
if (verbose) {
gts_surface_print_stats (s1, stderr);
}
/* check that the surface is an orientable manifold */
if (!gts_surface_is_orientable (s1)) {
fprintf (stderr, "gtsinside: surface `%s' is not an orientable manifold\n",
file1);
return 1;
}
/* build bounding box tree for the surface */
tree1 = gts_bb_tree_surface (s1);
is_open1 = gts_surface_volume (s1) < 0. ? TRUE : FALSE;
/* scan file 2 for points and determine if it they are inside surface */
while ( fscanf(fptr, "%lg %lg %lg", &x, &y, &z) == 3 ) {
P.x = x; P.y = y; P.z = z;
is_inside = gts_point_is_inside_surface(&P,tree1,is_open1);
if (is_inside) printf("%d\n",cnt);
//printf("Point %d: %lf, %lf, %lf: %d\n",cnt,P.x,P.y,P.z,is_inside);
cnt++;
}
if ( !feof(fptr) ) {
fprintf (stderr, "gtsinside: error while reading points from file `%s'\n",
file2);
return 1;
}
fclose (fptr);
/* destroy surface */
gts_object_destroy (GTS_OBJECT (s1));
/* destroy bounding box tree (including bounding boxes) */
gts_bb_tree_destroy (tree1, TRUE);
return 0;
}
/* set - compute set operations between surfaces */
int main (int argc, char * argv[])
{
GtsSurface * s1, * s2, * s3;
GtsSurfaceInter * si;
GNode * tree1, * tree2;
FILE * fptr;
GtsFile * fp;
int c = 0;
gboolean verbose = TRUE;
gboolean inter = FALSE;
gboolean check_self_intersection = FALSE;
gchar * operation, * file1, * file2;
gboolean closed = TRUE, is_open1, is_open2;
if (!setlocale (LC_ALL, "POSIX"))
g_warning ("cannot set locale to POSIX");
/* parse options using getopt */
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"inter", no_argument, NULL, 'i'},
{"self", no_argument, NULL, 's'},
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'}
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "hvis",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "hvis"))) {
#endif /* not HAVE_GETOPT_LONG */
case 's': /* self */
check_self_intersection = TRUE;
break;
case 'i': /* inter */
inter = TRUE;
break;
case 'v': /* verbose */
verbose = FALSE;
break;
case 'h': /* help */
fprintf (stderr,
"Usage: set [OPTION] OPERATION FILE1 FILE2\n"
"Compute set operations between surfaces, where OPERATION is either.\n"
"union, inter, diff.\n"
"\n"
" -i --inter output an OOGL (Geomview) representation of the curve\n"
" intersection of the surfaces\n"
" -s --self checks that the surfaces are not self-intersecting\n"
" if one of them is, the set of self-intersecting faces\n"
" is written (as a GtsSurface) on standard output\n"
" -v --verbose do not print statistics about the surface\n"
" -h --help display this help and exit\n"
"\n"
"Reports bugs to %s\n",
GTS_MAINTAINER);
return 0; /* success */
break;
case '?': /* wrong options */
fprintf (stderr, "Try `set --help' for more information.\n");
return 1; /* failure */
}
}
if (optind >= argc) { /* missing OPERATION */
fprintf (stderr,
"set: missing OPERATION\n"
"Try `set --help' for more information.\n");
return 1; /* failure */
}
operation = argv[optind++];
if (optind >= argc) { /* missing FILE1 */
fprintf (stderr,
"set: missing FILE1\n"
"Try `set --help' for more information.\n");
return 1; /* failure */
}
file1 = argv[optind++];
if (optind >= argc) { /* missing FILE2 */
fprintf (stderr,
"set: missing FILE2\n"
"Try `set --help' for more information.\n");
return 1; /* failure */
}
file2 = argv[optind++];
/* open first file */
if ((fptr = fopen (file1, "rt")) == NULL) {
fprintf (stderr, "set: can not open file `%s'\n", file1);
return 1;
}
/* reads in first surface file */
s1 = GTS_SURFACE (gts_object_new (GTS_OBJECT_CLASS (gts_surface_class ())));
fp = gts_file_new (fptr);
if (gts_surface_read (s1, fp)) {
fprintf (stderr, "set: `%s' is not a valid GTS surface file\n",
file1);
fprintf (stderr, "%s:%d:%d: %s\n", file1, fp->line, fp->pos, fp->error);
return 1;
}
gts_file_destroy (fp);
fclose (fptr);
/* open second file */
if ((fptr = fopen (file2, "rt")) == NULL) {
fprintf (stderr, "set: can not open file `%s'\n", file2);
return 1;
}
/* reads in second surface file */
s2 = GTS_SURFACE (gts_object_new (GTS_OBJECT_CLASS (gts_surface_class ())));
fp = gts_file_new (fptr);
if (gts_surface_read (s2, fp)) {
fprintf (stderr, "set: `%s' is not a valid GTS surface file\n",
file2);
fprintf (stderr, "%s:%d:%d: %s\n", file2, fp->line, fp->pos, fp->error);
return 1;
}
gts_file_destroy (fp);
fclose (fptr);
/* display summary information about both surfaces */
if (verbose) {
gts_surface_print_stats (s1, stderr);
gts_surface_print_stats (s2, stderr);
}
/* check that the surfaces are orientable manifolds */
if (!gts_surface_is_orientable (s1)) {
fprintf (stderr, "set: surface `%s' is not an orientable manifold\n",
file1);
return 1;
}
if (!gts_surface_is_orientable (s2)) {
fprintf (stderr, "set: surface `%s' is not an orientable manifold\n",
file2);
return 1;
}
/* check that the surfaces are not self-intersecting */
if (check_self_intersection) {
GtsSurface * self_intersects;
self_intersects = gts_surface_is_self_intersecting (s1);
if (self_intersects != NULL) {
fprintf (stderr, "set: surface `%s' is self-intersecting\n", file1);
if (verbose)
gts_surface_print_stats (self_intersects, stderr);
gts_surface_write (self_intersects, stdout);
gts_object_destroy (GTS_OBJECT (self_intersects));
return 1;
}
self_intersects = gts_surface_is_self_intersecting (s2);
if (self_intersects != NULL) {
fprintf (stderr, "set: surface `%s' is self-intersecting\n", file2);
if (verbose)
gts_surface_print_stats (self_intersects, stderr);
gts_surface_write (self_intersects, stdout);
gts_object_destroy (GTS_OBJECT (self_intersects));
return 1;
}
}
/* build bounding box tree for first surface */
tree1 = gts_bb_tree_surface (s1);
is_open1 = gts_surface_volume (s1) < 0. ? TRUE : FALSE;
/* build bounding box tree for second surface */
tree2 = gts_bb_tree_surface (s2);
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));
if (!closed) {
fprintf (stderr,
"set: the intersection of `%s' and `%s' is not a closed curve\n",
file1, file2);
return 1;
}
s3 = gts_surface_new (gts_surface_class (),
gts_face_class (),
gts_edge_class (),
gts_vertex_class ());
if (!strcmp (operation, "union")) {
gts_surface_inter_boolean (si, s3, GTS_1_OUT_2);
gts_surface_inter_boolean (si, s3, GTS_2_OUT_1);
}
else if (!strcmp (operation, "inter")) {
gts_surface_inter_boolean (si, s3, GTS_1_IN_2);
gts_surface_inter_boolean (si, s3, GTS_2_IN_1);
}
else if (!strcmp (operation, "diff")) {
gts_surface_inter_boolean (si, s3, GTS_1_OUT_2);
gts_surface_inter_boolean (si, s3, GTS_2_IN_1);
gts_surface_foreach_face (si->s2, (GtsFunc) gts_triangle_revert, NULL);
gts_surface_foreach_face (s2, (GtsFunc) gts_triangle_revert, NULL);
}
else {
fprintf (stderr,
"set: operation `%s' unknown\n"
"Try `set --help' for more information.\n",
operation);
return 1;
}
/* check that the resulting surface is not self-intersecting */
if (check_self_intersection) {
GtsSurface * self_intersects;
self_intersects = gts_surface_is_self_intersecting (s3);
if (self_intersects != NULL) {
fprintf (stderr, "set: the resulting surface is self-intersecting\n");
if (verbose)
gts_surface_print_stats (self_intersects, stderr);
gts_surface_write (self_intersects, stdout);
gts_object_destroy (GTS_OBJECT (self_intersects));
return 1;
}
}
/* display summary information about the resulting surface */
if (verbose)
gts_surface_print_stats (s3, stderr);
/* write resulting surface to standard output */
if (inter) {
printf ("LIST {\n");
g_slist_foreach (si->edges, (GFunc) write_edge, stdout);
printf ("}\n");
}
else {
GTS_POINT_CLASS (gts_vertex_class ())->binary = TRUE;
gts_surface_write (s3, stdout);
}
/* destroy surfaces */
gts_object_destroy (GTS_OBJECT (s1));
gts_object_destroy (GTS_OBJECT (s2));
gts_object_destroy (GTS_OBJECT (s3));
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;
}
int main (int argc, char * argv[])
{
GtsSurface * s;
GtsFile * fp;
GtsFace * first = NULL;
int c = 0;
gboolean verbose = FALSE;
if (!setlocale (LC_ALL, "POSIX"))
g_warning ("cannot set locale to POSIX");
colormap = colormap_red_blue (); /* default */
/* parse options using getopt */
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"cmap", required_argument, NULL, 'c'},
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'},
{ NULL }
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "hvc:",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "hvc:"))) {
#endif /* not HAVE_GETOPT_LONG */
case 'c': { /* cmap */
FILE * fptr = fopen (optarg, "rt");
if (!fptr) {
fprintf (stderr, "traverse: cannot open colormap file `%s'.\n",
optarg);
return 1;
}
colormap = colormap_read (fptr);
fclose (fptr);
break;
}
case 'v': /* verbose */
verbose = TRUE;
break;
case 'h': /* help */
fprintf (stderr,
"Usage: traverse [OPTION] < file.gts > file.oogl\n"
"Output an OOGL (geomview) surface colored according to the (graph) distance\n"
"from a random face to the others\n"
"\n"
" -c FILE --cmap=FILE load FILE as colormap\n"
" -v --verbose print statistics about the surface\n"
" -h --help display this help and exit\n"
"\n"
"Reports bugs to %s\n",
GTS_MAINTAINER);
return 0; /* success */
break;
case '?': /* wrong options */
fprintf (stderr, "Try `traverse --help' for more information.\n");
return 1; /* failure */
}
}
s = gts_surface_new (gts_surface_class (),
GTS_FACE_CLASS (depth_face_class ()),
gts_edge_class (),
gts_vertex_class ());
fp = gts_file_new (stdin);
if (gts_surface_read (s, fp)) {
fputs ("traverse: file on standard input is not a valid GTS file\n",
stderr);
fprintf (stderr, "stdin:%d:%d: %s\n", fp->line, fp->pos, fp->error);
return 1; /* failure */
}
if (verbose)
gts_surface_print_stats (s, stderr);
gts_surface_foreach_face (s, (GtsFunc) pick_first_face, &first);
gts_range_init (&depth_range);
if (first) {
GtsSurfaceTraverse * t = gts_surface_traverse_new (s, first);
GtsFace * f;
guint level;
while ((f = gts_surface_traverse_next (t, &level))) {
DEPTH_FACE (f)->depth = level;
gts_range_add_value (&depth_range, level);
}
gts_surface_traverse_destroy (t);
}
gts_range_update (&depth_range);
if (verbose) {
fputs ("distance: ", stderr);
gts_range_print (&depth_range, stderr);
fputc ('\n', stderr);
}
gts_surface_write_oogl (s, stdout);
return 0;
}
int main (int argc, char * argv[])
{
GtsSurface * s;
gboolean verbose = FALSE;
int c = 0;
if (!setlocale (LC_ALL, "POSIX"))
g_warning ("cannot set locale to POSIX");
/* parse options using getopt */
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'},
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "hv",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "hv"))) {
#endif /* not HAVE_GETOPT_LONG */
case 'v': /* verbose */
verbose = TRUE;
break;
case 'h': /* help */
fprintf (stderr,
"Usage: merge [OPTION] file1.gts file2.gts ...\n"
"Merges files and outputs the resulting GTS surface.\n"
"\n"
" -v --verbose print statistics about the surface\n"
" -h --help display this help and exit\n"
"\n"
"Reports bugs to %s\n",
GTS_MAINTAINER);
return 0; /* success */
break;
case '?': /* wrong options */
fprintf (stderr, "Try `merge --help' for more information.\n");
return 1; /* failure */
}
}
s = GTS_SURFACE (gts_object_new (GTS_OBJECT_CLASS (gts_surface_class ())));
while (optind < argc) {
FILE * f = fopen (argv[optind], "r");
GtsFile * fp;
GtsSurface * s1;
if (f == NULL) {
fprintf (stderr, "merge: can not open file `%s'\n", argv[optind]);
return 1;
}
fp = gts_file_new (f);
s1 = GTS_SURFACE (gts_object_new (GTS_OBJECT_CLASS (gts_surface_class ())));
if (gts_surface_read (s1, fp)) {
fprintf (stderr, "merge: `%s' is not a valid GTS surface file\n",
argv[optind]);
fprintf (stderr, "%s:%d:%d: %s\n", argv[optind], fp->line, fp->pos, fp->error);
return 1;
}
gts_surface_merge (s, s1);
gts_object_destroy (GTS_OBJECT (s1));
gts_file_destroy (fp);
fclose (f);
optind++;
}
if (verbose)
gts_surface_print_stats (s, stderr);
gts_surface_write (s, stdout);
return 0;
}
int main (int argc, char * argv[])
{
int c = 0;
gboolean verbose = FALSE;
gboolean revert = FALSE;
GtsSurface * s;
GtsFile * fp;
while (c != EOF) {
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"revert", no_argument, NULL, 'r'},
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'}
};
int option_index = 0;
switch ((c = getopt_long (argc, argv, "hvr",
long_options, &option_index))) {
#else /* not HAVE_GETOPT_LONG */
switch ((c = getopt (argc, argv, "hvr"))) {
#endif /* not HAVE_GETOPT_LONG */
case 'r': /* revert */
revert = TRUE;
break;
case 'h': /* help */
fprintf (stderr,
"Usage: gts2stl [OPTION]... < input.gts > output.stl\n"
"Convert a GTS file to STL format.\n"
"\n"
" -r, --revert revert face normals\n"
" -v, --verbose display surface statistics\n"
" -h, --help display this help and exit\n"
"\n"
"Report bugs to %s\n",
GTS_MAINTAINER);
return 0;
break;
case 'v':
verbose = TRUE;
break;
case '?': /* wrong options */
fprintf (stderr, "Try `gts2stl --help' for more information.\n");
return 1;
}
}
s = gts_surface_new (gts_surface_class (),
gts_face_class (),
gts_edge_class (),
gts_vertex_class ());
fp = gts_file_new (stdin);
if (gts_surface_read (s, fp)) {
fputs ("gts2stl: file on standard input is not a valid GTS file\n",
stderr);
fprintf (stderr, "stdin:%d:%d: %s\n", fp->line, fp->pos, fp->error);
return 1; /* failure */
}
if (revert)
gts_surface_foreach_face (s, (GtsFunc) gts_triangle_revert, NULL);
if (verbose)
gts_surface_print_stats (s, stderr);
puts ("solid");
gts_surface_foreach_face (s, (GtsFunc) write_face, NULL);
puts ("endsolid");
return 0;
}