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 ?
|
# -DLINUX -> no fpu_control in bionic, needed ?
|
||||||
|
|
||||||
LOCAL_MODULE := triangle-jni
|
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
|
LOCAL_LDLIBS := -llog
|
||||||
|
|
||||||
include $(BUILD_SHARED_LIBRARY)
|
include $(BUILD_SHARED_LIBRARY)
|
||||||
|
|||||||
@ -27,26 +27,20 @@ int pnpoly(int nvert, float *vert, float testx, float testy)
|
|||||||
|
|
||||||
//#define TESTING
|
//#define TESTING
|
||||||
|
|
||||||
int compare_dups(const void *a, const void *b)
|
int compare_dups(const void *a, const void *b) {
|
||||||
{
|
|
||||||
int da = *((const int*) a);
|
int da = *((const int*) a);
|
||||||
int db = *((const int*) b);
|
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);
|
jshort* indices = (jshort*) (*env)->GetDirectBufferAddress(env, indice_buf);
|
||||||
jboolean isCopy;
|
jboolean isCopy;
|
||||||
|
|
||||||
float* orig_points = (float*) (*env)->GetPrimitiveArrayCritical(env,
|
float* orig_points = (float*) (*env)->GetPrimitiveArrayCritical(env, obj_points, &isCopy);
|
||||||
obj_points, &isCopy);
|
|
||||||
if (orig_points == NULL)
|
if (orig_points == NULL)
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
@ -65,18 +59,15 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
|
|
||||||
// check if explicitly closed
|
// check if explicitly closed
|
||||||
if (in.pointlist[0] == in.pointlist[indices[0] - 2]
|
if (in.pointlist[0] == in.pointlist[indices[0] - 2]
|
||||||
&& in.pointlist[1] == in.pointlist[indices[0] - 1])
|
&& in.pointlist[1] == in.pointlist[indices[0] - 1]) {
|
||||||
{
|
|
||||||
int point = 0;
|
int point = 0;
|
||||||
for (int i = 0; i < num_rings; i++)
|
for (int i = 0; i < num_rings; i++) {
|
||||||
{
|
|
||||||
// remove last point in ring
|
// remove last point in ring
|
||||||
indices[i] -= 2;
|
indices[i] -= 2;
|
||||||
int last = point + (indices[i] >> 1);
|
int last = point + (indices[i] >> 1);
|
||||||
|
|
||||||
if (in.numberofpoints - last > 1)
|
if (in.numberofpoints - last > 1)
|
||||||
memmove(in.pointlist + (last * 2),
|
memmove(in.pointlist + (last * 2), in.pointlist + ((last + 1) * 2),
|
||||||
in.pointlist + ((last + 1) * 2),
|
|
||||||
(in.numberofpoints - last - 1) * 2 * sizeof(float));
|
(in.numberofpoints - last - 1) * 2 * sizeof(float));
|
||||||
|
|
||||||
in.numberofpoints--;
|
in.numberofpoints--;
|
||||||
@ -91,16 +82,13 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
|
|
||||||
// check for duplicate vertices and keep a list
|
// check for duplicate vertices and keep a list
|
||||||
// of dups and the first occurence
|
// of dups and the first occurence
|
||||||
for (int i = 0; i < in.numberofpoints - 1; i++)
|
for (int i = 0; i < in.numberofpoints - 1; i++) {
|
||||||
{
|
|
||||||
float x = *i_points++;
|
float x = *i_points++;
|
||||||
float y = *i_points++;
|
float y = *i_points++;
|
||||||
float *j_points = i_points;
|
float *j_points = i_points;
|
||||||
|
|
||||||
for (int j = i + 1; j < in.numberofpoints; j++, j_points += 2)
|
for (int j = i + 1; j < in.numberofpoints; j++, j_points += 2) {
|
||||||
{
|
if ((*j_points == x) && (*(j_points + 1) == y)) {
|
||||||
if ((*j_points == x) && (*(j_points + 1) == y))
|
|
||||||
{
|
|
||||||
skip_list = realloc(skip_list, (dups + 2) * 2 * sizeof(int));
|
skip_list = realloc(skip_list, (dups + 2) * 2 * sizeof(int));
|
||||||
skip_list[dups * 2 + 0] = j;
|
skip_list[dups * 2 + 0] = j;
|
||||||
skip_list[dups * 2 + 1] = i;
|
skip_list[dups * 2 + 1] = i;
|
||||||
@ -121,8 +109,7 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
in.numberofholes = num_rings - 1;
|
in.numberofholes = num_rings - 1;
|
||||||
|
|
||||||
int *rings = NULL;
|
int *rings = NULL;
|
||||||
if (in.numberofholes > 0)
|
if (in.numberofholes > 0) {
|
||||||
{
|
|
||||||
in.holelist = (float *) malloc(in.numberofholes * 2 * sizeof(float));
|
in.holelist = (float *) malloc(in.numberofholes * 2 * sizeof(float));
|
||||||
rings = (int*) malloc(num_rings * sizeof(int));
|
rings = (int*) malloc(num_rings * sizeof(int));
|
||||||
}
|
}
|
||||||
@ -136,8 +123,7 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
int ring;
|
int ring;
|
||||||
|
|
||||||
// assign all points to segments for each ring
|
// assign all points to segments for each ring
|
||||||
for (ring = 0, point = 0; ring < num_rings; ring++, point++)
|
for (ring = 0, point = 0; ring < num_rings; ring++, point++) {
|
||||||
{
|
|
||||||
int len;
|
int len;
|
||||||
int num_points = indices[ring] >> 1;
|
int num_points = indices[ring] >> 1;
|
||||||
|
|
||||||
@ -149,8 +135,7 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
// 'parallel' lines have a distance of at least
|
// 'parallel' lines have a distance of at least
|
||||||
// 1 unit. you'll notice when things went wrong
|
// 1 unit. you'll notice when things went wrong
|
||||||
// when the hole is rendered instead of the poly
|
// when the hole is rendered instead of the poly
|
||||||
if (ring > 0)
|
if (ring > 0) {
|
||||||
{
|
|
||||||
int k = point * 2;
|
int k = point * 2;
|
||||||
|
|
||||||
float nx = in.pointlist[k++];
|
float nx = in.pointlist[k++];
|
||||||
@ -159,8 +144,7 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
float cx, cy, vx, vy;
|
float cx, cy, vx, vy;
|
||||||
|
|
||||||
// try to find a large enough segment
|
// try to find a large enough segment
|
||||||
for (len = (point + num_points) * 2; k < len;)
|
for (len = (point + num_points) * 2; k < len;) {
|
||||||
{
|
|
||||||
cx = nx;
|
cx = nx;
|
||||||
cy = ny;
|
cy = ny;
|
||||||
|
|
||||||
@ -191,21 +175,16 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
*seg++ = last;
|
*seg++ = last;
|
||||||
*seg++ = point;
|
*seg++ = point;
|
||||||
|
|
||||||
for (len = point + num_points - 1; point < len; point++)
|
for (len = point + num_points - 1; point < len; point++) {
|
||||||
{
|
|
||||||
*seg++ = point;
|
*seg++ = point;
|
||||||
*seg++ = point + 1;
|
*seg++ = point + 1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (dups)
|
if (dups) {
|
||||||
{
|
for (int i = 0; i < dups; i++) {
|
||||||
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]);
|
||||||
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
|
// print poly format to check with triangle/showme
|
||||||
for (int j = 0; j < in.numberofpoints; j++)
|
for (int j = 0; j < in.numberofpoints; j++)
|
||||||
@ -215,23 +194,19 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
for (int j = 0; j < in.numberofsegments; j++, seg += 2)
|
for (int j = 0; j < in.numberofsegments; j++, seg += 2)
|
||||||
printf("%d %d %d\n", j, *seg, *(seg+1));
|
printf("%d %d %d\n", j, *seg, *(seg+1));
|
||||||
|
|
||||||
for (int j = 0; j < in.numberofholes; j++)
|
for (int j = 0; j < in.numberofholes; j++) {
|
||||||
{
|
|
||||||
printf("%d %f %f\n", j, in.holelist[j*2], in.holelist[j*2+1]);
|
printf("%d %f %f\n", j, in.holelist[j*2], in.holelist[j*2+1]);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (0)
|
if (0) {
|
||||||
{
|
|
||||||
free(in.segmentlist);
|
free(in.segmentlist);
|
||||||
free(in.holelist);
|
free(in.holelist);
|
||||||
free(rings);
|
free(rings);
|
||||||
free(skip_list);
|
free(skip_list);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
if (dups == 2)
|
if (dups == 2) {
|
||||||
{
|
if (skip_list[0] > skip_list[2]) {
|
||||||
if (skip_list[0] > skip_list[2])
|
|
||||||
{
|
|
||||||
int tmp = skip_list[0];
|
int tmp = skip_list[0];
|
||||||
skip_list[0] = skip_list[2];
|
skip_list[0] = skip_list[2];
|
||||||
skip_list[2] = tmp;
|
skip_list[2] = tmp;
|
||||||
@ -243,16 +218,14 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
printf("flip items\n");
|
printf("flip items\n");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else if (dups > 2)
|
else if (dups > 2) {
|
||||||
{
|
|
||||||
printf("sort dups\n");
|
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
|
// shift segment indices while removing duplicate points
|
||||||
for (int i = 0; i < dups; i++)
|
for (int i = 0; i < dups; i++) {
|
||||||
{
|
|
||||||
// position of the duplicate vertex
|
// position of the duplicate vertex
|
||||||
int pos = skip_list[i * 2] - i;
|
int pos = skip_list[i * 2] - i;
|
||||||
// first vertex
|
// first vertex
|
||||||
@ -260,10 +233,8 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
|
|
||||||
printf("add offset: %d, from pos %d\n", i, pos);
|
printf("add offset: %d, from pos %d\n", i, pos);
|
||||||
seg = in.segmentlist;
|
seg = in.segmentlist;
|
||||||
for (int j = 0; j < in.numberofsegments * 2; j++, seg++)
|
for (int j = 0; j < in.numberofsegments * 2; j++, seg++) {
|
||||||
{
|
if (*seg == pos) {
|
||||||
if (*seg == pos)
|
|
||||||
{
|
|
||||||
if (replacement >= pos)
|
if (replacement >= pos)
|
||||||
*seg = replacement - i;
|
*seg = replacement - i;
|
||||||
else
|
else
|
||||||
@ -273,12 +244,10 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
*seg -= 1;
|
*seg -= 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
printf(
|
printf( "move %d %d %d\n", pos, pos + 1, in.numberofpoints - pos - 1);
|
||||||
"move %d %d %d\n", pos, pos + 1, in.numberofpoints - pos - 1);
|
|
||||||
|
|
||||||
if (in.numberofpoints - pos > 1)
|
if (in.numberofpoints - pos > 1)
|
||||||
memmove(in.pointlist + (pos * 2),
|
memmove(in.pointlist + (pos * 2), in.pointlist + ((pos + 1) * 2),
|
||||||
in.pointlist + ((pos + 1) * 2),
|
|
||||||
(in.numberofpoints - pos - 1) * 2 * sizeof(float));
|
(in.numberofpoints - pos - 1) * 2 * sizeof(float));
|
||||||
|
|
||||||
in.numberofpoints--;
|
in.numberofpoints--;
|
||||||
@ -308,26 +277,36 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
// N - no node output
|
// N - no node output
|
||||||
// B - no bound output
|
// B - no bound output
|
||||||
// Q - be quiet!
|
// Q - be quiet!
|
||||||
triangulate("pzPNBQ", &in, &out, (TriangleIO *) NULL);
|
|
||||||
|
|
||||||
if (in.numberofpoints < out.numberofpoints)
|
TriangleOptions opt;
|
||||||
{
|
memset(&opt, 0, sizeof(TriangleOptions));
|
||||||
printf( "polygon input is bad! points in:%d out%d\n",
|
|
||||||
in.numberofpoints,
|
|
||||||
out.numberofpoints);
|
|
||||||
|
|
||||||
for (int j = 0; j < in.numberofpoints; j++)
|
opt.dwyer = 1;
|
||||||
{
|
opt.steiner = -1;
|
||||||
|
opt.order = 1;
|
||||||
|
opt.maxarea = -1.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]);
|
printf("%d %f %f\n", j, in.pointlist[j*2], in.pointlist[j*2+1]);
|
||||||
}
|
}
|
||||||
|
|
||||||
seg = in.segmentlist;
|
seg = in.segmentlist;
|
||||||
for (int j = 0; j < in.numberofsegments; j++, seg += 2)
|
for (int j = 0; j < in.numberofsegments; j++, seg += 2) {
|
||||||
{
|
|
||||||
printf("%d %d %d\n", j, *seg, *(seg+1));
|
printf("%d %d %d\n", j, *seg, *(seg+1));
|
||||||
}
|
}
|
||||||
(*env)->ReleasePrimitiveArrayCritical(env, obj_points, orig_points,
|
(*env)->ReleasePrimitiveArrayCritical(env, obj_points, orig_points, JNI_ABORT);
|
||||||
JNI_ABORT);
|
|
||||||
free(in.segmentlist);
|
free(in.segmentlist);
|
||||||
free(in.holelist);
|
free(in.holelist);
|
||||||
free(rings);
|
free(rings);
|
||||||
@ -348,8 +327,7 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
INDICE *tri;
|
INDICE *tri;
|
||||||
|
|
||||||
/* shift back indices from removed duplicates */
|
/* shift back indices from removed duplicates */
|
||||||
for (int i = 0; i < dups; i++)
|
for (int i = 0; i < dups; i++) {
|
||||||
{
|
|
||||||
int pos = skip_list[i * 2] + i;
|
int pos = skip_list[i * 2] + i;
|
||||||
|
|
||||||
tri = out.trianglelist;
|
tri = out.trianglelist;
|
||||||
@ -376,8 +354,7 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
// additional vertices will be added. so the following rings
|
// additional vertices will be added. so the following rings
|
||||||
// needs extra offset...
|
// needs extra offset...
|
||||||
int start = offset;
|
int start = offset;
|
||||||
for (int j = 0, m = in.numberofholes; j < m; j++)
|
for (int j = 0, m = in.numberofholes; j < m; j++) {
|
||||||
{
|
|
||||||
start += rings[j] * stride;
|
start += rings[j] * stride;
|
||||||
// even number of points?
|
// even number of points?
|
||||||
if (!(rings[j] & 1))
|
if (!(rings[j] & 1))
|
||||||
@ -393,8 +370,7 @@ jint Java_org_oscim_renderer_layer_ExtrusionLayer_triangulate(JNIEnv *env,
|
|||||||
start += stride;
|
start += stride;
|
||||||
}
|
}
|
||||||
|
|
||||||
(*env)->ReleasePrimitiveArrayCritical(env, obj_points, orig_points,
|
(*env)->ReleasePrimitiveArrayCritical(env, obj_points, orig_points, JNI_ABORT);
|
||||||
JNI_ABORT);
|
|
||||||
|
|
||||||
free(in.segmentlist);
|
free(in.segmentlist);
|
||||||
free(in.holelist);
|
free(in.holelist);
|
||||||
|
|||||||
File diff suppressed because it is too large
Load Diff
@ -248,7 +248,6 @@
|
|||||||
/* */
|
/* */
|
||||||
/*****************************************************************************/
|
/*****************************************************************************/
|
||||||
|
|
||||||
|
|
||||||
#define SINGLE
|
#define SINGLE
|
||||||
|
|
||||||
#ifdef SINGLE
|
#ifdef SINGLE
|
||||||
@ -259,6 +258,8 @@
|
|||||||
|
|
||||||
#define INDICE unsigned short
|
#define INDICE unsigned short
|
||||||
|
|
||||||
|
typedef struct triangulateio TriangleIO;
|
||||||
|
|
||||||
struct triangulateio {
|
struct triangulateio {
|
||||||
REAL *pointlist; /* In / out */
|
REAL *pointlist; /* In / out */
|
||||||
REAL *pointattributelist; /* In / out */
|
REAL *pointattributelist; /* In / out */
|
||||||
@ -290,11 +291,70 @@ struct triangulateio {
|
|||||||
int numberofedges; /* Out only */
|
int numberofedges; /* Out only */
|
||||||
};
|
};
|
||||||
|
|
||||||
#ifdef ANSI_DECLARATORS
|
/* Data structure for command line switches and file names. This structure
|
||||||
void triangulate(char *, struct triangulateio *, struct triangulateio *,
|
/* 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 *);
|
struct triangulateio *);
|
||||||
void trifree(VOID *memptr);
|
|
||||||
#else /* not ANSI_DECLARATORS */
|
|
||||||
void triangulate();
|
|
||||||
void trifree();
|
|
||||||
#endif /* not ANSI_DECLARATORS */
|
|
||||||
|
|||||||
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