start splitting up Triangle
removing non-library build and pre-ansi declarations
This commit is contained in:
Hannes Janetzek
parent
22441bf527
commit
2538ed8eb7
@ -8,7 +8,7 @@ LOCAL_CFLAGS := -O -DTRILIBRARY -DREDUCED -DCDT_ONLY -DNO_TIMER -Werror -std=c99
|
||||
# -DLINUX -> no fpu_control in bionic, needed ?
|
||||
|
||||
LOCAL_MODULE := triangle-jni
|
||||
LOCAL_SRC_FILES := triangle/TriangleJni.c triangle/triangle.c
|
||||
LOCAL_SRC_FILES := triangle/TriangleJni.c triangle/triangle.c triangle/triangle_dbg.c
|
||||
LOCAL_LDLIBS := -llog
|
||||
|
||||
include $(BUILD_SHARED_LIBRARY)
|
||||
|
||||
@ -12,394 +12,370 @@
|
||||
#if 0
|
||||
int pnpoly(int nvert, float *vert, float testx, float testy)
|
||||
{
|
||||
int i, j, c = 0;
|
||||
for (i = 0, j = (nvert-1)*2; i < nvert * 2; j = i++)
|
||||
{
|
||||
if ( ((vert[i*2+1] > testy) != (vert[j*j+1] > testy)) &&
|
||||
(testx < (vert[j*2]-vert[i*2])
|
||||
* (testy - vert[i*2+1])
|
||||
/ (vert[j*2+1]-vert[i*2+1]) + vert[i*2]) )
|
||||
c = !c;
|
||||
}
|
||||
return c;
|
||||
int i, j, c = 0;
|
||||
for (i = 0, j = (nvert-1)*2; i < nvert * 2; j = i++)
|
||||
{
|
||||
if ( ((vert[i*2+1] > testy) != (vert[j*j+1] > testy)) &&
|
||||
(testx < (vert[j*2]-vert[i*2])
|
||||
* (testy - vert[i*2+1])
|
||||
/ (vert[j*2+1]-vert[i*2+1]) + vert[i*2]) )
|
||||
c = !c;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
#endif
|
||||
|
||||
//#define TESTING
|
||||
|
||||
int compare_dups(const void *a, const void *b)
|
||||
{
|
||||
int da = *((const int*) a);
|
||||
int db = *((const int*) b);
|
||||
int compare_dups(const void *a, const void *b) {
|
||||
int da = *((const int*) a);
|
||||
int db = *((const int*) b);
|
||||
|
||||
return (da > db) - (da < db);
|
||||
return (da > db) - (da < db);
|
||||
}
|
||||
|
||||
typedef struct triangulateio TriangleIO;
|
||||
jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env, jclass c,
|
||||
jfloatArray obj_points, jint pos, jint len, jint num_rings, jobject indice_buf, jint offset) {
|
||||
|
||||
jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
||||
jclass c, jfloatArray obj_points, jint pos, jint len, jint num_rings,
|
||||
jobject indice_buf, jint offset)
|
||||
{
|
||||
jshort* indices = (jshort*) (*env)->GetDirectBufferAddress(env, indice_buf);
|
||||
jboolean isCopy;
|
||||
|
||||
jshort* indices = (jshort*) (*env)->GetDirectBufferAddress(env, indice_buf);
|
||||
jboolean isCopy;
|
||||
float* orig_points = (float*) (*env)->GetPrimitiveArrayCritical(env, obj_points, &isCopy);
|
||||
if (orig_points == NULL)
|
||||
return 0;
|
||||
|
||||
float* orig_points = (float*) (*env)->GetPrimitiveArrayCritical(env,
|
||||
obj_points, &isCopy);
|
||||
if (orig_points == NULL)
|
||||
return 0;
|
||||
if (isCopy)
|
||||
printf("Poor bugger: VM copied array");
|
||||
|
||||
if (isCopy)
|
||||
printf("Poor bugger: VM copied array");
|
||||
float *points = orig_points + pos;
|
||||
|
||||
float *points = orig_points + pos;
|
||||
TriangleIO in, out;
|
||||
char buf[128];
|
||||
|
||||
TriangleIO in, out;
|
||||
char buf[128];
|
||||
memset(&in, 0, sizeof(TriangleIO));
|
||||
|
||||
memset(&in, 0, sizeof(TriangleIO));
|
||||
in.numberofpoints = len >> 1;
|
||||
in.pointlist = (float *) points;
|
||||
|
||||
in.numberofpoints = len >> 1;
|
||||
in.pointlist = (float *) points;
|
||||
// check if explicitly closed
|
||||
if (in.pointlist[0] == in.pointlist[indices[0] - 2]
|
||||
&& in.pointlist[1] == in.pointlist[indices[0] - 1]) {
|
||||
int point = 0;
|
||||
for (int i = 0; i < num_rings; i++) {
|
||||
// remove last point in ring
|
||||
indices[i] -= 2;
|
||||
int last = point + (indices[i] >> 1);
|
||||
|
||||
// check if explicitly closed
|
||||
if (in.pointlist[0] == in.pointlist[indices[0] - 2]
|
||||
&& in.pointlist[1] == in.pointlist[indices[0] - 1])
|
||||
{
|
||||
int point = 0;
|
||||
for (int i = 0; i < num_rings; i++)
|
||||
{
|
||||
// remove last point in ring
|
||||
indices[i] -= 2;
|
||||
int last = point + (indices[i] >> 1);
|
||||
if (in.numberofpoints - last > 1)
|
||||
memmove(in.pointlist + (last * 2), in.pointlist + ((last + 1) * 2),
|
||||
(in.numberofpoints - last - 1) * 2 * sizeof(float));
|
||||
|
||||
if (in.numberofpoints - last > 1)
|
||||
memmove(in.pointlist + (last * 2),
|
||||
in.pointlist + ((last + 1) * 2),
|
||||
(in.numberofpoints - last - 1) * 2 * sizeof(float));
|
||||
in.numberofpoints--;
|
||||
point = last;
|
||||
}
|
||||
}
|
||||
|
||||
in.numberofpoints--;
|
||||
point = last;
|
||||
}
|
||||
}
|
||||
int dups = 0;
|
||||
|
||||
int dups = 0;
|
||||
float *i_points = points;
|
||||
int *skip_list = NULL;
|
||||
|
||||
float *i_points = points;
|
||||
int *skip_list = NULL;
|
||||
// check for duplicate vertices and keep a list
|
||||
// of dups and the first occurence
|
||||
for (int i = 0; i < in.numberofpoints - 1; i++) {
|
||||
float x = *i_points++;
|
||||
float y = *i_points++;
|
||||
float *j_points = i_points;
|
||||
|
||||
// check for duplicate vertices and keep a list
|
||||
// of dups and the first occurence
|
||||
for (int i = 0; i < in.numberofpoints - 1; i++)
|
||||
{
|
||||
float x = *i_points++;
|
||||
float y = *i_points++;
|
||||
float *j_points = i_points;
|
||||
|
||||
for (int j = i + 1; j < in.numberofpoints; j++, j_points += 2)
|
||||
{
|
||||
if ((*j_points == x) && (*(j_points + 1) == y))
|
||||
{
|
||||
skip_list = realloc(skip_list, (dups + 2) * 2 * sizeof(int));
|
||||
skip_list[dups * 2 + 0] = j;
|
||||
skip_list[dups * 2 + 1] = i;
|
||||
dups++;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int j = i + 1; j < in.numberofpoints; j++, j_points += 2) {
|
||||
if ((*j_points == x) && (*(j_points + 1) == y)) {
|
||||
skip_list = realloc(skip_list, (dups + 2) * 2 * sizeof(int));
|
||||
skip_list[dups * 2 + 0] = j;
|
||||
skip_list[dups * 2 + 1] = i;
|
||||
dups++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef TESTING
|
||||
for (i = 0; i < in.numberofpoints; i++)
|
||||
{
|
||||
printf("point: %f, %f\n", points[i*2], points[i*2+1]);
|
||||
}
|
||||
printf("points: %d, rings: %d\n", in.numberofpoints, num_rings);
|
||||
for (i = 0; i < in.numberofpoints; i++)
|
||||
{
|
||||
printf("point: %f, %f\n", points[i*2], points[i*2+1]);
|
||||
}
|
||||
printf("points: %d, rings: %d\n", in.numberofpoints, num_rings);
|
||||
#endif
|
||||
in.segmentlist = (int *) malloc(in.numberofpoints * 2 * sizeof(int));
|
||||
in.numberofsegments = in.numberofpoints;
|
||||
in.numberofholes = num_rings - 1;
|
||||
in.segmentlist = (int *) malloc(in.numberofpoints * 2 * sizeof(int));
|
||||
in.numberofsegments = in.numberofpoints;
|
||||
in.numberofholes = num_rings - 1;
|
||||
|
||||
int *rings = NULL;
|
||||
if (in.numberofholes > 0)
|
||||
{
|
||||
in.holelist = (float *) malloc(in.numberofholes * 2 * sizeof(float));
|
||||
rings = (int*) malloc(num_rings * sizeof(int));
|
||||
}
|
||||
int *rings = NULL;
|
||||
if (in.numberofholes > 0) {
|
||||
in.holelist = (float *) malloc(in.numberofholes * 2 * sizeof(float));
|
||||
rings = (int*) malloc(num_rings * sizeof(int));
|
||||
}
|
||||
|
||||
int *seg = in.segmentlist;
|
||||
float *hole = in.holelist;
|
||||
int *seg = in.segmentlist;
|
||||
float *hole = in.holelist;
|
||||
|
||||
// counter going through all points
|
||||
int point;
|
||||
// counter going through all rings
|
||||
int ring;
|
||||
// counter going through all points
|
||||
int point;
|
||||
// counter going through all rings
|
||||
int ring;
|
||||
|
||||
// assign all points to segments for each ring
|
||||
for (ring = 0, point = 0; ring < num_rings; ring++, point++)
|
||||
{
|
||||
int len;
|
||||
int num_points = indices[ring] >> 1;
|
||||
// assign all points to segments for each ring
|
||||
for (ring = 0, point = 0; ring < num_rings; ring++, point++) {
|
||||
int len;
|
||||
int num_points = indices[ring] >> 1;
|
||||
|
||||
if (rings)
|
||||
rings[ring] = num_points;
|
||||
if (rings)
|
||||
rings[ring] = num_points;
|
||||
|
||||
// add holes: we need a point inside the hole...
|
||||
// this is just a heuristic, assuming that two
|
||||
// 'parallel' lines have a distance of at least
|
||||
// 1 unit. you'll notice when things went wrong
|
||||
// when the hole is rendered instead of the poly
|
||||
if (ring > 0)
|
||||
{
|
||||
int k = point * 2;
|
||||
// add holes: we need a point inside the hole...
|
||||
// this is just a heuristic, assuming that two
|
||||
// 'parallel' lines have a distance of at least
|
||||
// 1 unit. you'll notice when things went wrong
|
||||
// when the hole is rendered instead of the poly
|
||||
if (ring > 0) {
|
||||
int k = point * 2;
|
||||
|
||||
float nx = in.pointlist[k++];
|
||||
float ny = in.pointlist[k++];
|
||||
float nx = in.pointlist[k++];
|
||||
float ny = in.pointlist[k++];
|
||||
|
||||
float cx, cy, vx, vy;
|
||||
float cx, cy, vx, vy;
|
||||
|
||||
// try to find a large enough segment
|
||||
for (len = (point + num_points) * 2; k < len;)
|
||||
{
|
||||
cx = nx;
|
||||
cy = ny;
|
||||
// try to find a large enough segment
|
||||
for (len = (point + num_points) * 2; k < len;) {
|
||||
cx = nx;
|
||||
cy = ny;
|
||||
|
||||
nx = in.pointlist[k++];
|
||||
ny = in.pointlist[k++];
|
||||
nx = in.pointlist[k++];
|
||||
ny = in.pointlist[k++];
|
||||
|
||||
vx = nx - cx;
|
||||
vy = ny - cy;
|
||||
vx = nx - cx;
|
||||
vy = ny - cy;
|
||||
|
||||
if (vx > 4 || vx < -4 || vy > 4 || vy < -4)
|
||||
break;
|
||||
}
|
||||
if (vx > 4 || vx < -4 || vy > 4 || vy < -4)
|
||||
break;
|
||||
}
|
||||
|
||||
float a = sqrt(vx * vx + vy * vy);
|
||||
float a = sqrt(vx * vx + vy * vy);
|
||||
|
||||
float ux = -vy / a;
|
||||
float uy = vx / a;
|
||||
float ux = -vy / a;
|
||||
float uy = vx / a;
|
||||
|
||||
float centerx = cx + vx / 2 - ux;
|
||||
float centery = cy + vy / 2 - uy;
|
||||
float centerx = cx + vx / 2 - ux;
|
||||
float centery = cy + vy / 2 - uy;
|
||||
|
||||
*hole++ = centerx;
|
||||
*hole++ = centery;
|
||||
}
|
||||
*hole++ = centerx;
|
||||
*hole++ = centery;
|
||||
}
|
||||
|
||||
// close ring
|
||||
int last = point + (num_points - 1);
|
||||
*seg++ = last;
|
||||
*seg++ = point;
|
||||
// close ring
|
||||
int last = point + (num_points - 1);
|
||||
*seg++ = last;
|
||||
*seg++ = point;
|
||||
|
||||
for (len = point + num_points - 1; point < len; point++)
|
||||
{
|
||||
*seg++ = point;
|
||||
*seg++ = point + 1;
|
||||
}
|
||||
}
|
||||
for (len = point + num_points - 1; point < len; point++) {
|
||||
*seg++ = point;
|
||||
*seg++ = point + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (dups)
|
||||
{
|
||||
for (int i = 0; i < dups; i++)
|
||||
{
|
||||
printf( "duplicate points at %d, %d: %f,%f\n",
|
||||
skip_list[i*2], skip_list[i*2+1],
|
||||
in.pointlist[skip_list[i*2+1]*2],
|
||||
in.pointlist[skip_list[i*2+1]*2+1]);
|
||||
}
|
||||
// print poly format to check with triangle/showme
|
||||
for (int j = 0; j < in.numberofpoints; j++)
|
||||
printf("%d %f %f\n", j, in.pointlist[j*2], in.pointlist[j*2+1]);
|
||||
if (dups) {
|
||||
for (int i = 0; i < dups; i++) {
|
||||
printf(
|
||||
"duplicate points at %d, %d: %f,%f\n", skip_list[i*2], skip_list[i*2+1], in.pointlist[skip_list[i*2+1]*2], in.pointlist[skip_list[i*2+1]*2+1]);
|
||||
}
|
||||
// print poly format to check with triangle/showme
|
||||
for (int j = 0; j < in.numberofpoints; j++)
|
||||
printf("%d %f %f\n", j, in.pointlist[j*2], in.pointlist[j*2+1]);
|
||||
|
||||
seg = in.segmentlist;
|
||||
for (int j = 0; j < in.numberofsegments; j++, seg += 2)
|
||||
printf("%d %d %d\n", j, *seg, *(seg+1));
|
||||
seg = in.segmentlist;
|
||||
for (int j = 0; j < in.numberofsegments; j++, seg += 2)
|
||||
printf("%d %d %d\n", j, *seg, *(seg+1));
|
||||
|
||||
for (int j = 0; j < in.numberofholes; j++)
|
||||
{
|
||||
printf("%d %f %f\n", j, in.holelist[j*2], in.holelist[j*2+1]);
|
||||
}
|
||||
for (int j = 0; j < in.numberofholes; j++) {
|
||||
printf("%d %f %f\n", j, in.holelist[j*2], in.holelist[j*2+1]);
|
||||
}
|
||||
|
||||
if (0)
|
||||
{
|
||||
free(in.segmentlist);
|
||||
free(in.holelist);
|
||||
free(rings);
|
||||
free(skip_list);
|
||||
return 0;
|
||||
}
|
||||
if (dups == 2)
|
||||
{
|
||||
if (skip_list[0] > skip_list[2])
|
||||
{
|
||||
int tmp = skip_list[0];
|
||||
skip_list[0] = skip_list[2];
|
||||
skip_list[2] = tmp;
|
||||
if (0) {
|
||||
free(in.segmentlist);
|
||||
free(in.holelist);
|
||||
free(rings);
|
||||
free(skip_list);
|
||||
return 0;
|
||||
}
|
||||
if (dups == 2) {
|
||||
if (skip_list[0] > skip_list[2]) {
|
||||
int tmp = skip_list[0];
|
||||
skip_list[0] = skip_list[2];
|
||||
skip_list[2] = tmp;
|
||||
|
||||
tmp = skip_list[1];
|
||||
skip_list[1] = skip_list[3];
|
||||
skip_list[3] = tmp;
|
||||
tmp = skip_list[1];
|
||||
skip_list[1] = skip_list[3];
|
||||
skip_list[3] = tmp;
|
||||
|
||||
printf("flip items\n");
|
||||
}
|
||||
}
|
||||
else if (dups > 2)
|
||||
{
|
||||
printf("sort dups\n");
|
||||
printf("flip items\n");
|
||||
}
|
||||
}
|
||||
else if (dups > 2) {
|
||||
printf("sort dups\n");
|
||||
|
||||
qsort(skip_list, dups, 2 * sizeof(float), compare_dups);
|
||||
}
|
||||
qsort(skip_list, dups, 2 * sizeof(float), compare_dups);
|
||||
}
|
||||
|
||||
// shift segment indices while removing duplicate points
|
||||
for (int i = 0; i < dups; i++)
|
||||
{
|
||||
// position of the duplicate vertex
|
||||
int pos = skip_list[i * 2] - i;
|
||||
// first vertex
|
||||
int replacement = skip_list[i * 2 + 1];
|
||||
// shift segment indices while removing duplicate points
|
||||
for (int i = 0; i < dups; i++) {
|
||||
// position of the duplicate vertex
|
||||
int pos = skip_list[i * 2] - i;
|
||||
// first vertex
|
||||
int replacement = skip_list[i * 2 + 1];
|
||||
|
||||
printf("add offset: %d, from pos %d\n", i, pos);
|
||||
seg = in.segmentlist;
|
||||
for (int j = 0; j < in.numberofsegments * 2; j++, seg++)
|
||||
{
|
||||
if (*seg == pos)
|
||||
{
|
||||
if (replacement >= pos)
|
||||
*seg = replacement - i;
|
||||
else
|
||||
*seg = replacement;
|
||||
}
|
||||
else if (*seg > pos)
|
||||
*seg -= 1;
|
||||
}
|
||||
printf("add offset: %d, from pos %d\n", i, pos);
|
||||
seg = in.segmentlist;
|
||||
for (int j = 0; j < in.numberofsegments * 2; j++, seg++) {
|
||||
if (*seg == pos) {
|
||||
if (replacement >= pos)
|
||||
*seg = replacement - i;
|
||||
else
|
||||
*seg = replacement;
|
||||
}
|
||||
else if (*seg > pos)
|
||||
*seg -= 1;
|
||||
}
|
||||
|
||||
printf(
|
||||
"move %d %d %d\n", pos, pos + 1, in.numberofpoints - pos - 1);
|
||||
printf( "move %d %d %d\n", pos, pos + 1, in.numberofpoints - pos - 1);
|
||||
|
||||
if (in.numberofpoints - pos > 1)
|
||||
memmove(in.pointlist + (pos * 2),
|
||||
in.pointlist + ((pos + 1) * 2),
|
||||
(in.numberofpoints - pos - 1) * 2 * sizeof(float));
|
||||
if (in.numberofpoints - pos > 1)
|
||||
memmove(in.pointlist + (pos * 2), in.pointlist + ((pos + 1) * 2),
|
||||
(in.numberofpoints - pos - 1) * 2 * sizeof(float));
|
||||
|
||||
in.numberofpoints--;
|
||||
}
|
||||
}
|
||||
in.numberofpoints--;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef TESTING
|
||||
for (i = 0; i < in.numberofsegments; i++)
|
||||
{
|
||||
printf("segment: %d, %d\n",
|
||||
in.segmentlist[i*2], in.segmentlist[i*2+1]);
|
||||
}
|
||||
for (i = 0; i < in.numberofsegments; i++)
|
||||
{
|
||||
printf("segment: %d, %d\n",
|
||||
in.segmentlist[i*2], in.segmentlist[i*2+1]);
|
||||
}
|
||||
|
||||
for (i = 0; i < in.numberofholes; i++)
|
||||
{
|
||||
printf("hole: %f, %f\n",
|
||||
in.holelist[i*2], in.holelist[i*2+1]);
|
||||
}
|
||||
for (i = 0; i < in.numberofholes; i++)
|
||||
{
|
||||
printf("hole: %f, %f\n",
|
||||
in.holelist[i*2], in.holelist[i*2+1]);
|
||||
}
|
||||
#endif
|
||||
|
||||
memset(&out, 0, sizeof(TriangleIO));
|
||||
out.trianglelist = (INDICE*) indices;
|
||||
memset(&out, 0, sizeof(TriangleIO));
|
||||
out.trianglelist = (INDICE*) indices;
|
||||
|
||||
// p - use polygon input, for CDT
|
||||
// z - zero offset array offsets...
|
||||
// P - no poly output
|
||||
// N - no node output
|
||||
// B - no bound output
|
||||
// Q - be quiet!
|
||||
triangulate("pzPNBQ", &in, &out, (TriangleIO *) NULL);
|
||||
// p - use polygon input, for CDT
|
||||
// z - zero offset array offsets...
|
||||
// P - no poly output
|
||||
// N - no node output
|
||||
// B - no bound output
|
||||
// Q - be quiet!
|
||||
|
||||
if (in.numberofpoints < out.numberofpoints)
|
||||
{
|
||||
printf( "polygon input is bad! points in:%d out%d\n",
|
||||
in.numberofpoints,
|
||||
out.numberofpoints);
|
||||
TriangleOptions opt;
|
||||
memset(&opt, 0, sizeof(TriangleOptions));
|
||||
|
||||
for (int j = 0; j < in.numberofpoints; j++)
|
||||
{
|
||||
printf("%d %f %f\n", j, in.pointlist[j*2], in.pointlist[j*2+1]);
|
||||
}
|
||||
opt.dwyer = 1;
|
||||
opt.steiner = -1;
|
||||
opt.order = 1;
|
||||
opt.maxarea = -1.0;
|
||||
|
||||
seg = in.segmentlist;
|
||||
for (int j = 0; j < in.numberofsegments; j++, seg += 2)
|
||||
{
|
||||
printf("%d %d %d\n", j, *seg, *(seg+1));
|
||||
}
|
||||
(*env)->ReleasePrimitiveArrayCritical(env, obj_points, orig_points,
|
||||
JNI_ABORT);
|
||||
free(in.segmentlist);
|
||||
free(in.holelist);
|
||||
free(rings);
|
||||
return 0;
|
||||
}
|
||||
opt.poly = 1;
|
||||
opt.usesegments = 1;
|
||||
opt.nopolywritten = 1;
|
||||
opt.nonodewritten = 1;
|
||||
opt.nobound = 1;
|
||||
opt.quiet = 1;
|
||||
|
||||
triangulate(&opt, &in, &out, (TriangleIO *) NULL);
|
||||
|
||||
if (in.numberofpoints < out.numberofpoints) {
|
||||
printf( "polygon input is bad! points in:%d out%d\n", in.numberofpoints, out.numberofpoints);
|
||||
|
||||
for (int j = 0; j < in.numberofpoints; j++) {
|
||||
printf("%d %f %f\n", j, in.pointlist[j*2], in.pointlist[j*2+1]);
|
||||
}
|
||||
|
||||
seg = in.segmentlist;
|
||||
for (int j = 0; j < in.numberofsegments; j++, seg += 2) {
|
||||
printf("%d %d %d\n", j, *seg, *(seg+1));
|
||||
}
|
||||
(*env)->ReleasePrimitiveArrayCritical(env, obj_points, orig_points, JNI_ABORT);
|
||||
free(in.segmentlist);
|
||||
free(in.holelist);
|
||||
free(rings);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef TESTING
|
||||
printf( "triangles: %d\n", out.numberoftriangles);
|
||||
printf( "triangles: %d\n", out.numberoftriangles);
|
||||
|
||||
for (int i = 0; i < out.numberoftriangles; i++)
|
||||
{
|
||||
printf("> %d, %d, %d\n",out.trianglelist[i*3],
|
||||
out.trianglelist[i*3+1],
|
||||
out.trianglelist[i*3+2]);
|
||||
}
|
||||
for (int i = 0; i < out.numberoftriangles; i++)
|
||||
{
|
||||
printf("> %d, %d, %d\n",out.trianglelist[i*3],
|
||||
out.trianglelist[i*3+1],
|
||||
out.trianglelist[i*3+2]);
|
||||
}
|
||||
#endif
|
||||
|
||||
INDICE *tri;
|
||||
INDICE *tri;
|
||||
|
||||
/* shift back indices from removed duplicates */
|
||||
for (int i = 0; i < dups; i++)
|
||||
{
|
||||
int pos = skip_list[i * 2] + i;
|
||||
/* shift back indices from removed duplicates */
|
||||
for (int i = 0; i < dups; i++) {
|
||||
int pos = skip_list[i * 2] + i;
|
||||
|
||||
tri = out.trianglelist;
|
||||
int n = out.numberoftriangles * 3;
|
||||
tri = out.trianglelist;
|
||||
int n = out.numberoftriangles * 3;
|
||||
|
||||
for (; n-- > 0; tri++)
|
||||
if (*tri >= pos)
|
||||
*tri += 1;
|
||||
}
|
||||
for (; n-- > 0; tri++)
|
||||
if (*tri >= pos)
|
||||
*tri += 1;
|
||||
}
|
||||
|
||||
/* fix offset to vertex buffer indices */
|
||||
/* fix offset to vertex buffer indices */
|
||||
|
||||
// scale to stride and add offset
|
||||
short stride = 2;
|
||||
// scale to stride and add offset
|
||||
short stride = 2;
|
||||
|
||||
if (offset < 0)
|
||||
offset = 0;
|
||||
if (offset < 0)
|
||||
offset = 0;
|
||||
|
||||
tri = out.trianglelist;
|
||||
for (int n = out.numberoftriangles * 3; n > 0; n--)
|
||||
*tri++ = *tri * stride + offset;
|
||||
tri = out.trianglelist;
|
||||
for (int n = out.numberoftriangles * 3; n > 0; n--)
|
||||
*tri++ = *tri * stride + offset;
|
||||
|
||||
// when a ring has an odd number of points one (or rather two)
|
||||
// additional vertices will be added. so the following rings
|
||||
// needs extra offset...
|
||||
int start = offset;
|
||||
for (int j = 0, m = in.numberofholes; j < m; j++)
|
||||
{
|
||||
start += rings[j] * stride;
|
||||
// even number of points?
|
||||
if (!(rings[j] & 1))
|
||||
continue;
|
||||
// when a ring has an odd number of points one (or rather two)
|
||||
// additional vertices will be added. so the following rings
|
||||
// needs extra offset...
|
||||
int start = offset;
|
||||
for (int j = 0, m = in.numberofholes; j < m; j++) {
|
||||
start += rings[j] * stride;
|
||||
// even number of points?
|
||||
if (!(rings[j] & 1))
|
||||
continue;
|
||||
|
||||
tri = out.trianglelist;
|
||||
int n = out.numberoftriangles * 3;
|
||||
tri = out.trianglelist;
|
||||
int n = out.numberoftriangles * 3;
|
||||
|
||||
for (; n-- > 0; tri++)
|
||||
if (*tri >= start)
|
||||
*tri += stride;
|
||||
for (; n-- > 0; tri++)
|
||||
if (*tri >= start)
|
||||
*tri += stride;
|
||||
|
||||
start += stride;
|
||||
}
|
||||
start += stride;
|
||||
}
|
||||
|
||||
(*env)->ReleasePrimitiveArrayCritical(env, obj_points, orig_points,
|
||||
JNI_ABORT);
|
||||
(*env)->ReleasePrimitiveArrayCritical(env, obj_points, orig_points, JNI_ABORT);
|
||||
|
||||
free(in.segmentlist);
|
||||
free(in.holelist);
|
||||
free(rings);
|
||||
free(skip_list);
|
||||
free(in.segmentlist);
|
||||
free(in.holelist);
|
||||
free(rings);
|
||||
free(skip_list);
|
||||
|
||||
return out.numberoftriangles;
|
||||
return out.numberoftriangles;
|
||||
}
|
||||
|
||||
17497
jni/triangle/triangle.c
17497
jni/triangle/triangle.c
File diff suppressed because it is too large
Load Diff
@ -248,7 +248,6 @@
|
||||
/* */
|
||||
/*****************************************************************************/
|
||||
|
||||
|
||||
#define SINGLE
|
||||
|
||||
#ifdef SINGLE
|
||||
@ -259,42 +258,103 @@
|
||||
|
||||
#define INDICE unsigned short
|
||||
|
||||
typedef struct triangulateio TriangleIO;
|
||||
|
||||
struct triangulateio {
|
||||
REAL *pointlist; /* In / out */
|
||||
REAL *pointattributelist; /* In / out */
|
||||
int *pointmarkerlist; /* In / out */
|
||||
int numberofpoints; /* In / out */
|
||||
int numberofpointattributes; /* In / out */
|
||||
REAL *pointlist; /* In / out */
|
||||
REAL *pointattributelist; /* In / out */
|
||||
int *pointmarkerlist; /* In / out */
|
||||
int numberofpoints; /* In / out */
|
||||
int numberofpointattributes; /* In / out */
|
||||
|
||||
INDICE *trianglelist; /* In / out */
|
||||
REAL *triangleattributelist; /* In / out */
|
||||
REAL *trianglearealist; /* In only */
|
||||
int *neighborlist; /* Out only */
|
||||
int numberoftriangles; /* In / out */
|
||||
int numberofcorners; /* In / out */
|
||||
int numberoftriangleattributes; /* In / out */
|
||||
INDICE *trianglelist; /* In / out */
|
||||
REAL *triangleattributelist; /* In / out */
|
||||
REAL *trianglearealist; /* In only */
|
||||
int *neighborlist; /* Out only */
|
||||
int numberoftriangles; /* In / out */
|
||||
int numberofcorners; /* In / out */
|
||||
int numberoftriangleattributes; /* In / out */
|
||||
|
||||
int *segmentlist; /* In / out */
|
||||
int *segmentmarkerlist; /* In / out */
|
||||
int numberofsegments; /* In / out */
|
||||
int *segmentlist; /* In / out */
|
||||
int *segmentmarkerlist; /* In / out */
|
||||
int numberofsegments; /* In / out */
|
||||
|
||||
REAL *holelist; /* In / pointer to array copied out */
|
||||
int numberofholes; /* In / copied out */
|
||||
REAL *holelist; /* In / pointer to array copied out */
|
||||
int numberofholes; /* In / copied out */
|
||||
|
||||
REAL *regionlist; /* In / pointer to array copied out */
|
||||
int numberofregions; /* In / copied out */
|
||||
REAL *regionlist; /* In / pointer to array copied out */
|
||||
int numberofregions; /* In / copied out */
|
||||
|
||||
int *edgelist; /* Out only */
|
||||
int *edgemarkerlist; /* Not used with Voronoi diagram; out only */
|
||||
REAL *normlist; /* Used only with Voronoi diagram; out only */
|
||||
int numberofedges; /* Out only */
|
||||
int *edgelist; /* Out only */
|
||||
int *edgemarkerlist; /* Not used with Voronoi diagram; out only */
|
||||
REAL *normlist; /* Used only with Voronoi diagram; out only */
|
||||
int numberofedges; /* Out only */
|
||||
};
|
||||
|
||||
#ifdef ANSI_DECLARATORS
|
||||
void triangulate(char *, struct triangulateio *, struct triangulateio *,
|
||||
struct triangulateio *);
|
||||
void trifree(VOID *memptr);
|
||||
#else /* not ANSI_DECLARATORS */
|
||||
void triangulate();
|
||||
void trifree();
|
||||
#endif /* not ANSI_DECLARATORS */
|
||||
/* Data structure for command line switches and file names. This structure
|
||||
/* is used (instead of global variables) to allow reentrancy.
|
||||
|
||||
* Switches for the triangulator.
|
||||
* poly: -p switch.
|
||||
* refine: -r switch.
|
||||
* quality: -q switch.
|
||||
* minangle: minimum angle bound, specified after -q switch.
|
||||
* goodangle: cosine squared of minangle.
|
||||
* offconstant: constant used to place off-center Steiner points.
|
||||
* vararea: -a switch without number.
|
||||
* fixedarea: -a switch with number.
|
||||
* maxarea: maximum area bound, specified after -a switch.
|
||||
* usertest: -u switch.
|
||||
* regionattrib: -A switch.
|
||||
* convex: -c switch.
|
||||
* weighted: 1 for -w switch, 2 for -W switch.
|
||||
* jettison: -j switch
|
||||
* firstnumber: inverse of -z switch. All items are numbered starting
|
||||
* from `firstnumber'.
|
||||
* edgesout: -e switch.
|
||||
* voronoi: -v switch.
|
||||
* neighbors: -n switch.
|
||||
* geomview: -g switch.
|
||||
* nobound: -B switch.
|
||||
* nopolywritten: -P switch.
|
||||
* nonodewritten: -N switch.
|
||||
* noelewritten: -E switch.
|
||||
* noiterationnum: -I switch.
|
||||
* noholes: -O switch.
|
||||
* noexact: -X switch.
|
||||
* order: element order, specified after -o switch.
|
||||
* nobisect: count of how often -Y switch is selected.
|
||||
* steiner: maximum number of Steiner points, specified after -S switch.
|
||||
* incremental: -i switch. sweepline: -F switch.
|
||||
* dwyer: inverse of -l switch.
|
||||
* splitseg: -s switch.
|
||||
* conformdel: -D switch. docheck: -C switch.
|
||||
* quiet: -Q switch. verbose: count of how often -V switch is selected.
|
||||
* usesegments: -p, -r, -q, or -c switch; determines whether segments are
|
||||
* used at all.
|
||||
*
|
||||
* Read the instructions to find out the meaning of these switches. */
|
||||
|
||||
typedef struct behavior TriangleOptions;
|
||||
|
||||
struct behavior {
|
||||
int poly, refine, quality, vararea, fixedarea, usertest;
|
||||
int regionattrib, convex, weighted, jettison;
|
||||
int firstnumber;
|
||||
int edgesout, voronoi, neighbors, geomview;
|
||||
int nobound, nopolywritten, nonodewritten, noelewritten, noiterationnum;
|
||||
int noholes, noexact, conformdel;
|
||||
int incremental, sweepline, dwyer;
|
||||
int splitseg;
|
||||
int docheck;
|
||||
int quiet, verbose;
|
||||
int usesegments;
|
||||
int order;
|
||||
int nobisect;
|
||||
int steiner;REAL minangle, goodangle, offconstant;REAL maxarea;
|
||||
|
||||
};
|
||||
void parsecommandline(int argc, char **argv, struct behavior *b);
|
||||
void triangulate(struct behavior *, struct triangulateio *, struct triangulateio *,
|
||||
struct triangulateio *);
|
||||
|
||||
|
||||
441
jni/triangle/triangle_dbg.c
Normal file
441
jni/triangle/triangle_dbg.c
Normal file
@ -0,0 +1,441 @@
|
||||
#include "triangle_private.h"
|
||||
|
||||
/*****************************************************************************/
|
||||
/* */
|
||||
/* quality_statistics() Print statistics about the quality of the mesh. */
|
||||
/* */
|
||||
/*****************************************************************************/
|
||||
|
||||
void quality_statistics(struct mesh *m, struct behavior *b) {
|
||||
struct otri triangleloop;
|
||||
vertex p[3];
|
||||
REAL cossquaretable[8];
|
||||
REAL ratiotable[16];
|
||||
REAL dx[3], dy[3];
|
||||
REAL edgelength[3];
|
||||
REAL dotproduct;
|
||||
REAL cossquare;
|
||||
REAL triarea;
|
||||
REAL shortest, longest;
|
||||
REAL trilongest2;
|
||||
REAL smallestarea, biggestarea;
|
||||
REAL triminaltitude2;
|
||||
REAL minaltitude;
|
||||
REAL triaspect2;
|
||||
REAL worstaspect;
|
||||
REAL smallestangle, biggestangle;
|
||||
REAL radconst, degconst;
|
||||
int angletable[18];
|
||||
int aspecttable[16];
|
||||
int aspectindex;
|
||||
int tendegree;
|
||||
int acutebiggest;
|
||||
int i, ii, j, k;
|
||||
|
||||
printf("Mesh quality statistics:\n\n");
|
||||
radconst = PI / 18.0;
|
||||
degconst = 180.0 / PI;
|
||||
for (i = 0; i < 8; i++) {
|
||||
cossquaretable[i] = cos(radconst * (REAL) (i + 1));
|
||||
cossquaretable[i] = cossquaretable[i] * cossquaretable[i];
|
||||
}
|
||||
for (i = 0; i < 18; i++) {
|
||||
angletable[i] = 0;
|
||||
}
|
||||
|
||||
ratiotable[0] = 1.5;
|
||||
ratiotable[1] = 2.0;
|
||||
ratiotable[2] = 2.5;
|
||||
ratiotable[3] = 3.0;
|
||||
ratiotable[4] = 4.0;
|
||||
ratiotable[5] = 6.0;
|
||||
ratiotable[6] = 10.0;
|
||||
ratiotable[7] = 15.0;
|
||||
ratiotable[8] = 25.0;
|
||||
ratiotable[9] = 50.0;
|
||||
ratiotable[10] = 100.0;
|
||||
ratiotable[11] = 300.0;
|
||||
ratiotable[12] = 1000.0;
|
||||
ratiotable[13] = 10000.0;
|
||||
ratiotable[14] = 100000.0;
|
||||
ratiotable[15] = 0.0;
|
||||
for (i = 0; i < 16; i++) {
|
||||
aspecttable[i] = 0;
|
||||
}
|
||||
|
||||
worstaspect = 0.0;
|
||||
minaltitude = m->xmax - m->xmin + m->ymax - m->ymin;
|
||||
minaltitude = minaltitude * minaltitude;
|
||||
shortest = minaltitude;
|
||||
longest = 0.0;
|
||||
smallestarea = minaltitude;
|
||||
biggestarea = 0.0;
|
||||
worstaspect = 0.0;
|
||||
smallestangle = 0.0;
|
||||
biggestangle = 2.0;
|
||||
acutebiggest = 1;
|
||||
|
||||
traversalinit(&m->triangles);
|
||||
triangleloop.tri = triangletraverse(m);
|
||||
triangleloop.orient = 0;
|
||||
while (triangleloop.tri != (triangle *) NULL) {
|
||||
org(triangleloop, p[0]);
|
||||
dest(triangleloop, p[1]);
|
||||
apex(triangleloop, p[2]);
|
||||
trilongest2 = 0.0;
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
j = plus1mod3[i];
|
||||
k = minus1mod3[i];
|
||||
dx[i] = p[j][0] - p[k][0];
|
||||
dy[i] = p[j][1] - p[k][1];
|
||||
edgelength[i] = dx[i] * dx[i] + dy[i] * dy[i];
|
||||
if (edgelength[i] > trilongest2) {
|
||||
trilongest2 = edgelength[i];
|
||||
}
|
||||
if (edgelength[i] > longest) {
|
||||
longest = edgelength[i];
|
||||
}
|
||||
if (edgelength[i] < shortest) {
|
||||
shortest = edgelength[i];
|
||||
}
|
||||
}
|
||||
|
||||
triarea = counterclockwise(m, b, p[0], p[1], p[2]);
|
||||
if (triarea < smallestarea) {
|
||||
smallestarea = triarea;
|
||||
}
|
||||
if (triarea > biggestarea) {
|
||||
biggestarea = triarea;
|
||||
}
|
||||
triminaltitude2 = triarea * triarea / trilongest2;
|
||||
if (triminaltitude2 < minaltitude) {
|
||||
minaltitude = triminaltitude2;
|
||||
}
|
||||
triaspect2 = trilongest2 / triminaltitude2;
|
||||
if (triaspect2 > worstaspect) {
|
||||
worstaspect = triaspect2;
|
||||
}
|
||||
aspectindex = 0;
|
||||
while ((triaspect2 > ratiotable[aspectindex] * ratiotable[aspectindex]) && (aspectindex < 15)) {
|
||||
aspectindex++;
|
||||
}
|
||||
aspecttable[aspectindex]++;
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
j = plus1mod3[i];
|
||||
k = minus1mod3[i];
|
||||
dotproduct = dx[j] * dx[k] + dy[j] * dy[k];
|
||||
cossquare = dotproduct * dotproduct / (edgelength[j] * edgelength[k]);
|
||||
tendegree = 8;
|
||||
for (ii = 7; ii >= 0; ii--) {
|
||||
if (cossquare > cossquaretable[ii]) {
|
||||
tendegree = ii;
|
||||
}
|
||||
}
|
||||
if (dotproduct <= 0.0) {
|
||||
angletable[tendegree]++;
|
||||
if (cossquare > smallestangle) {
|
||||
smallestangle = cossquare;
|
||||
}
|
||||
if (acutebiggest && (cossquare < biggestangle)) {
|
||||
biggestangle = cossquare;
|
||||
}
|
||||
}
|
||||
else {
|
||||
angletable[17 - tendegree]++;
|
||||
if (acutebiggest || (cossquare > biggestangle)) {
|
||||
biggestangle = cossquare;
|
||||
acutebiggest = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
triangleloop.tri = triangletraverse(m);
|
||||
}
|
||||
|
||||
shortest = sqrt(shortest);
|
||||
longest = sqrt(longest);
|
||||
minaltitude = sqrt(minaltitude);
|
||||
worstaspect = sqrt(worstaspect);
|
||||
smallestarea *= 0.5;
|
||||
biggestarea *= 0.5;
|
||||
if (smallestangle >= 1.0) {
|
||||
smallestangle = 0.0;
|
||||
}
|
||||
else {
|
||||
smallestangle = degconst * acos(sqrt(smallestangle));
|
||||
}
|
||||
if (biggestangle >= 1.0) {
|
||||
biggestangle = 180.0;
|
||||
}
|
||||
else {
|
||||
if (acutebiggest) {
|
||||
biggestangle = degconst * acos(sqrt(biggestangle));
|
||||
}
|
||||
else {
|
||||
biggestangle = 180.0 - degconst * acos(sqrt(biggestangle));
|
||||
}
|
||||
}
|
||||
|
||||
printf(" Smallest area: %16.5g | Largest area: %16.5g\n", smallestarea, biggestarea);
|
||||
printf(" Shortest edge: %16.5g | Longest edge: %16.5g\n", shortest, longest);
|
||||
printf(
|
||||
" Shortest altitude: %12.5g | Largest aspect ratio: %8.5g\n\n", minaltitude, worstaspect);
|
||||
|
||||
printf(" Triangle aspect ratio histogram:\n");
|
||||
printf(
|
||||
" 1.1547 - %-6.6g : %8d | %6.6g - %-6.6g : %8d\n", ratiotable[0], aspecttable[0], ratiotable[7], ratiotable[8], aspecttable[8]);
|
||||
for (i = 1; i < 7; i++) {
|
||||
printf(
|
||||
" %6.6g - %-6.6g : %8d | %6.6g - %-6.6g : %8d\n", ratiotable[i - 1], ratiotable[i], aspecttable[i], ratiotable[i + 7], ratiotable[i + 8], aspecttable[i + 8]);
|
||||
}
|
||||
printf(
|
||||
" %6.6g - %-6.6g : %8d | %6.6g - : %8d\n", ratiotable[6], ratiotable[7], aspecttable[7], ratiotable[14], aspecttable[15]);
|
||||
printf(" (Aspect ratio is longest edge divided by shortest altitude)\n\n");
|
||||
|
||||
printf(" Smallest angle: %15.5g | Largest angle: %15.5g\n\n", smallestangle, biggestangle);
|
||||
|
||||
printf(" Angle histogram:\n");
|
||||
for (i = 0; i < 9; i++) {
|
||||
printf(
|
||||
" %3d - %3d degrees: %8d | %3d - %3d degrees: %8d\n", i * 10, i * 10 + 10, angletable[i], i * 10 + 90, i * 10 + 100, angletable[i + 9]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
/* */
|
||||
/* statistics() Print all sorts of cool facts. */
|
||||
/* */
|
||||
/*****************************************************************************/
|
||||
|
||||
void statistics(struct mesh *m, struct behavior *b) {
|
||||
printf("\nStatistics:\n\n");
|
||||
printf(" Input vertices: %d\n", m->invertices);
|
||||
if (b->refine) {
|
||||
printf(" Input triangles: %d\n", m->inelements);
|
||||
}
|
||||
if (b->poly) {
|
||||
printf(" Input segments: %d\n", m->insegments);
|
||||
if (!b->refine) {
|
||||
printf(" Input holes: %d\n", m->holes);
|
||||
}
|
||||
}
|
||||
|
||||
printf("\n Mesh vertices: %ld\n", m->vertices.items - m->undeads);
|
||||
printf(" Mesh triangles: %ld\n", m->triangles.items);
|
||||
printf(" Mesh edges: %ld\n", m->edges);
|
||||
printf(" Mesh exterior boundary edges: %ld\n", m->hullsize);
|
||||
if (b->poly || b->refine) {
|
||||
printf(" Mesh interior boundary edges: %ld\n", m->subsegs.items - m->hullsize);
|
||||
printf(" Mesh subsegments (constrained edges): %ld\n", m->subsegs.items);
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
if (b->verbose) {
|
||||
quality_statistics(m, b);
|
||||
printf("Memory allocation statistics:\n\n");
|
||||
printf(" Maximum number of vertices: %ld\n", m->vertices.maxitems);
|
||||
printf(" Maximum number of triangles: %ld\n", m->triangles.maxitems);
|
||||
if (m->subsegs.maxitems > 0) {
|
||||
printf(" Maximum number of subsegments: %ld\n", m->subsegs.maxitems);
|
||||
}
|
||||
if (m->viri.maxitems > 0) {
|
||||
printf(" Maximum number of viri: %ld\n", m->viri.maxitems);
|
||||
}
|
||||
if (m->badsubsegs.maxitems > 0) {
|
||||
printf(" Maximum number of encroached subsegments: %ld\n", m->badsubsegs.maxitems);
|
||||
}
|
||||
if (m->badtriangles.maxitems > 0) {
|
||||
printf(" Maximum number of bad triangles: %ld\n", m->badtriangles.maxitems);
|
||||
}
|
||||
if (m->flipstackers.maxitems > 0) {
|
||||
printf(" Maximum number of stacked triangle flips: %ld\n", m->flipstackers.maxitems);
|
||||
}
|
||||
if (m->splaynodes.maxitems > 0) {
|
||||
printf(" Maximum number of splay tree nodes: %ld\n", m->splaynodes.maxitems);
|
||||
}
|
||||
printf(
|
||||
" Approximate heap memory use (bytes): %ld\n\n", m->vertices.maxitems * m->vertices.itembytes + m->triangles.maxitems * m->triangles.itembytes + m->subsegs.maxitems * m->subsegs.itembytes + m->viri.maxitems * m->viri.itembytes + m->badsubsegs.maxitems * m->badsubsegs.itembytes + m->badtriangles.maxitems * m->badtriangles.itembytes + m->flipstackers.maxitems * m->flipstackers.itembytes + m->splaynodes.maxitems * m->splaynodes.itembytes);
|
||||
|
||||
printf("Algorithmic statistics:\n\n");
|
||||
if (!b->weighted) {
|
||||
printf(" Number of incircle tests: %ld\n", m->incirclecount);
|
||||
}
|
||||
else {
|
||||
printf(" Number of 3D orientation tests: %ld\n", m->orient3dcount);
|
||||
}
|
||||
printf(" Number of 2D orientation tests: %ld\n", m->counterclockcount);
|
||||
if (m->hyperbolacount > 0) {
|
||||
printf(" Number of right-of-hyperbola tests: %ld\n", m->hyperbolacount);
|
||||
}
|
||||
if (m->circletopcount > 0) {
|
||||
printf(" Number of circle top computations: %ld\n", m->circletopcount);
|
||||
}
|
||||
if (m->circumcentercount > 0) {
|
||||
printf(" Number of triangle circumcenter computations: %ld\n", m->circumcentercount);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
||||
/********* Debugging routines begin here *********/
|
||||
/** **/
|
||||
/** **/
|
||||
|
||||
/*****************************************************************************/
|
||||
/* */
|
||||
/* printtriangle() Print out the details of an oriented triangle. */
|
||||
/* */
|
||||
/* I originally wrote this procedure to simplify debugging; it can be */
|
||||
/* called directly from the debugger, and presents information about an */
|
||||
/* oriented triangle in digestible form. It's also used when the */
|
||||
/* highest level of verbosity (`-VVV') is specified. */
|
||||
/* */
|
||||
/*****************************************************************************/
|
||||
|
||||
void printtriangle(struct mesh *m, struct behavior *b, struct otri *t) {
|
||||
struct otri printtri;
|
||||
struct osub printsh;
|
||||
vertex printvertex;
|
||||
|
||||
printf("triangle x%lx with orientation %d:\n", (unsigned long) t->tri, t->orient);
|
||||
decode(t->tri[0], printtri);
|
||||
if (printtri.tri == m->dummytri) {
|
||||
printf(" [0] = Outer space\n");
|
||||
}
|
||||
else {
|
||||
printf(" [0] = x%lx %d\n", (unsigned long) printtri.tri, printtri.orient);
|
||||
}
|
||||
decode(t->tri[1], printtri);
|
||||
if (printtri.tri == m->dummytri) {
|
||||
printf(" [1] = Outer space\n");
|
||||
}
|
||||
else {
|
||||
printf(" [1] = x%lx %d\n", (unsigned long) printtri.tri, printtri.orient);
|
||||
}
|
||||
decode(t->tri[2], printtri);
|
||||
if (printtri.tri == m->dummytri) {
|
||||
printf(" [2] = Outer space\n");
|
||||
}
|
||||
else {
|
||||
printf(" [2] = x%lx %d\n", (unsigned long) printtri.tri, printtri.orient);
|
||||
}
|
||||
|
||||
org(*t, printvertex);
|
||||
if (printvertex == (vertex) NULL)
|
||||
printf(" Origin[%d] = NULL\n", (t->orient + 1) % 3 + 3);
|
||||
else
|
||||
printf(
|
||||
" Origin[%d] = x%lx (%.12g, %.12g)\n", (t->orient + 1) % 3 + 3, (unsigned long) printvertex, printvertex[0], printvertex[1]);
|
||||
dest(*t, printvertex);
|
||||
if (printvertex == (vertex) NULL)
|
||||
printf(" Dest [%d] = NULL\n", (t->orient + 2) % 3 + 3);
|
||||
else
|
||||
printf(
|
||||
" Dest [%d] = x%lx (%.12g, %.12g)\n", (t->orient + 2) % 3 + 3, (unsigned long) printvertex, printvertex[0], printvertex[1]);
|
||||
apex(*t, printvertex);
|
||||
if (printvertex == (vertex) NULL)
|
||||
printf(" Apex [%d] = NULL\n", t->orient + 3);
|
||||
else
|
||||
printf(
|
||||
" Apex [%d] = x%lx (%.12g, %.12g)\n", t->orient + 3, (unsigned long) printvertex, printvertex[0], printvertex[1]);
|
||||
|
||||
if (b->usesegments) {
|
||||
sdecode(t->tri[6], printsh);
|
||||
if (printsh.ss != m->dummysub) {
|
||||
printf(" [6] = x%lx %d\n", (unsigned long) printsh.ss, printsh.ssorient);
|
||||
}
|
||||
sdecode(t->tri[7], printsh);
|
||||
if (printsh.ss != m->dummysub) {
|
||||
printf(" [7] = x%lx %d\n", (unsigned long) printsh.ss, printsh.ssorient);
|
||||
}
|
||||
sdecode(t->tri[8], printsh);
|
||||
if (printsh.ss != m->dummysub) {
|
||||
printf(" [8] = x%lx %d\n", (unsigned long) printsh.ss, printsh.ssorient);
|
||||
}
|
||||
}
|
||||
|
||||
if (b->vararea) {
|
||||
printf(" Area constraint: %.4g\n", areabound(*t));
|
||||
}
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
/* */
|
||||
/* printsubseg() Print out the details of an oriented subsegment. */
|
||||
/* */
|
||||
/* I originally wrote this procedure to simplify debugging; it can be */
|
||||
/* called directly from the debugger, and presents information about an */
|
||||
/* oriented subsegment in digestible form. It's also used when the highest */
|
||||
/* level of verbosity (`-VVV') is specified. */
|
||||
/* */
|
||||
/*****************************************************************************/
|
||||
|
||||
void printsubseg(struct mesh *m, struct behavior *b, struct osub *s) {
|
||||
struct osub printsh;
|
||||
struct otri printtri;
|
||||
vertex printvertex;
|
||||
|
||||
printf(
|
||||
"subsegment x%lx with orientation %d and mark %d:\n", (unsigned long) s->ss, s->ssorient, mark(*s));
|
||||
sdecode(s->ss[0], printsh);
|
||||
if (printsh.ss == m->dummysub) {
|
||||
printf(" [0] = No subsegment\n");
|
||||
}
|
||||
else {
|
||||
printf(" [0] = x%lx %d\n", (unsigned long) printsh.ss, printsh.ssorient);
|
||||
}
|
||||
sdecode(s->ss[1], printsh);
|
||||
if (printsh.ss == m->dummysub) {
|
||||
printf(" [1] = No subsegment\n");
|
||||
}
|
||||
else {
|
||||
printf(" [1] = x%lx %d\n", (unsigned long) printsh.ss, printsh.ssorient);
|
||||
}
|
||||
|
||||
sorg(*s, printvertex);
|
||||
if (printvertex == (vertex) NULL)
|
||||
printf(" Origin[%d] = NULL\n", 2 + s->ssorient);
|
||||
else
|
||||
printf(
|
||||
" Origin[%d] = x%lx (%.12g, %.12g)\n", 2 + s->ssorient, (unsigned long) printvertex, printvertex[0], printvertex[1]);
|
||||
sdest(*s, printvertex);
|
||||
if (printvertex == (vertex) NULL)
|
||||
printf(" Dest [%d] = NULL\n", 3 - s->ssorient);
|
||||
else
|
||||
printf(
|
||||
" Dest [%d] = x%lx (%.12g, %.12g)\n", 3 - s->ssorient, (unsigned long) printvertex, printvertex[0], printvertex[1]);
|
||||
|
||||
decode(s->ss[6], printtri);
|
||||
if (printtri.tri == m->dummytri) {
|
||||
printf(" [6] = Outer space\n");
|
||||
}
|
||||
else {
|
||||
printf(" [6] = x%lx %d\n", (unsigned long) printtri.tri, printtri.orient);
|
||||
}
|
||||
decode(s->ss[7], printtri);
|
||||
if (printtri.tri == m->dummytri) {
|
||||
printf(" [7] = Outer space\n");
|
||||
}
|
||||
else {
|
||||
printf(" [7] = x%lx %d\n", (unsigned long) printtri.tri, printtri.orient);
|
||||
}
|
||||
|
||||
segorg(*s, printvertex);
|
||||
if (printvertex == (vertex) NULL)
|
||||
printf(" Segment origin[%d] = NULL\n", 4 + s->ssorient);
|
||||
else
|
||||
printf(
|
||||
" Segment origin[%d] = x%lx (%.12g, %.12g)\n", 4 + s->ssorient, (unsigned long) printvertex, printvertex[0], printvertex[1]);
|
||||
segdest(*s, printvertex);
|
||||
if (printvertex == (vertex) NULL)
|
||||
printf(" Segment dest [%d] = NULL\n", 5 - s->ssorient);
|
||||
else
|
||||
printf(
|
||||
" Segment dest [%d] = x%lx (%.12g, %.12g)\n", 5 - s->ssorient, (unsigned long) printvertex, printvertex[0], printvertex[1]);
|
||||
}
|
||||
|
||||
/** **/
|
||||
/** **/
|
||||
/********* Debugging routines end here *********/
|
||||
1067
jni/triangle/triangle_private.h
Normal file
1067
jni/triangle/triangle_private.h
Normal file
File diff suppressed because it is too large
Load Diff
Loading…
x
Reference in New Issue
Block a user