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;
}
GtsVertexClass *gts_vertex_class( void )
{
int eax;
int edx;
int edi;
static GtsVertexClass *klass;
if ( klass == 0 )
{
GtsObjectClassInfo vertex_info = { };
vertex_info.name[0] = 'G';
*(int*)&vertex_info.name[4] = 0x65747265;
*(int*)&vertex_info.name[8] = 120;
do
{
*(int*)&vertex_info.name[11] = 0;
}
while ( klass + 4 + 4 < 28 );
vertex_info.object_size = 40;
vertex_info.class_size = 100;
vertex_info.class_init_func = &vertex_class_init;
vertex_info.object_init_func = &vertex_init;
klass = gts_object_class_new( (GtsObjectClass*)gts_point_class( ), &vertex_info );
}
if ( 0 ^ 0 )
{
__stack_chk_fail( );
}
return klass;
}
/**
* 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);
}
/**
* gts_bb_tree_segment_distance:
* @tree: a bounding box tree.
* @s: a #GtsSegment.
* @distance: a #GtsBBoxDistFunc.
* @delta: spatial scale of the sampling to be used.
* @range: a #GtsRange to be filled with the results.
*
* Given a segment @s, points are sampled regularly on its length
* 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_segment_distance (GNode * tree,
GtsSegment * s,
gdouble (*distance) (GtsPoint *,
gpointer),
gdouble delta,
GtsRange * range)
{
GtsPoint * p1, * p2, * p;
GtsVector p1p2;
gdouble l, t, dt;
guint i, n;
g_return_if_fail (tree != NULL);
g_return_if_fail (s != NULL);
g_return_if_fail (distance != NULL);
g_return_if_fail (delta > 0.);
g_return_if_fail (range != NULL);
p1 = GTS_POINT (s->v1);
p2 = GTS_POINT (s->v2);
gts_vector_init (p1p2, p1, p2);
gts_range_init (range);
p = GTS_POINT (gts_object_new (GTS_OBJECT_CLASS (gts_point_class())));
l = sqrt (gts_vector_scalar (p1p2, p1p2));
n = (guint) (l/delta + 1);
dt = 1.0/(gdouble) n;
t = 0.0;
for (i = 0; i <= n; i++, t += dt) {
p->x = p1->x + t*p1p2[0];
p->y = p1->y + t*p1p2[1];
p->z = p1->z + t*p1p2[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);
}
