зеркало из https://github.com/mozilla/pjs.git
1539 строки
39 KiB
C
1539 строки
39 KiB
C
/* Libart_LGPL - library of basic graphic primitives
|
|
* Copyright (C) 1998-2000 Raph Levien
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
/* Primitive intersection and winding number operations on sorted
|
|
vector paths.
|
|
|
|
These routines are internal to libart, used to construct operations
|
|
like intersection, union, and difference. */
|
|
|
|
|
|
#include <stdio.h> /* for printf of debugging info */
|
|
#include <string.h> /* for memcpy */
|
|
#include <math.h>
|
|
#include "art_misc.h"
|
|
|
|
#include "art_rect.h"
|
|
#include "art_svp.h"
|
|
#include "art_svp_wind.h"
|
|
|
|
#define noVERBOSE
|
|
|
|
#define PT_EQ(p1,p2) ((p1).x == (p2).x && (p1).y == (p2).y)
|
|
|
|
#define PT_CLOSE(p1,p2) (fabs ((p1).x - (p2).x) < 1e-6 && fabs ((p1).y - (p2).y) < 1e-6)
|
|
|
|
/* return nonzero and set *p to the intersection point if the lines
|
|
z0-z1 and z2-z3 intersect each other. */
|
|
static int
|
|
intersect_lines (ArtPoint z0, ArtPoint z1, ArtPoint z2, ArtPoint z3,
|
|
ArtPoint *p)
|
|
{
|
|
double a01, b01, c01;
|
|
double a23, b23, c23;
|
|
double d0, d1, d2, d3;
|
|
double det;
|
|
|
|
/* if the vectors share an endpoint, they don't intersect */
|
|
if (PT_EQ (z0, z2) || PT_EQ (z0, z3) || PT_EQ (z1, z2) || PT_EQ (z1, z3))
|
|
return 0;
|
|
|
|
#if 0
|
|
if (PT_CLOSE (z0, z2) || PT_CLOSE (z0, z3) || PT_CLOSE (z1, z2) || PT_CLOSE (z1, z3))
|
|
return 0;
|
|
#endif
|
|
|
|
/* find line equations ax + by + c = 0 */
|
|
a01 = z0.y - z1.y;
|
|
b01 = z1.x - z0.x;
|
|
c01 = -(z0.x * a01 + z0.y * b01);
|
|
/* = -((z0.y - z1.y) * z0.x + (z1.x - z0.x) * z0.y)
|
|
= (z1.x * z0.y - z1.y * z0.x) */
|
|
|
|
d2 = a01 * z2.x + b01 * z2.y + c01;
|
|
d3 = a01 * z3.x + b01 * z3.y + c01;
|
|
if ((d2 > 0) == (d3 > 0))
|
|
return 0;
|
|
|
|
a23 = z2.y - z3.y;
|
|
b23 = z3.x - z2.x;
|
|
c23 = -(z2.x * a23 + z2.y * b23);
|
|
|
|
d0 = a23 * z0.x + b23 * z0.y + c23;
|
|
d1 = a23 * z1.x + b23 * z1.y + c23;
|
|
if ((d0 > 0) == (d1 > 0))
|
|
return 0;
|
|
|
|
/* now we definitely know that the lines intersect */
|
|
/* solve the two linear equations ax + by + c = 0 */
|
|
det = 1.0 / (a01 * b23 - a23 * b01);
|
|
p->x = det * (c23 * b01 - c01 * b23);
|
|
p->y = det * (c01 * a23 - c23 * a01);
|
|
|
|
return 1;
|
|
}
|
|
|
|
#define EPSILON 1e-6
|
|
|
|
static double
|
|
trap_epsilon (double v)
|
|
{
|
|
const double epsilon = EPSILON;
|
|
|
|
if (v < epsilon && v > -epsilon) return 0;
|
|
else return v;
|
|
}
|
|
|
|
/* Determine the order of line segments z0-z1 and z2-z3.
|
|
Return +1 if z2-z3 lies entirely to the right of z0-z1,
|
|
-1 if entirely to the left,
|
|
or 0 if overlap.
|
|
|
|
The case analysis in this function is quite ugly. The fact that it's
|
|
almost 200 lines long is ridiculous.
|
|
|
|
Ok, so here's the plan to cut it down:
|
|
|
|
First, do a bounding line comparison on the x coordinates. This is pretty
|
|
much the common case, and should go quickly. It also takes care of the
|
|
case where both lines are horizontal.
|
|
|
|
Then, do d0 and d1 computation, but only if a23 is nonzero.
|
|
|
|
Finally, do d2 and d3 computation, but only if a01 is nonzero.
|
|
|
|
Fall through to returning 0 (this will happen when both lines are
|
|
horizontal and they overlap).
|
|
*/
|
|
static int
|
|
x_order (ArtPoint z0, ArtPoint z1, ArtPoint z2, ArtPoint z3)
|
|
{
|
|
double a01, b01, c01;
|
|
double a23, b23, c23;
|
|
double d0, d1, d2, d3;
|
|
|
|
if (z0.y == z1.y)
|
|
{
|
|
if (z2.y == z3.y)
|
|
{
|
|
double x01min, x01max;
|
|
double x23min, x23max;
|
|
|
|
if (z0.x > z1.x)
|
|
{
|
|
x01min = z1.x;
|
|
x01max = z0.x;
|
|
}
|
|
else
|
|
{
|
|
x01min = z0.x;
|
|
x01max = z1.x;
|
|
}
|
|
|
|
if (z2.x > z3.x)
|
|
{
|
|
x23min = z3.x;
|
|
x23max = z2.x;
|
|
}
|
|
else
|
|
{
|
|
x23min = z2.x;
|
|
x23max = z3.x;
|
|
}
|
|
|
|
if (x23min >= x01max) return 1;
|
|
else if (x01min >= x23max) return -1;
|
|
else return 0;
|
|
}
|
|
else
|
|
{
|
|
/* z0-z1 is horizontal, z2-z3 isn't */
|
|
a23 = z2.y - z3.y;
|
|
b23 = z3.x - z2.x;
|
|
c23 = -(z2.x * a23 + z2.y * b23);
|
|
|
|
if (z3.y < z2.y)
|
|
{
|
|
a23 = -a23;
|
|
b23 = -b23;
|
|
c23 = -c23;
|
|
}
|
|
|
|
d0 = trap_epsilon (a23 * z0.x + b23 * z0.y + c23);
|
|
d1 = trap_epsilon (a23 * z1.x + b23 * z1.y + c23);
|
|
|
|
if (d0 > 0)
|
|
{
|
|
if (d1 >= 0) return 1;
|
|
else return 0;
|
|
}
|
|
else if (d0 == 0)
|
|
{
|
|
if (d1 > 0) return 1;
|
|
else if (d1 < 0) return -1;
|
|
else printf ("case 1 degenerate\n");
|
|
return 0;
|
|
}
|
|
else /* d0 < 0 */
|
|
{
|
|
if (d1 <= 0) return -1;
|
|
else return 0;
|
|
}
|
|
}
|
|
}
|
|
else if (z2.y == z3.y)
|
|
{
|
|
/* z2-z3 is horizontal, z0-z1 isn't */
|
|
a01 = z0.y - z1.y;
|
|
b01 = z1.x - z0.x;
|
|
c01 = -(z0.x * a01 + z0.y * b01);
|
|
/* = -((z0.y - z1.y) * z0.x + (z1.x - z0.x) * z0.y)
|
|
= (z1.x * z0.y - z1.y * z0.x) */
|
|
|
|
if (z1.y < z0.y)
|
|
{
|
|
a01 = -a01;
|
|
b01 = -b01;
|
|
c01 = -c01;
|
|
}
|
|
|
|
d2 = trap_epsilon (a01 * z2.x + b01 * z2.y + c01);
|
|
d3 = trap_epsilon (a01 * z3.x + b01 * z3.y + c01);
|
|
|
|
if (d2 > 0)
|
|
{
|
|
if (d3 >= 0) return -1;
|
|
else return 0;
|
|
}
|
|
else if (d2 == 0)
|
|
{
|
|
if (d3 > 0) return -1;
|
|
else if (d3 < 0) return 1;
|
|
else printf ("case 2 degenerate\n");
|
|
return 0;
|
|
}
|
|
else /* d2 < 0 */
|
|
{
|
|
if (d3 <= 0) return 1;
|
|
else return 0;
|
|
}
|
|
}
|
|
|
|
/* find line equations ax + by + c = 0 */
|
|
a01 = z0.y - z1.y;
|
|
b01 = z1.x - z0.x;
|
|
c01 = -(z0.x * a01 + z0.y * b01);
|
|
/* = -((z0.y - z1.y) * z0.x + (z1.x - z0.x) * z0.y)
|
|
= -(z1.x * z0.y - z1.y * z0.x) */
|
|
|
|
if (a01 > 0)
|
|
{
|
|
a01 = -a01;
|
|
b01 = -b01;
|
|
c01 = -c01;
|
|
}
|
|
/* so now, (a01, b01) points to the left, thus a01 * x + b01 * y + c01
|
|
is negative if the point lies to the right of the line */
|
|
|
|
d2 = trap_epsilon (a01 * z2.x + b01 * z2.y + c01);
|
|
d3 = trap_epsilon (a01 * z3.x + b01 * z3.y + c01);
|
|
if (d2 > 0)
|
|
{
|
|
if (d3 >= 0) return -1;
|
|
}
|
|
else if (d2 == 0)
|
|
{
|
|
if (d3 > 0) return -1;
|
|
else if (d3 < 0) return 1;
|
|
else
|
|
fprintf (stderr, "colinear!\n");
|
|
}
|
|
else /* d2 < 0 */
|
|
{
|
|
if (d3 <= 0) return 1;
|
|
}
|
|
|
|
a23 = z2.y - z3.y;
|
|
b23 = z3.x - z2.x;
|
|
c23 = -(z2.x * a23 + z2.y * b23);
|
|
|
|
if (a23 > 0)
|
|
{
|
|
a23 = -a23;
|
|
b23 = -b23;
|
|
c23 = -c23;
|
|
}
|
|
d0 = trap_epsilon (a23 * z0.x + b23 * z0.y + c23);
|
|
d1 = trap_epsilon (a23 * z1.x + b23 * z1.y + c23);
|
|
if (d0 > 0)
|
|
{
|
|
if (d1 >= 0) return 1;
|
|
}
|
|
else if (d0 == 0)
|
|
{
|
|
if (d1 > 0) return 1;
|
|
else if (d1 < 0) return -1;
|
|
else
|
|
fprintf (stderr, "colinear!\n");
|
|
}
|
|
else /* d0 < 0 */
|
|
{
|
|
if (d1 <= 0) return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* similar to x_order, but to determine whether point z0 + epsilon lies to
|
|
the left of the line z2-z3 or to the right */
|
|
static int
|
|
x_order_2 (ArtPoint z0, ArtPoint z1, ArtPoint z2, ArtPoint z3)
|
|
{
|
|
double a23, b23, c23;
|
|
double d0, d1;
|
|
|
|
a23 = z2.y - z3.y;
|
|
b23 = z3.x - z2.x;
|
|
c23 = -(z2.x * a23 + z2.y * b23);
|
|
|
|
if (a23 > 0)
|
|
{
|
|
a23 = -a23;
|
|
b23 = -b23;
|
|
c23 = -c23;
|
|
}
|
|
|
|
d0 = a23 * z0.x + b23 * z0.y + c23;
|
|
|
|
if (d0 > EPSILON)
|
|
return -1;
|
|
else if (d0 < -EPSILON)
|
|
return 1;
|
|
|
|
d1 = a23 * z1.x + b23 * z1.y + c23;
|
|
if (d1 > EPSILON)
|
|
return -1;
|
|
else if (d1 < -EPSILON)
|
|
return 1;
|
|
|
|
if (z0.x <= z2.x && z1.x <= z2.x && z0.x <= z3.x && z1.x <= z3.x)
|
|
return -1;
|
|
if (z0.x >= z2.x && z1.x >= z2.x && z0.x >= z3.x && z1.x >= z3.x)
|
|
return 1;
|
|
|
|
fprintf (stderr, "x_order_2: colinear!\n");
|
|
return 0;
|
|
}
|
|
|
|
#ifdef DEAD_CODE
|
|
/* Traverse the vector path, keeping it in x-sorted order.
|
|
|
|
This routine doesn't actually do anything - it's just here for
|
|
explanatory purposes. */
|
|
void
|
|
traverse (ArtSVP *vp)
|
|
{
|
|
int *active_segs;
|
|
int n_active_segs;
|
|
int *cursor;
|
|
int seg_idx;
|
|
double y;
|
|
int tmp1, tmp2;
|
|
int asi;
|
|
int i, j;
|
|
|
|
active_segs = art_new (int, vp->n_segs);
|
|
cursor = art_new (int, vp->n_segs);
|
|
|
|
n_active_segs = 0;
|
|
seg_idx = 0;
|
|
y = vp->segs[0].points[0].y;
|
|
while (seg_idx < vp->n_segs || n_active_segs > 0)
|
|
{
|
|
printf ("y = %g\n", y);
|
|
/* delete segments ending at y from active list */
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
if (vp->segs[asi].n_points - 1 == cursor[asi] &&
|
|
vp->segs[asi].points[cursor[asi]].y == y)
|
|
{
|
|
printf ("deleting %d\n", asi);
|
|
n_active_segs--;
|
|
for (j = i; j < n_active_segs; j++)
|
|
active_segs[j] = active_segs[j + 1];
|
|
i--;
|
|
}
|
|
}
|
|
|
|
/* insert new segments into the active list */
|
|
while (seg_idx < vp->n_segs && y == vp->segs[seg_idx].points[0].y)
|
|
{
|
|
cursor[seg_idx] = 0;
|
|
printf ("inserting %d\n", seg_idx);
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
if (x_order (vp->segs[asi].points[cursor[asi]],
|
|
vp->segs[asi].points[cursor[asi] + 1],
|
|
vp->segs[seg_idx].points[0],
|
|
vp->segs[seg_idx].points[1]) == -1)
|
|
break;
|
|
}
|
|
tmp1 = seg_idx;
|
|
for (j = i; j < n_active_segs; j++)
|
|
{
|
|
tmp2 = active_segs[j];
|
|
active_segs[j] = tmp1;
|
|
tmp1 = tmp2;
|
|
}
|
|
active_segs[n_active_segs] = tmp1;
|
|
n_active_segs++;
|
|
seg_idx++;
|
|
}
|
|
|
|
/* all active segs cross the y scanline (considering segs to be
|
|
closed on top and open on bottom) */
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
printf ("%d (%g, %g) - (%g, %g) %s\n", asi,
|
|
vp->segs[asi].points[cursor[asi]].x,
|
|
vp->segs[asi].points[cursor[asi]].y,
|
|
vp->segs[asi].points[cursor[asi] + 1].x,
|
|
vp->segs[asi].points[cursor[asi] + 1].y,
|
|
vp->segs[asi].dir ? "v" : "^");
|
|
}
|
|
|
|
/* advance y to the next event */
|
|
if (n_active_segs == 0)
|
|
{
|
|
if (seg_idx < vp->n_segs)
|
|
y = vp->segs[seg_idx].points[0].y;
|
|
/* else we're done */
|
|
}
|
|
else
|
|
{
|
|
asi = active_segs[0];
|
|
y = vp->segs[asi].points[cursor[asi] + 1].y;
|
|
for (i = 1; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
if (y > vp->segs[asi].points[cursor[asi] + 1].y)
|
|
y = vp->segs[asi].points[cursor[asi] + 1].y;
|
|
}
|
|
if (seg_idx < vp->n_segs && y > vp->segs[seg_idx].points[0].y)
|
|
y = vp->segs[seg_idx].points[0].y;
|
|
}
|
|
|
|
/* advance cursors to reach new y */
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
while (cursor[asi] < vp->segs[asi].n_points - 1 &&
|
|
y >= vp->segs[asi].points[cursor[asi] + 1].y)
|
|
cursor[asi]++;
|
|
}
|
|
printf ("\n");
|
|
}
|
|
art_free (cursor);
|
|
art_free (active_segs);
|
|
}
|
|
#endif
|
|
|
|
/* I believe that the loop will always break with i=1.
|
|
|
|
I think I'll want to change this from a simple sorted list to a
|
|
modified stack. ips[*][0] will get its own data structure, and
|
|
ips[*] will in general only be allocated if there is an intersection.
|
|
Finally, the segment can be traced through the initial point
|
|
(formerly ips[*][0]), backwards through the stack, and finally
|
|
to cursor + 1.
|
|
|
|
This change should cut down on allocation bandwidth, and also
|
|
eliminate the iteration through n_ipl below.
|
|
|
|
*/
|
|
static void
|
|
insert_ip (int seg_i, int *n_ips, int *n_ips_max, ArtPoint **ips, ArtPoint ip)
|
|
{
|
|
int i;
|
|
ArtPoint tmp1, tmp2;
|
|
int n_ipl;
|
|
ArtPoint *ipl;
|
|
|
|
n_ipl = n_ips[seg_i]++;
|
|
if (n_ipl == n_ips_max[seg_i])
|
|
art_expand (ips[seg_i], ArtPoint, n_ips_max[seg_i]);
|
|
ipl = ips[seg_i];
|
|
for (i = 1; i < n_ipl; i++)
|
|
if (ipl[i].y > ip.y)
|
|
break;
|
|
tmp1 = ip;
|
|
for (; i <= n_ipl; i++)
|
|
{
|
|
tmp2 = ipl[i];
|
|
ipl[i] = tmp1;
|
|
tmp1 = tmp2;
|
|
}
|
|
}
|
|
|
|
/* test active segment (i - 1) against i for intersection, if
|
|
so, add intersection point to both ips lists. */
|
|
static void
|
|
intersect_neighbors (int i, int *active_segs,
|
|
int *n_ips, int *n_ips_max, ArtPoint **ips,
|
|
int *cursor, ArtSVP *vp)
|
|
{
|
|
ArtPoint z0, z1, z2, z3;
|
|
int asi01, asi23;
|
|
ArtPoint ip;
|
|
|
|
asi01 = active_segs[i - 1];
|
|
|
|
z0 = ips[asi01][0];
|
|
if (n_ips[asi01] == 1)
|
|
z1 = vp->segs[asi01].points[cursor[asi01] + 1];
|
|
else
|
|
z1 = ips[asi01][1];
|
|
|
|
asi23 = active_segs[i];
|
|
|
|
z2 = ips[asi23][0];
|
|
if (n_ips[asi23] == 1)
|
|
z3 = vp->segs[asi23].points[cursor[asi23] + 1];
|
|
else
|
|
z3 = ips[asi23][1];
|
|
|
|
if (intersect_lines (z0, z1, z2, z3, &ip))
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("new intersection point: (%g, %g)\n", ip.x, ip.y);
|
|
#endif
|
|
insert_ip (asi01, n_ips, n_ips_max, ips, ip);
|
|
insert_ip (asi23, n_ips, n_ips_max, ips, ip);
|
|
}
|
|
}
|
|
|
|
/* Add a new point to a segment in the svp.
|
|
|
|
Here, we also check to make sure that the segments satisfy nocross.
|
|
However, this is only valuable for debugging, and could possibly be
|
|
removed.
|
|
*/
|
|
static void
|
|
svp_add_point (ArtSVP *svp, int *n_points_max,
|
|
ArtPoint p, int *seg_map, int *active_segs, int n_active_segs,
|
|
int i)
|
|
{
|
|
int asi, asi_left, asi_right;
|
|
int n_points, n_points_left, n_points_right;
|
|
ArtSVPSeg *seg;
|
|
|
|
asi = seg_map[active_segs[i]];
|
|
seg = &svp->segs[asi];
|
|
n_points = seg->n_points;
|
|
/* find out whether neighboring segments share a point */
|
|
if (i > 0)
|
|
{
|
|
asi_left = seg_map[active_segs[i - 1]];
|
|
n_points_left = svp->segs[asi_left].n_points;
|
|
if (n_points_left > 1 &&
|
|
PT_EQ (svp->segs[asi_left].points[n_points_left - 2],
|
|
svp->segs[asi].points[n_points - 1]))
|
|
{
|
|
/* ok, new vector shares a top point with segment to the left -
|
|
now, check that it satisfies ordering invariant */
|
|
if (x_order (svp->segs[asi_left].points[n_points_left - 2],
|
|
svp->segs[asi_left].points[n_points_left - 1],
|
|
svp->segs[asi].points[n_points - 1],
|
|
p) < 1)
|
|
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("svp_add_point: cross on left!\n");
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
if (i + 1 < n_active_segs)
|
|
{
|
|
asi_right = seg_map[active_segs[i + 1]];
|
|
n_points_right = svp->segs[asi_right].n_points;
|
|
if (n_points_right > 1 &&
|
|
PT_EQ (svp->segs[asi_right].points[n_points_right - 2],
|
|
svp->segs[asi].points[n_points - 1]))
|
|
{
|
|
/* ok, new vector shares a top point with segment to the right -
|
|
now, check that it satisfies ordering invariant */
|
|
if (x_order (svp->segs[asi_right].points[n_points_right - 2],
|
|
svp->segs[asi_right].points[n_points_right - 1],
|
|
svp->segs[asi].points[n_points - 1],
|
|
p) > -1)
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("svp_add_point: cross on right!\n");
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
if (n_points_max[asi] == n_points)
|
|
art_expand (seg->points, ArtPoint, n_points_max[asi]);
|
|
seg->points[n_points] = p;
|
|
if (p.x < seg->bbox.x0)
|
|
seg->bbox.x0 = p.x;
|
|
else if (p.x > seg->bbox.x1)
|
|
seg->bbox.x1 = p.x;
|
|
seg->bbox.y1 = p.y;
|
|
seg->n_points++;
|
|
}
|
|
|
|
#if 0
|
|
/* find where the segment (currently at i) is supposed to go, and return
|
|
the target index - if equal to i, then there is no crossing problem.
|
|
|
|
"Where it is supposed to go" is defined as following:
|
|
|
|
Delete element i, re-insert at position target (bumping everything
|
|
target and greater to the right).
|
|
*/
|
|
static int
|
|
find_crossing (int i, int *active_segs, int n_active_segs,
|
|
int *cursor, ArtPoint **ips, int *n_ips, ArtSVP *vp)
|
|
{
|
|
int asi, asi_left, asi_right;
|
|
ArtPoint p0, p1;
|
|
ArtPoint p0l, p1l;
|
|
ArtPoint p0r, p1r;
|
|
int target;
|
|
|
|
asi = active_segs[i];
|
|
p0 = ips[asi][0];
|
|
if (n_ips[asi] == 1)
|
|
p1 = vp->segs[asi].points[cursor[asi] + 1];
|
|
else
|
|
p1 = ips[asi][1];
|
|
|
|
for (target = i; target > 0; target--)
|
|
{
|
|
asi_left = active_segs[target - 1];
|
|
p0l = ips[asi_left][0];
|
|
if (n_ips[asi_left] == 1)
|
|
p1l = vp->segs[asi_left].points[cursor[asi_left] + 1];
|
|
else
|
|
p1l = ips[asi_left][1];
|
|
if (!PT_EQ (p0, p0l))
|
|
break;
|
|
|
|
#ifdef VERBOSE
|
|
printf ("point matches on left (%g, %g) - (%g, %g) x (%g, %g) - (%g, %g)!\n",
|
|
p0l.x, p0l.y, p1l.x, p1l.y, p0.x, p0.y, p1.x, p1.y);
|
|
#endif
|
|
if (x_order (p0l, p1l, p0, p1) == 1)
|
|
break;
|
|
|
|
#ifdef VERBOSE
|
|
printf ("scanning to the left (i=%d, target=%d)\n", i, target);
|
|
#endif
|
|
}
|
|
|
|
if (target < i) return target;
|
|
|
|
for (; target < n_active_segs - 1; target++)
|
|
{
|
|
asi_right = active_segs[target + 1];
|
|
p0r = ips[asi_right][0];
|
|
if (n_ips[asi_right] == 1)
|
|
p1r = vp->segs[asi_right].points[cursor[asi_right] + 1];
|
|
else
|
|
p1r = ips[asi_right][1];
|
|
if (!PT_EQ (p0, p0r))
|
|
break;
|
|
|
|
#ifdef VERBOSE
|
|
printf ("point matches on left (%g, %g) - (%g, %g) x (%g, %g) - (%g, %g)!\n",
|
|
p0.x, p0.y, p1.x, p1.y, p0r.x, p0r.y, p1r.x, p1r.y);
|
|
#endif
|
|
if (x_order (p0r, p1r, p0, p1) == 1)
|
|
break;
|
|
|
|
#ifdef VERBOSE
|
|
printf ("scanning to the right (i=%d, target=%d)\n", i, target);
|
|
#endif
|
|
}
|
|
|
|
return target;
|
|
}
|
|
#endif
|
|
|
|
/* This routine handles the case where the segment changes its position
|
|
in the active segment list. Generally, this will happen when the
|
|
segment (defined by i and cursor) shares a top point with a neighbor,
|
|
but breaks the ordering invariant.
|
|
|
|
Essentially, this routine sorts the lines [start..end), all of which
|
|
share a top point. This is implemented as your basic insertion sort.
|
|
|
|
This routine takes care of intersecting the appropriate neighbors,
|
|
as well.
|
|
|
|
A first argument of -1 immediately returns, which helps reduce special
|
|
casing in the main unwind routine.
|
|
*/
|
|
static void
|
|
fix_crossing (int start, int end, int *active_segs, int n_active_segs,
|
|
int *cursor, ArtPoint **ips, int *n_ips, int *n_ips_max,
|
|
ArtSVP *vp, int *seg_map,
|
|
ArtSVP **p_new_vp, int *pn_segs_max,
|
|
int **pn_points_max)
|
|
{
|
|
int i, j;
|
|
int target;
|
|
int asi, asj;
|
|
ArtPoint p0i, p1i;
|
|
ArtPoint p0j, p1j;
|
|
int swap = 0;
|
|
#ifdef VERBOSE
|
|
int k;
|
|
#endif
|
|
ArtPoint *pts;
|
|
|
|
#ifdef VERBOSE
|
|
printf ("fix_crossing: [%d..%d)", start, end);
|
|
for (k = 0; k < n_active_segs; k++)
|
|
printf (" %d", active_segs[k]);
|
|
printf ("\n");
|
|
#endif
|
|
|
|
if (start == -1)
|
|
return;
|
|
|
|
for (i = start + 1; i < end; i++)
|
|
{
|
|
|
|
asi = active_segs[i];
|
|
if (cursor[asi] < vp->segs[asi].n_points - 1) {
|
|
p0i = ips[asi][0];
|
|
if (n_ips[asi] == 1)
|
|
p1i = vp->segs[asi].points[cursor[asi] + 1];
|
|
else
|
|
p1i = ips[asi][1];
|
|
|
|
for (j = i - 1; j >= start; j--)
|
|
{
|
|
asj = active_segs[j];
|
|
if (cursor[asj] < vp->segs[asj].n_points - 1)
|
|
{
|
|
p0j = ips[asj][0];
|
|
if (n_ips[asj] == 1)
|
|
p1j = vp->segs[asj].points[cursor[asj] + 1];
|
|
else
|
|
p1j = ips[asj][1];
|
|
|
|
/* we _hope_ p0i = p0j */
|
|
if (x_order_2 (p0j, p1j, p0i, p1i) == -1)
|
|
break;
|
|
}
|
|
}
|
|
|
|
target = j + 1;
|
|
/* target is where active_seg[i] _should_ be in active_segs */
|
|
|
|
if (target != i)
|
|
{
|
|
swap = 1;
|
|
|
|
#ifdef VERBOSE
|
|
printf ("fix_crossing: at %i should be %i\n", i, target);
|
|
#endif
|
|
|
|
/* let's close off all relevant segments */
|
|
for (j = i; j >= target; j--)
|
|
{
|
|
asi = active_segs[j];
|
|
/* First conjunct: this isn't the last point in the original
|
|
segment.
|
|
|
|
Second conjunct: this isn't the first point in the new
|
|
segment (i.e. already broken).
|
|
*/
|
|
if (cursor[asi] < vp->segs[asi].n_points - 1 &&
|
|
(*p_new_vp)->segs[seg_map[asi]].n_points != 1)
|
|
{
|
|
int seg_num;
|
|
/* so break here */
|
|
#ifdef VERBOSE
|
|
printf ("closing off %d\n", j);
|
|
#endif
|
|
|
|
pts = art_new (ArtPoint, 16);
|
|
pts[0] = ips[asi][0];
|
|
seg_num = art_svp_add_segment (p_new_vp, pn_segs_max,
|
|
pn_points_max,
|
|
1, vp->segs[asi].dir,
|
|
pts,
|
|
NULL);
|
|
(*pn_points_max)[seg_num] = 16;
|
|
seg_map[asi] = seg_num;
|
|
}
|
|
}
|
|
|
|
/* now fix the ordering in active_segs */
|
|
asi = active_segs[i];
|
|
for (j = i; j > target; j--)
|
|
active_segs[j] = active_segs[j - 1];
|
|
active_segs[j] = asi;
|
|
}
|
|
}
|
|
}
|
|
if (swap && start > 0)
|
|
{
|
|
int as_start;
|
|
|
|
as_start = active_segs[start];
|
|
if (cursor[as_start] < vp->segs[as_start].n_points)
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("checking intersection of %d, %d\n", start - 1, start);
|
|
#endif
|
|
intersect_neighbors (start, active_segs,
|
|
n_ips, n_ips_max, ips,
|
|
cursor, vp);
|
|
}
|
|
}
|
|
|
|
if (swap && end < n_active_segs)
|
|
{
|
|
int as_end;
|
|
|
|
as_end = active_segs[end - 1];
|
|
if (cursor[as_end] < vp->segs[as_end].n_points)
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("checking intersection of %d, %d\n", end - 1, end);
|
|
#endif
|
|
intersect_neighbors (end, active_segs,
|
|
n_ips, n_ips_max, ips,
|
|
cursor, vp);
|
|
}
|
|
}
|
|
if (swap)
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("fix_crossing return: [%d..%d)", start, end);
|
|
for (k = 0; k < n_active_segs; k++)
|
|
printf (" %d", active_segs[k]);
|
|
printf ("\n");
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/* Return a new sorted vector that covers the same area as the
|
|
argument, but which satisfies the nocross invariant.
|
|
|
|
Basically, this routine works by finding the intersection points,
|
|
and cutting the segments at those points.
|
|
|
|
Status of this routine:
|
|
|
|
Basic correctness: Seems ok.
|
|
|
|
Numerical stability: known problems in the case of points falling
|
|
on lines, and colinear lines. For actual use, randomly perturbing
|
|
the vertices is currently recommended.
|
|
|
|
Speed: pretty good, although a more efficient priority queue, as
|
|
well as bbox culling of potential intersections, are two
|
|
optimizations that could help.
|
|
|
|
Precision: pretty good, although the numerical stability problems
|
|
make this routine unsuitable for precise calculations of
|
|
differences.
|
|
|
|
*/
|
|
|
|
/* Here is a more detailed description of the algorithm. It follows
|
|
roughly the structure of traverse (above), but is obviously quite
|
|
a bit more complex.
|
|
|
|
Here are a few important data structures:
|
|
|
|
A new sorted vector path (new_svp).
|
|
|
|
For each (active) segment in the original, a list of intersection
|
|
points.
|
|
|
|
Of course, the original being traversed.
|
|
|
|
The following invariants hold (in addition to the invariants
|
|
of the traverse procedure).
|
|
|
|
The new sorted vector path lies entirely above the y scan line.
|
|
|
|
The new sorted vector path keeps the nocross invariant.
|
|
|
|
For each active segment, the y scan line crosses the line from the
|
|
first to the second of the intersection points (where the second
|
|
point is cursor + 1 if there is only one intersection point).
|
|
|
|
The list of intersection points + the (cursor + 1) point is kept
|
|
in nondecreasing y order.
|
|
|
|
Of the active segments, none of the lines from first to second
|
|
intersection point cross the 1st ip..2nd ip line of the left or
|
|
right neighbor. (However, such a line may cross further
|
|
intersection points of the neighbors, or segments past the
|
|
immediate neighbors).
|
|
|
|
Of the active segments, all lines from 1st ip..2nd ip are in
|
|
strictly increasing x_order (this is very similar to the invariant
|
|
of the traverse procedure, but is explicitly stated here in terms
|
|
of ips). (this basically says that nocross holds on the active
|
|
segments)
|
|
|
|
The combination of the new sorted vector path, the path through all
|
|
the intersection points to cursor + 1, and [cursor + 1, n_points)
|
|
covers the same area as the argument.
|
|
|
|
Another important data structure is mapping from original segment
|
|
number to new segment number.
|
|
|
|
The algorithm is perhaps best understood as advancing the cursors
|
|
while maintaining these invariants. Here's roughly how it's done.
|
|
|
|
When deleting segments from the active list, those segments are added
|
|
to the new sorted vector path. In addition, the neighbors may intersect
|
|
each other, so they are intersection tested (see below).
|
|
|
|
When inserting new segments, they are intersection tested against
|
|
their neighbors. The top point of the segment becomes the first
|
|
intersection point.
|
|
|
|
Advancing the cursor is just a bit different from the traverse
|
|
routine, as the cursor may advance through the intersection points
|
|
as well. Only when there is a single intersection point in the list
|
|
does the cursor advance in the original segment. In either case,
|
|
the new vector is intersection tested against both neighbors. It
|
|
also causes the vector over which the cursor is advancing to be
|
|
added to the new svp.
|
|
|
|
Two steps need further clarification:
|
|
|
|
Intersection testing: the 1st ip..2nd ip lines of the neighbors
|
|
are tested to see if they cross (using intersect_lines). If so,
|
|
then the intersection point is added to the ip list of both
|
|
segments, maintaining the invariant that the list of intersection
|
|
points is nondecreasing in y).
|
|
|
|
Adding vector to new svp: if the new vector shares a top x
|
|
coordinate with another vector, then it is checked to see whether
|
|
it is in order. If not, then both segments are "broken," and then
|
|
restarted. Note: in the case when both segments are in the same
|
|
order, they may simply be swapped without breaking.
|
|
|
|
For the time being, I'm going to put some of these operations into
|
|
subroutines. If it turns out to be a performance problem, I could
|
|
try to reorganize the traverse procedure so that each is only
|
|
called once, and inline them. But if it's not a performance
|
|
problem, I'll just keep it this way, because it will probably help
|
|
to make the code clearer, and I believe this code could use all the
|
|
clarity it can get. */
|
|
/**
|
|
* art_svp_uncross: Resolve self-intersections of an svp.
|
|
* @vp: The original svp.
|
|
*
|
|
* Finds all the intersections within @vp, and constructs a new svp
|
|
* with new points added at these intersections.
|
|
*
|
|
* This routine needs to be redone from scratch with numerical robustness
|
|
* in mind. I'm working on it.
|
|
*
|
|
* Return value: The new svp.
|
|
**/
|
|
ArtSVP *
|
|
art_svp_uncross (ArtSVP *vp)
|
|
{
|
|
int *active_segs;
|
|
int n_active_segs;
|
|
int *cursor;
|
|
int seg_idx;
|
|
double y;
|
|
int tmp1, tmp2;
|
|
int asi;
|
|
int i, j;
|
|
/* new data structures */
|
|
/* intersection points; invariant: *ips[i] is only allocated if
|
|
i is active */
|
|
int *n_ips, *n_ips_max;
|
|
ArtPoint **ips;
|
|
/* new sorted vector path */
|
|
int n_segs_max, seg_num;
|
|
ArtSVP *new_vp;
|
|
int *n_points_max;
|
|
/* mapping from argument to new segment numbers - again, only valid
|
|
if active */
|
|
int *seg_map;
|
|
double y_curs;
|
|
ArtPoint p_curs;
|
|
int first_share;
|
|
double share_x;
|
|
ArtPoint *pts;
|
|
|
|
n_segs_max = 16;
|
|
new_vp = (ArtSVP *)art_alloc (sizeof(ArtSVP) +
|
|
(n_segs_max - 1) * sizeof(ArtSVPSeg));
|
|
new_vp->n_segs = 0;
|
|
|
|
if (vp->n_segs == 0)
|
|
return new_vp;
|
|
|
|
active_segs = art_new (int, vp->n_segs);
|
|
cursor = art_new (int, vp->n_segs);
|
|
|
|
seg_map = art_new (int, vp->n_segs);
|
|
n_ips = art_new (int, vp->n_segs);
|
|
n_ips_max = art_new (int, vp->n_segs);
|
|
ips = art_new (ArtPoint *, vp->n_segs);
|
|
|
|
n_points_max = art_new (int, n_segs_max);
|
|
|
|
n_active_segs = 0;
|
|
seg_idx = 0;
|
|
y = vp->segs[0].points[0].y;
|
|
while (seg_idx < vp->n_segs || n_active_segs > 0)
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("y = %g\n", y);
|
|
#endif
|
|
|
|
/* maybe move deletions to end of loop (to avoid so much special
|
|
casing on the end of a segment)? */
|
|
|
|
/* delete segments ending at y from active list */
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
if (vp->segs[asi].n_points - 1 == cursor[asi] &&
|
|
vp->segs[asi].points[cursor[asi]].y == y)
|
|
{
|
|
do
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("deleting %d\n", asi);
|
|
#endif
|
|
art_free (ips[asi]);
|
|
n_active_segs--;
|
|
for (j = i; j < n_active_segs; j++)
|
|
active_segs[j] = active_segs[j + 1];
|
|
if (i < n_active_segs)
|
|
asi = active_segs[i];
|
|
else
|
|
break;
|
|
}
|
|
while (vp->segs[asi].n_points - 1 == cursor[asi] &&
|
|
vp->segs[asi].points[cursor[asi]].y == y);
|
|
|
|
/* test intersection of neighbors */
|
|
if (i > 0 && i < n_active_segs)
|
|
intersect_neighbors (i, active_segs,
|
|
n_ips, n_ips_max, ips,
|
|
cursor, vp);
|
|
|
|
i--;
|
|
}
|
|
}
|
|
|
|
/* insert new segments into the active list */
|
|
while (seg_idx < vp->n_segs && y == vp->segs[seg_idx].points[0].y)
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("inserting %d\n", seg_idx);
|
|
#endif
|
|
cursor[seg_idx] = 0;
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
if (x_order_2 (vp->segs[seg_idx].points[0],
|
|
vp->segs[seg_idx].points[1],
|
|
vp->segs[asi].points[cursor[asi]],
|
|
vp->segs[asi].points[cursor[asi] + 1]) == -1)
|
|
break;
|
|
}
|
|
|
|
/* Create and initialize the intersection points data structure */
|
|
n_ips[seg_idx] = 1;
|
|
n_ips_max[seg_idx] = 2;
|
|
ips[seg_idx] = art_new (ArtPoint, n_ips_max[seg_idx]);
|
|
ips[seg_idx][0] = vp->segs[seg_idx].points[0];
|
|
|
|
/* Start a new segment in the new vector path */
|
|
pts = art_new (ArtPoint, 16);
|
|
pts[0] = vp->segs[seg_idx].points[0];
|
|
seg_num = art_svp_add_segment (&new_vp, &n_segs_max,
|
|
&n_points_max,
|
|
1, vp->segs[seg_idx].dir,
|
|
pts,
|
|
NULL);
|
|
n_points_max[seg_num] = 16;
|
|
seg_map[seg_idx] = seg_num;
|
|
|
|
tmp1 = seg_idx;
|
|
for (j = i; j < n_active_segs; j++)
|
|
{
|
|
tmp2 = active_segs[j];
|
|
active_segs[j] = tmp1;
|
|
tmp1 = tmp2;
|
|
}
|
|
active_segs[n_active_segs] = tmp1;
|
|
n_active_segs++;
|
|
|
|
if (i > 0)
|
|
intersect_neighbors (i, active_segs,
|
|
n_ips, n_ips_max, ips,
|
|
cursor, vp);
|
|
|
|
if (i + 1 < n_active_segs)
|
|
intersect_neighbors (i + 1, active_segs,
|
|
n_ips, n_ips_max, ips,
|
|
cursor, vp);
|
|
|
|
seg_idx++;
|
|
}
|
|
|
|
/* all active segs cross the y scanline (considering segs to be
|
|
closed on top and open on bottom) */
|
|
#ifdef VERBOSE
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
printf ("%d ", asi);
|
|
for (j = 0; j < n_ips[asi]; j++)
|
|
printf ("(%g, %g) - ",
|
|
ips[asi][j].x,
|
|
ips[asi][j].y);
|
|
printf ("(%g, %g) %s\n",
|
|
vp->segs[asi].points[cursor[asi] + 1].x,
|
|
vp->segs[asi].points[cursor[asi] + 1].y,
|
|
vp->segs[asi].dir ? "v" : "^");
|
|
}
|
|
#endif
|
|
|
|
/* advance y to the next event
|
|
Note: this is quadratic. We'd probably get decent constant
|
|
factor speed improvement by caching the y_curs values. */
|
|
if (n_active_segs == 0)
|
|
{
|
|
if (seg_idx < vp->n_segs)
|
|
y = vp->segs[seg_idx].points[0].y;
|
|
/* else we're done */
|
|
}
|
|
else
|
|
{
|
|
asi = active_segs[0];
|
|
if (n_ips[asi] == 1)
|
|
y = vp->segs[asi].points[cursor[asi] + 1].y;
|
|
else
|
|
y = ips[asi][1].y;
|
|
for (i = 1; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
if (n_ips[asi] == 1)
|
|
y_curs = vp->segs[asi].points[cursor[asi] + 1].y;
|
|
else
|
|
y_curs = ips[asi][1].y;
|
|
if (y > y_curs)
|
|
y = y_curs;
|
|
}
|
|
if (seg_idx < vp->n_segs && y > vp->segs[seg_idx].points[0].y)
|
|
y = vp->segs[seg_idx].points[0].y;
|
|
}
|
|
|
|
first_share = -1;
|
|
share_x = 0; /* to avoid gcc warning, although share_x is never
|
|
used when first_share is -1 */
|
|
/* advance cursors to reach new y */
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
if (n_ips[asi] == 1)
|
|
p_curs = vp->segs[asi].points[cursor[asi] + 1];
|
|
else
|
|
p_curs = ips[asi][1];
|
|
if (p_curs.y == y)
|
|
{
|
|
svp_add_point (new_vp, n_points_max,
|
|
p_curs, seg_map, active_segs, n_active_segs, i);
|
|
|
|
n_ips[asi]--;
|
|
for (j = 0; j < n_ips[asi]; j++)
|
|
ips[asi][j] = ips[asi][j + 1];
|
|
|
|
if (n_ips[asi] == 0)
|
|
{
|
|
ips[asi][0] = p_curs;
|
|
n_ips[asi] = 1;
|
|
cursor[asi]++;
|
|
}
|
|
|
|
if (first_share < 0 || p_curs.x != share_x)
|
|
{
|
|
/* this is where crossings are detected, and if
|
|
found, the active segments switched around. */
|
|
|
|
fix_crossing (first_share, i,
|
|
active_segs, n_active_segs,
|
|
cursor, ips, n_ips, n_ips_max, vp, seg_map,
|
|
&new_vp,
|
|
&n_segs_max, &n_points_max);
|
|
|
|
first_share = i;
|
|
share_x = p_curs.x;
|
|
}
|
|
|
|
if (cursor[asi] < vp->segs[asi].n_points - 1)
|
|
{
|
|
|
|
if (i > 0)
|
|
intersect_neighbors (i, active_segs,
|
|
n_ips, n_ips_max, ips,
|
|
cursor, vp);
|
|
|
|
if (i + 1 < n_active_segs)
|
|
intersect_neighbors (i + 1, active_segs,
|
|
n_ips, n_ips_max, ips,
|
|
cursor, vp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* not on a cursor point */
|
|
fix_crossing (first_share, i,
|
|
active_segs, n_active_segs,
|
|
cursor, ips, n_ips, n_ips_max, vp, seg_map,
|
|
&new_vp,
|
|
&n_segs_max, &n_points_max);
|
|
first_share = -1;
|
|
}
|
|
}
|
|
|
|
/* fix crossing on last shared group */
|
|
fix_crossing (first_share, i,
|
|
active_segs, n_active_segs,
|
|
cursor, ips, n_ips, n_ips_max, vp, seg_map,
|
|
&new_vp,
|
|
&n_segs_max, &n_points_max);
|
|
|
|
#ifdef VERBOSE
|
|
printf ("\n");
|
|
#endif
|
|
}
|
|
|
|
/* not necessary to sort, new segments only get added at y, which
|
|
increases monotonically */
|
|
#if 0
|
|
qsort (&new_vp->segs, new_vp->n_segs, sizeof (svp_seg), svp_seg_compare);
|
|
{
|
|
int k;
|
|
for (k = 0; k < new_vp->n_segs - 1; k++)
|
|
{
|
|
printf ("(%g, %g) - (%g, %g) %s (%g, %g) - (%g, %g)\n",
|
|
new_vp->segs[k].points[0].x,
|
|
new_vp->segs[k].points[0].y,
|
|
new_vp->segs[k].points[1].x,
|
|
new_vp->segs[k].points[1].y,
|
|
svp_seg_compare (&new_vp->segs[k], &new_vp->segs[k + 1]) > 1 ? ">": "<",
|
|
new_vp->segs[k + 1].points[0].x,
|
|
new_vp->segs[k + 1].points[0].y,
|
|
new_vp->segs[k + 1].points[1].x,
|
|
new_vp->segs[k + 1].points[1].y);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
art_free (n_points_max);
|
|
art_free (seg_map);
|
|
art_free (n_ips_max);
|
|
art_free (n_ips);
|
|
art_free (ips);
|
|
art_free (cursor);
|
|
art_free (active_segs);
|
|
|
|
return new_vp;
|
|
}
|
|
|
|
#define noVERBOSE
|
|
|
|
/* Rewind a svp satisfying the nocross invariant.
|
|
|
|
The winding number of a segment is defined as the winding number of
|
|
the points to the left while travelling in the direction of the
|
|
segment. Therefore it preincrements and postdecrements as a scan
|
|
line is traversed from left to right.
|
|
|
|
Status of this routine:
|
|
|
|
Basic correctness: Was ok in gfonted. However, this code does not
|
|
yet compute bboxes for the resulting svp segs.
|
|
|
|
Numerical stability: known problems in the case of horizontal
|
|
segments in polygons with any complexity. For actual use, randomly
|
|
perturbing the vertices is recommended.
|
|
|
|
Speed: good.
|
|
|
|
Precision: good, except that no attempt is made to remove "hair".
|
|
Doing random perturbation just makes matters worse.
|
|
|
|
*/
|
|
/**
|
|
* art_svp_rewind_uncrossed: Rewind an svp satisfying the nocross invariant.
|
|
* @vp: The original svp.
|
|
* @rule: The winding rule.
|
|
*
|
|
* Creates a new svp with winding number of 0 or 1 everywhere. The @rule
|
|
* argument specifies a rule for how winding numbers in the original
|
|
* @vp map to the winding numbers in the result.
|
|
*
|
|
* With @rule == ART_WIND_RULE_NONZERO, the resulting svp has a
|
|
* winding number of 1 where @vp has a nonzero winding number.
|
|
*
|
|
* With @rule == ART_WIND_RULE_INTERSECT, the resulting svp has a
|
|
* winding number of 1 where @vp has a winding number greater than
|
|
* 1. It is useful for computing intersections.
|
|
*
|
|
* With @rule == ART_WIND_RULE_ODDEVEN, the resulting svp has a
|
|
* winding number of 1 where @vp has an odd winding number. It is
|
|
* useful for implementing the even-odd winding rule of the
|
|
* PostScript imaging model.
|
|
*
|
|
* With @rule == ART_WIND_RULE_POSITIVE, the resulting svp has a
|
|
* winding number of 1 where @vp has a positive winding number. It is
|
|
* useful for implementing asymmetric difference.
|
|
*
|
|
* This routine needs to be redone from scratch with numerical robustness
|
|
* in mind. I'm working on it.
|
|
*
|
|
* Return value: The new svp.
|
|
**/
|
|
ArtSVP *
|
|
art_svp_rewind_uncrossed (ArtSVP *vp, ArtWindRule rule)
|
|
{
|
|
int *active_segs;
|
|
int n_active_segs;
|
|
int *cursor;
|
|
int seg_idx;
|
|
double y;
|
|
int tmp1, tmp2;
|
|
int asi;
|
|
int i, j;
|
|
|
|
ArtSVP *new_vp;
|
|
int n_segs_max;
|
|
int *winding;
|
|
int left_wind;
|
|
int wind;
|
|
int keep, invert;
|
|
|
|
#ifdef VERBOSE
|
|
print_svp (vp);
|
|
#endif
|
|
n_segs_max = 16;
|
|
new_vp = (ArtSVP *)art_alloc (sizeof(ArtSVP) +
|
|
(n_segs_max - 1) * sizeof(ArtSVPSeg));
|
|
new_vp->n_segs = 0;
|
|
|
|
if (vp->n_segs == 0)
|
|
return new_vp;
|
|
|
|
winding = art_new (int, vp->n_segs);
|
|
|
|
active_segs = art_new (int, vp->n_segs);
|
|
cursor = art_new (int, vp->n_segs);
|
|
|
|
n_active_segs = 0;
|
|
seg_idx = 0;
|
|
y = vp->segs[0].points[0].y;
|
|
while (seg_idx < vp->n_segs || n_active_segs > 0)
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("y = %g\n", y);
|
|
#endif
|
|
/* delete segments ending at y from active list */
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
if (vp->segs[asi].n_points - 1 == cursor[asi] &&
|
|
vp->segs[asi].points[cursor[asi]].y == y)
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("deleting %d\n", asi);
|
|
#endif
|
|
n_active_segs--;
|
|
for (j = i; j < n_active_segs; j++)
|
|
active_segs[j] = active_segs[j + 1];
|
|
i--;
|
|
}
|
|
}
|
|
|
|
/* insert new segments into the active list */
|
|
while (seg_idx < vp->n_segs && y == vp->segs[seg_idx].points[0].y)
|
|
{
|
|
#ifdef VERBOSE
|
|
printf ("inserting %d\n", seg_idx);
|
|
#endif
|
|
cursor[seg_idx] = 0;
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
if (x_order_2 (vp->segs[seg_idx].points[0],
|
|
vp->segs[seg_idx].points[1],
|
|
vp->segs[asi].points[cursor[asi]],
|
|
vp->segs[asi].points[cursor[asi] + 1]) == -1)
|
|
break;
|
|
}
|
|
|
|
/* Determine winding number for this segment */
|
|
if (i == 0)
|
|
left_wind = 0;
|
|
else if (vp->segs[active_segs[i - 1]].dir)
|
|
left_wind = winding[active_segs[i - 1]];
|
|
else
|
|
left_wind = winding[active_segs[i - 1]] - 1;
|
|
|
|
if (vp->segs[seg_idx].dir)
|
|
wind = left_wind + 1;
|
|
else
|
|
wind = left_wind;
|
|
|
|
winding[seg_idx] = wind;
|
|
|
|
switch (rule)
|
|
{
|
|
case ART_WIND_RULE_NONZERO:
|
|
keep = (wind == 1 || wind == 0);
|
|
invert = (wind == 0);
|
|
break;
|
|
case ART_WIND_RULE_INTERSECT:
|
|
keep = (wind == 2);
|
|
invert = 0;
|
|
break;
|
|
case ART_WIND_RULE_ODDEVEN:
|
|
keep = 1;
|
|
invert = !(wind & 1);
|
|
break;
|
|
case ART_WIND_RULE_POSITIVE:
|
|
keep = (wind == 1);
|
|
invert = 0;
|
|
break;
|
|
default:
|
|
keep = 0;
|
|
invert = 0;
|
|
break;
|
|
}
|
|
|
|
if (keep)
|
|
{
|
|
ArtPoint *points, *new_points;
|
|
int n_points;
|
|
int new_dir;
|
|
|
|
#ifdef VERBOSE
|
|
printf ("keeping segment %d\n", seg_idx);
|
|
#endif
|
|
n_points = vp->segs[seg_idx].n_points;
|
|
points = vp->segs[seg_idx].points;
|
|
new_points = art_new (ArtPoint, n_points);
|
|
memcpy (new_points, points, n_points * sizeof (ArtPoint));
|
|
new_dir = vp->segs[seg_idx].dir ^ invert;
|
|
art_svp_add_segment (&new_vp, &n_segs_max,
|
|
NULL,
|
|
n_points, new_dir, new_points,
|
|
&vp->segs[seg_idx].bbox);
|
|
}
|
|
|
|
tmp1 = seg_idx;
|
|
for (j = i; j < n_active_segs; j++)
|
|
{
|
|
tmp2 = active_segs[j];
|
|
active_segs[j] = tmp1;
|
|
tmp1 = tmp2;
|
|
}
|
|
active_segs[n_active_segs] = tmp1;
|
|
n_active_segs++;
|
|
seg_idx++;
|
|
}
|
|
|
|
#ifdef VERBOSE
|
|
/* all active segs cross the y scanline (considering segs to be
|
|
closed on top and open on bottom) */
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
printf ("%d:%d (%g, %g) - (%g, %g) %s %d\n", asi,
|
|
cursor[asi],
|
|
vp->segs[asi].points[cursor[asi]].x,
|
|
vp->segs[asi].points[cursor[asi]].y,
|
|
vp->segs[asi].points[cursor[asi] + 1].x,
|
|
vp->segs[asi].points[cursor[asi] + 1].y,
|
|
vp->segs[asi].dir ? "v" : "^",
|
|
winding[asi]);
|
|
}
|
|
#endif
|
|
|
|
/* advance y to the next event */
|
|
if (n_active_segs == 0)
|
|
{
|
|
if (seg_idx < vp->n_segs)
|
|
y = vp->segs[seg_idx].points[0].y;
|
|
/* else we're done */
|
|
}
|
|
else
|
|
{
|
|
asi = active_segs[0];
|
|
y = vp->segs[asi].points[cursor[asi] + 1].y;
|
|
for (i = 1; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
if (y > vp->segs[asi].points[cursor[asi] + 1].y)
|
|
y = vp->segs[asi].points[cursor[asi] + 1].y;
|
|
}
|
|
if (seg_idx < vp->n_segs && y > vp->segs[seg_idx].points[0].y)
|
|
y = vp->segs[seg_idx].points[0].y;
|
|
}
|
|
|
|
/* advance cursors to reach new y */
|
|
for (i = 0; i < n_active_segs; i++)
|
|
{
|
|
asi = active_segs[i];
|
|
while (cursor[asi] < vp->segs[asi].n_points - 1 &&
|
|
y >= vp->segs[asi].points[cursor[asi] + 1].y)
|
|
cursor[asi]++;
|
|
}
|
|
#ifdef VERBOSE
|
|
printf ("\n");
|
|
#endif
|
|
}
|
|
art_free (cursor);
|
|
art_free (active_segs);
|
|
art_free (winding);
|
|
|
|
return new_vp;
|
|
}
|