main()
{ double pts[200000][2], radius, center[2];
long i, j; double x,y;
printf("Preparing test1\n");
i=0;
for( j= 0; j < 100000; j++)
{ x = 10.0 - ((double) j/ 100000.0 );
y = 0.0;
pts[i][0] = x; pts[i][1] = y; i++;
}
for( j= 0; j < 50000; j++)
{ y = 10.0 - ((double) j/ 50000.0 );
x = 0.0;
pts[i][0] = x; pts[i][1] = y; i++;
}
for( j= 0; j < 50000; j++)
{ x = 5.0 + 2.0*sin( (j/50000.0)*360.0) ;
y = 5.0 + 2.0*cos( (j/50000.0)*360.0) ;
pts[i][0] = x; pts[i][1] = y; i++;
}
printf("Running test1: %d pts\n", i);
circumcircle( i, &(pts[0][0]), &radius, &(center[0]) );
printf("Found center (%f,%f), radius %f; should be (%f,%f), %f\n",
center[0], center[1], radius, 5.0, 5.0, 5.0*sqrt(2) );
printf("Preparing test2\n");
i=0; j= 0;
while (i < 199998 )
{ x = ((j*j) % 300001) /200000.0;
y = (j+i)% 300007 / 200000.0;
if( (x-0.6)*(x-0.6) + (y-0.7)*(y-0.7) <= 0.25 )
{ pts[i][0] = x; pts[i][1] = y; i++;
}
j++;
}
pts[199998][0]=0.1; pts[199998][1] = 0.7;
pts[199999][0]=1.1; pts[199999][1] = 0.7;
i+=2;
printf("Running test2: %d pts\n", i);
circumcircle( i, &(pts[0][0]), &radius, &(center[0]) );
printf("Found center (%f,%f), radius %f; should be (%f,%f), %f\n",
center[0], center[1], radius, 0.6, 0.7, 0.5 );
}
double Line::sqr_dist_to(Point p) const
{
// If Point inside circumcircle, it's closer to edge than start/end point
Circle cir = circumcircle(*this);
if (overlaps(p, cir))
{
if (x2 - x1 != 0) // only valid for a non-infinite slope
{
// Derived from perpendicular distance formula
double m = slope();
return sqr(m*(x1 -p.x) +p.y -y1) / (sqr(m) +1);
}
else //vertical line edge case (infinite slope)
{
return sqr(p.x - x1);
}
}
else // if outside circumcircle, it's closer to start/end point
{
int start_dist = p.sqr_dist_to(start()),
end_dist = p.sqr_dist_to(end());
return min(start_dist, end_dist);
}
}
/*
Triangulation subroutine
Takes as input NV vertices in array pxyz
Returned is a list of ntri triangular faces in the array v
These triangles are arranged in a consistent clockwise order.
The triangle array 'v' should be malloced to 3 * nv
The vertex array pxyz must be big enough to hold 3 more points
The vertex array must be sorted in increasing x values say
qsort(p,nv,sizeof(XYZ),XYZCompare);
*/
int
delaunay (int nv,XYZ *pxyz,ITRIANGLE *v,int *ntri)
{
int *complete = NULL;
IEDGE *edges = NULL;
int nedge = 0;
int trimax,emax = 200;
int status = 0;
int inside;
int i,j,k;
double xp,yp,x1,y1,x2,y2,x3,y3,xc=0,yc=0,r=0;
double xmin,xmax,ymin,ymax,xmid,ymid;
double dx,dy,dmax;
/* Allocate memory for the completeness list, flag for each triangle */
trimax = 4 * nv;
if ((complete = malloc(trimax*sizeof(int))) == NULL) {
status = 1;
goto skip;
}
/* Allocate memory for the edge list */
if ((edges = malloc(emax*(long)sizeof(IEDGE))) == NULL) {
status = 2;
goto skip;
}
/*
Find the maximum and minimum vertex bounds.
This is to allow calculation of the bounding triangle
*/
xmin = pxyz[0].x;
ymin = pxyz[0].y;
xmax = xmin;
ymax = ymin;
for (i=1;i<nv;i++) {
if (pxyz[i].x < xmin) xmin = pxyz[i].x;
if (pxyz[i].x > xmax) xmax = pxyz[i].x;
if (pxyz[i].y < ymin) ymin = pxyz[i].y;
if (pxyz[i].y > ymax) ymax = pxyz[i].y;
}
dx = xmax - xmin;
dy = ymax - ymin;
dmax = (dx > dy) ? dx : dy;
xmid = (xmax + xmin) / 2.0;
ymid = (ymax + ymin) / 2.0;
/*
Set up the supertriangle
This is a triangle which encompasses all the sample points.
The supertriangle coordinates are added to the end of the
vertex list. The supertriangle is the first triangle in
the triangle list.
*/
pxyz[nv+0].x = xmid - 20 * dmax;
pxyz[nv+0].y = ymid - dmax;
pxyz[nv+0].z = 0.0;
pxyz[nv+1].x = xmid;
pxyz[nv+1].y = ymid + 20 * dmax;
pxyz[nv+1].z = 0.0;
pxyz[nv+2].x = xmid + 20 * dmax;
pxyz[nv+2].y = ymid - dmax;
pxyz[nv+2].z = 0.0;
v[0].p1 = nv;
v[0].p2 = nv+1;
v[0].p3 = nv+2;
complete[0] = FALSE;
*ntri = 1;
/*
Include each point one at a time into the existing mesh
*/
for (i=0;i<nv;i++) {
xp = pxyz[i].x;
yp = pxyz[i].y;
nedge = 0;
/*
Set up the edge buffer.
If the point (xp,yp) lies inside the circumcircle then the
three edges of that triangle are added to the edge buffer
and that triangle is removed.
*/
for (j=0;j<(*ntri);j++) {
if (complete[j])
continue;
x1 = pxyz[v[j].p1].x;
y1 = pxyz[v[j].p1].y;
x2 = pxyz[v[j].p2].x;
y2 = pxyz[v[j].p2].y;
x3 = pxyz[v[j].p3].x;
y3 = pxyz[v[j].p3].y;
inside = circumcircle(xp,yp,x1,y1,x2,y2,x3,y3,&xc,&yc,&r);
if (xc < xp && ((xp-xc)*(xp-xc)) > r)
complete[j] = TRUE;
if (inside) {
/* Check that we haven't exceeded the edge list size */
if (nedge+3 >= emax) {
emax += 100;
if ((edges = realloc(edges,emax*(long)sizeof(IEDGE))) == NULL) {
status = 3;
goto skip;
}
}
edges[nedge+0].p1 = v[j].p1;
edges[nedge+0].p2 = v[j].p2;
edges[nedge+1].p1 = v[j].p2;
edges[nedge+1].p2 = v[j].p3;
edges[nedge+2].p1 = v[j].p3;
edges[nedge+2].p2 = v[j].p1;
nedge += 3;
v[j] = v[(*ntri)-1];
complete[j] = complete[(*ntri)-1];
(*ntri)--;
j--;
}
}
/*
Tag multiple edges
Note: if all triangles are specified anticlockwise then all
interior edges are opposite pointing in direction.
*/
for (j=0;j<nedge-1;j++) {
for (k=j+1;k<nedge;k++) {
if ((edges[j].p1 == edges[k].p2) && (edges[j].p2 == edges[k].p1)) {
edges[j].p1 = -1;
edges[j].p2 = -1;
edges[k].p1 = -1;
edges[k].p2 = -1;
}
/* Shouldn't need the following, see note above */
if ((edges[j].p1 == edges[k].p1) && (edges[j].p2 == edges[k].p2)) {
edges[j].p1 = -1;
edges[j].p2 = -1;
edges[k].p1 = -1;
edges[k].p2 = -1;
}
}
}
/*
Form new triangles for the current point
Skipping over any tagged edges.
All edges are arranged in clockwise order.
*/
for (j=0;j<nedge;j++) {
if (edges[j].p1 < 0 || edges[j].p2 < 0)
continue;
if ((*ntri) >= trimax) {
status = 4;
goto skip;
}
v[*ntri].p1 = edges[j].p1;
v[*ntri].p2 = edges[j].p2;
v[*ntri].p3 = i;
complete[*ntri] = FALSE;
(*ntri)++;
}
}
/*
Remove triangles with supertriangle vertices
These are triangles which have a vertex number greater than nv
*/
for (i=0;i<(*ntri);i++) {
if (v[i].p1 >= nv || v[i].p2 >= nv || v[i].p3 >= nv) {
v[i] = v[(*ntri)-1];
(*ntri)--;
i--;
}
}
skip:
free(edges);
free(complete);
return(status);
}
