static void mbc_test(LWGEOM* g)
{
LWBOUNDINGCIRCLE* result = lwgeom_calculate_mbc(g);
CU_ASSERT_TRUE(result != NULL);
LWPOINTITERATOR* it = lwpointiterator_create(g);
POINT2D p;
POINT4D p4;
while (lwpointiterator_next(it, &p4))
{
p.x = p4.x;
p.y = p4.y;
/* We need to store the distance in a variable before the assert so that
* it is rounded from its 80-bit representation (on x86) down to 64 bits.
* */
volatile double d = distance2d_pt_pt(result->center, &p);
CU_ASSERT_TRUE(d <= result->radius);
}
lwboundingcircle_destroy(result);
lwpointiterator_destroy(it);
}
/**
* Returns LW_TRUE if b is on the arc formed by a1/a2/a3, but not within
* that portion already described by a1/a2/a3
*/
static int pt_continues_arc(const POINT4D *a1, const POINT4D *a2, const POINT4D *a3, const POINT4D *b)
{
POINT4D center;
POINT4D *centerptr=¢er;
double radius = lwcircle_center(a1, a2, a3, ¢er);
double b_distance, diff;
/* Co-linear a1/a2/a3 */
if ( radius < 0.0 )
return LW_FALSE;
b_distance = distance2d_pt_pt((POINT2D*)b, (POINT2D*)centerptr);
diff = fabs(radius - b_distance);
LWDEBUGF(4, "circle_radius=%g, b_distance=%g, diff=%g, percentage=%g", radius, b_distance, diff, diff/radius);
/* Is the point b on the circle? */
if ( diff < EPSILON_SQLMM )
{
int a2_side = signum(lw_segment_side((POINT2D*)a1, (POINT2D*)a3, (POINT2D*)a2));
int b_side = signum(lw_segment_side((POINT2D*)a1, (POINT2D*)a3, (POINT2D*)b));
/* Is the point b on the same side of a1/a3 as the mid-point a2 is? */
/* If not, it's in the unbounded part of the circle, so it continues the arc, return true. */
if ( b_side != a2_side )
return LW_TRUE;
}
return LW_FALSE;
}
/**
The old function nessecary for ptarray_segmentize2d in ptarray.c
*/
double
distance2d_pt_seg(const POINT2D *p, const POINT2D *A, const POINT2D *B)
{
double r,s;
/*if start==end, then use pt distance */
if ( ( A->x == B->x) && (A->y == B->y) )
return distance2d_pt_pt(p,A);
/*
* otherwise, we use comp.graphics.algorithms
* Frequently Asked Questions method
*
* (1) AC dot AB
* r = ---------
* ||AB||^2
* r has the following meaning:
* r=0 P = A
* r=1 P = B
* r<0 P is on the backward extension of AB
* r>1 P is on the forward extension of AB
* 0<r<1 P is interior to AB
*/
r = ( (p->x-A->x) * (B->x-A->x) + (p->y-A->y) * (B->y-A->y) )/( (B->x-A->x)*(B->x-A->x) +(B->y-A->y)*(B->y-A->y) );
if (r<0) return distance2d_pt_pt(p,A);
if (r>1) return distance2d_pt_pt(p,B);
/*
* (2)
* (Ay-Cy)(Bx-Ax)-(Ax-Cx)(By-Ay)
* s = -----------------------------
* L^2
*
* Then the distance from C to P = |s|*L.
*
*/
s = ( (A->y-p->y)*(B->x-A->x)- (A->x-p->x)*(B->y-A->y) ) /
( (B->x-A->x)*(B->x-A->x) +(B->y-A->y)*(B->y-A->y) );
return FP_ABS(s) * sqrt(
(B->x-A->x)*(B->x-A->x) + (B->y-A->y)*(B->y-A->y)
);
}
/**
* Re-write the measure ordinate (or add one, if it isn't already there) interpolating
* the measure between the supplied start and end values.
*/
LWLINE*
lwline_measured_from_lwline(const LWLINE *lwline, double m_start, double m_end)
{
int i = 0;
int hasm = 0, hasz = 0;
int npoints = 0;
double length = 0.0;
double length_so_far = 0.0;
double m_range = m_end - m_start;
double m;
POINTARRAY *pa = NULL;
POINT3DZ p1, p2;
if ( TYPE_GETTYPE(lwline->type) != LINETYPE )
{
lwerror("lwline_construct_from_lwline: only line types supported");
return NULL;
}
hasz = TYPE_HASZ(lwline->type);
hasm = 1;
/* Null points or npoints == 0 will result in empty return geometry */
if ( lwline->points )
{
npoints = lwline->points->npoints;
length = lwgeom_pointarray_length2d(lwline->points);
getPoint3dz_p(lwline->points, 0, &p1);
}
pa = ptarray_construct(hasz, hasm, npoints);
for ( i = 0; i < npoints; i++ )
{
POINT4D q;
POINT2D a, b;
getPoint3dz_p(lwline->points, i, &p2);
a.x = p1.x;
a.y = p1.y;
b.x = p2.x;
b.y = p2.y;
length_so_far += distance2d_pt_pt(&a, &b);
if ( length > 0.0 )
m = m_start + m_range * length_so_far / length;
else
m = 0.0;
q.x = p2.x;
q.y = p2.y;
q.z = p2.z;
q.m = m;
setPoint4d(pa, i, &q);
p1 = p2;
}
return lwline_construct(lwline->SRID, NULL, pa);
}
int
lwgeom_pt_inside_circle(POINT2D *p, double cx, double cy, double rad)
{
POINT2D center;
center.x = cx;
center.y = cy;
if ( distance2d_pt_pt(p, ¢er) < rad ) return 1;
else return 0;
}
/**
* Returns LW_TRUE if b is on the arc formed by a1/a2/a3, but not within
* that portion already described by a1/a2/a3
*/
static int pt_continues_arc(const POINT4D *a1, const POINT4D *a2, const POINT4D *a3, const POINT4D *b)
{
POINT2D center;
POINT2D *t1 = (POINT2D*)a1;
POINT2D *t2 = (POINT2D*)a2;
POINT2D *t3 = (POINT2D*)a3;
POINT2D *tb = (POINT2D*)b;
double radius = lw_arc_center(t1, t2, t3, ¢er);
double b_distance, diff;
/* Co-linear a1/a2/a3 */
if ( radius < 0.0 )
return LW_FALSE;
b_distance = distance2d_pt_pt(tb, ¢er);
diff = fabs(radius - b_distance);
LWDEBUGF(4, "circle_radius=%g, b_distance=%g, diff=%g, percentage=%g", radius, b_distance, diff, diff/radius);
/* Is the point b on the circle? */
if ( diff < EPSILON_SQLMM )
{
int a2_side = lw_segment_side(t1, t3, t2);
int b_side = lw_segment_side(t1, t3, tb);
double angle1 = lw_arc_angle(t1, t2, t3);
double angle2 = lw_arc_angle(t2, t3, tb);
/* Is the angle similar to the previous one ? */
diff = fabs(angle1 - angle2);
LWDEBUGF(4, " angle1: %g, angle2: %g, diff:%g", angle1, angle2, diff);
if ( diff > EPSILON_SQLMM )
{
return LW_FALSE;
}
/* Is the point b on the same side of a1/a3 as the mid-point a2 is? */
/* If not, it's in the unbounded part of the circle, so it continues the arc, return true. */
if ( b_side != a2_side )
return LW_TRUE;
}
return LW_FALSE;
}
int lw_arc_side(const POINT2D *A1, const POINT2D *A2, const POINT2D *A3, const POINT2D *Q)
{
POINT2D C;
double radius_A;
double side_Q, side_A2;
double d;
side_Q = lw_segment_side(A1, A3, Q);
radius_A = lw_arc_center(A1, A2, A3, &C);
side_A2 = lw_segment_side(A1, A3, A2);
/* Linear case */
if ( radius_A < 0 )
return side_Q;
d = distance2d_pt_pt(Q, &C);
/* Q is on the arc boundary */
if ( d == radius_A && side_Q == side_A2 )
{
return 0;
}
/* Q on A1-A3 line, so its on opposite side to A2 */
if ( side_Q == 0 )
{
return -1 * side_A2;
}
/*
* Q is inside the arc boundary, so it's not on the side we
* might think from examining only the end points
*/
if ( d < radius_A && side_Q == side_A2 )
{
side_Q *= -1;
}
return side_Q;
}
Datum LWGEOM_line_interpolate_point(PG_FUNCTION_ARGS)
{
GSERIALIZED *geom = (GSERIALIZED *)PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
double distance = PG_GETARG_FLOAT8(1);
LWLINE *line;
LWPOINT *point;
POINTARRAY *ipa, *opa;
POINT4D pt;
int nsegs, i;
double length, slength, tlength;
if ( distance < 0 || distance > 1 )
{
elog(ERROR,"line_interpolate_point: 2nd arg isnt within [0,1]");
PG_RETURN_NULL();
}
if ( gserialized_get_type(geom) != LINETYPE )
{
elog(ERROR,"line_interpolate_point: 1st arg isnt a line");
PG_RETURN_NULL();
}
line = lwgeom_as_lwline(lwgeom_from_gserialized(geom));
ipa = line->points;
/* If distance is one of the two extremes, return the point on that
* end rather than doing any expensive computations
*/
if ( distance == 0.0 || distance == 1.0 )
{
if ( distance == 0.0 )
getPoint4d_p(ipa, 0, &pt);
else
getPoint4d_p(ipa, ipa->npoints-1, &pt);
opa = ptarray_construct_reference_data(FLAGS_GET_Z(line->flags), FLAGS_GET_M(line->flags), 1, (uint8_t*)&pt);
point = lwpoint_construct(line->srid, NULL, opa);
PG_RETURN_POINTER(geometry_serialize(lwpoint_as_lwgeom(point)));
}
/* Interpolate a point on the line */
nsegs = ipa->npoints - 1;
length = ptarray_length_2d(ipa);
tlength = 0;
for ( i = 0; i < nsegs; i++ )
{
POINT4D p1, p2;
POINT4D *p1ptr=&p1, *p2ptr=&p2; /* don't break
* strict-aliasing rules
*/
getPoint4d_p(ipa, i, &p1);
getPoint4d_p(ipa, i+1, &p2);
/* Find the relative length of this segment */
slength = distance2d_pt_pt((POINT2D*)p1ptr, (POINT2D*)p2ptr)/length;
/* If our target distance is before the total length we've seen
* so far. create a new point some distance down the current
* segment.
*/
if ( distance < tlength + slength )
{
double dseg = (distance - tlength) / slength;
interpolate_point4d(&p1, &p2, &pt, dseg);
opa = ptarray_construct_reference_data(FLAGS_GET_Z(line->flags), FLAGS_GET_M(line->flags), 1, (uint8_t*)&pt);
point = lwpoint_construct(line->srid, NULL, opa);
PG_RETURN_POINTER(geometry_serialize(lwpoint_as_lwgeom(point)));
}
tlength += slength;
}
/* Return the last point on the line. This shouldn't happen, but
* could if there's some floating point rounding errors. */
getPoint4d_p(ipa, ipa->npoints-1, &pt);
opa = ptarray_construct_reference_data(FLAGS_GET_Z(line->flags), FLAGS_GET_M(line->flags), 1, (uint8_t*)&pt);
point = lwpoint_construct(line->srid, NULL, opa);
PG_RETURN_POINTER(geometry_serialize(lwpoint_as_lwgeom(point)));
}
/*
* Given a point, returns the location of closest point on pointarray
* and, optionally, it's actual distance from the point array.
*/
double
ptarray_locate_point(const POINTARRAY *pa, const POINT4D *p4d, double *mindistout, POINT4D *proj4d)
{
double mindist=-1;
double tlen, plen;
int t, seg=-1;
POINT4D start4d, end4d, projtmp;
POINT2D start, end, proj, p;
/* Initialize our 2D copy of the input parameter */
p.x = p4d->x;
p.y = p4d->y;
if ( ! proj4d ) proj4d = &projtmp;
getPoint2d_p(pa, 0, &start);
for (t=1; t<pa->npoints; t++)
{
double dist;
getPoint2d_p(pa, t, &end);
dist = distance2d_pt_seg(&p, &start, &end);
if (t==1 || dist < mindist )
{
mindist = dist;
seg=t-1;
}
if ( mindist == 0 )
{
LWDEBUG(3, "Breaking on mindist=0");
break;
}
start = end;
}
if ( mindistout ) *mindistout = mindist;
LWDEBUGF(3, "Closest segment: %d", seg);
LWDEBUGF(3, "mindist: %g", mindist);
/*
* We need to project the
* point on the closest segment.
*/
getPoint4d_p(pa, seg, &start4d);
getPoint4d_p(pa, seg+1, &end4d);
closest_point_on_segment(p4d, &start4d, &end4d, proj4d);
/* Copy 4D values into 2D holder */
proj.x = proj4d->x;
proj.y = proj4d->y;
LWDEBUGF(3, "Closest segment:%d, npoints:%d", seg, pa->npoints);
/* For robustness, force 1 when closest point == endpoint */
if ( (seg >= (pa->npoints-2)) && p2d_same(&proj, &end) )
{
return 1.0;
}
LWDEBUGF(3, "Closest point on segment: %g,%g", proj.x, proj.y);
tlen = ptarray_length_2d(pa);
LWDEBUGF(3, "tlen %g", tlen);
/* Location of any point on a zero-length line is 0 */
/* See http://trac.osgeo.org/postgis/ticket/1772#comment:2 */
if ( tlen == 0 ) return 0;
plen=0;
getPoint2d_p(pa, 0, &start);
for (t=0; t<seg; t++, start=end)
{
getPoint2d_p(pa, t+1, &end);
plen += distance2d_pt_pt(&start, &end);
LWDEBUGF(4, "Segment %d made plen %g", t, plen);
}
plen+=distance2d_pt_pt(&proj, &start);
LWDEBUGF(3, "plen %g, tlen %g", plen, tlen);
return plen/tlen;
}
POINTARRAY *
ptarray_substring(POINTARRAY *ipa, double from, double to, double tolerance)
{
POINTARRAY *dpa;
POINT4D pt;
POINT4D p1, p2;
POINT4D *p1ptr=&p1; /* don't break strict-aliasing rule */
POINT4D *p2ptr=&p2;
int nsegs, i;
double length, slength, tlength;
int state = 0; /* 0=before, 1=inside */
/*
* Create a dynamic pointarray with an initial capacity
* equal to full copy of input points
*/
dpa = ptarray_construct_empty(FLAGS_GET_Z(ipa->flags), FLAGS_GET_M(ipa->flags), ipa->npoints);
/* Compute total line length */
length = ptarray_length_2d(ipa);
LWDEBUGF(3, "Total length: %g", length);
/* Get 'from' and 'to' lengths */
from = length*from;
to = length*to;
LWDEBUGF(3, "From/To: %g/%g", from, to);
tlength = 0;
getPoint4d_p(ipa, 0, &p1);
nsegs = ipa->npoints - 1;
for ( i = 0; i < nsegs; i++ )
{
double dseg;
getPoint4d_p(ipa, i+1, &p2);
LWDEBUGF(3 ,"Segment %d: (%g,%g,%g,%g)-(%g,%g,%g,%g)",
i, p1.x, p1.y, p1.z, p1.m, p2.x, p2.y, p2.z, p2.m);
/* Find the length of this segment */
slength = distance2d_pt_pt((POINT2D *)p1ptr, (POINT2D *)p2ptr);
/*
* We are before requested start.
*/
if ( state == 0 ) /* before */
{
LWDEBUG(3, " Before start");
if ( fabs ( from - ( tlength + slength ) ) <= tolerance )
{
LWDEBUG(3, " Second point is our start");
/*
* Second point is our start
*/
ptarray_append_point(dpa, &p2, LW_FALSE);
state=1; /* we're inside now */
goto END;
}
else if ( fabs(from - tlength) <= tolerance )
{
LWDEBUG(3, " First point is our start");
/*
* First point is our start
*/
ptarray_append_point(dpa, &p1, LW_FALSE);
/*
* We're inside now, but will check
* 'to' point as well
*/
state=1;
}
/*
* Didn't reach the 'from' point,
* nothing to do
*/
else if ( from > tlength + slength ) goto END;
else /* tlength < from < tlength+slength */
{
LWDEBUG(3, " Seg contains first point");
/*
* Our start is between first and
* second point
*/
dseg = (from - tlength) / slength;
interpolate_point4d(&p1, &p2, &pt, dseg);
ptarray_append_point(dpa, &pt, LW_FALSE);
/*
* We're inside now, but will check
* 'to' point as well
*/
state=1;
}
}
if ( state == 1 ) /* inside */
{
LWDEBUG(3, " Inside");
/*
* 'to' point is our second point.
*/
if ( fabs(to - ( tlength + slength ) ) <= tolerance )
{
LWDEBUG(3, " Second point is our end");
ptarray_append_point(dpa, &p2, LW_FALSE);
break; /* substring complete */
}
/*
* 'to' point is our first point.
* (should only happen if 'to' is 0)
*/
else if ( fabs(to - tlength) <= tolerance )
{
LWDEBUG(3, " First point is our end");
ptarray_append_point(dpa, &p1, LW_FALSE);
break; /* substring complete */
}
/*
* Didn't reach the 'end' point,
* just copy second point
*/
else if ( to > tlength + slength )
{
ptarray_append_point(dpa, &p2, LW_FALSE);
goto END;
}
/*
* 'to' point falls on this segment
* Interpolate and break.
*/
else if ( to < tlength + slength )
{
LWDEBUG(3, " Seg contains our end");
dseg = (to - tlength) / slength;
interpolate_point4d(&p1, &p2, &pt, dseg);
ptarray_append_point(dpa, &pt, LW_FALSE);
break;
}
else
{
LWDEBUG(3, "Unhandled case");
}
}
END:
tlength += slength;
memcpy(&p1, &p2, sizeof(POINT4D));
}
LWDEBUGF(3, "Out of loop, ptarray has %d points", dpa->npoints);
return dpa;
}
/**
* @brief Returns a modified #POINTARRAY so that no segment is
* longer than the given distance (computed using 2d).
*
* Every input point is kept.
* Z and M values for added points (if needed) are set to 0.
*/
POINTARRAY *
ptarray_segmentize2d(const POINTARRAY *ipa, double dist)
{
double segdist;
POINT4D p1, p2;
POINT4D pbuf;
POINTARRAY *opa;
int ipoff=0; /* input point offset */
int hasz = FLAGS_GET_Z(ipa->flags);
int hasm = FLAGS_GET_M(ipa->flags);
pbuf.x = pbuf.y = pbuf.z = pbuf.m = 0;
/* Initial storage */
opa = ptarray_construct_empty(hasz, hasm, ipa->npoints);
/* Add first point */
getPoint4d_p(ipa, ipoff, &p1);
ptarray_append_point(opa, &p1, LW_FALSE);
ipoff++;
while (ipoff<ipa->npoints)
{
/*
* We use these pointers to avoid
* "strict-aliasing rules break" warning raised
* by gcc (3.3 and up).
*
* It looks that casting a variable address (also
* referred to as "type-punned pointer")
* breaks those "strict" rules.
*
*/
POINT4D *p1ptr=&p1, *p2ptr=&p2;
getPoint4d_p(ipa, ipoff, &p2);
segdist = distance2d_pt_pt((POINT2D *)p1ptr, (POINT2D *)p2ptr);
if (segdist > dist) /* add an intermediate point */
{
pbuf.x = p1.x + (p2.x-p1.x)/segdist * dist;
pbuf.y = p1.y + (p2.y-p1.y)/segdist * dist;
if( hasz )
pbuf.z = p1.z + (p2.z-p1.z)/segdist * dist;
if( hasm )
pbuf.m = p1.m + (p2.m-p1.m)/segdist * dist;
ptarray_append_point(opa, &pbuf, LW_FALSE);
p1 = pbuf;
}
else /* copy second point */
{
ptarray_append_point(opa, &p2, (ipa->npoints==2)?LW_TRUE:LW_FALSE);
p1 = p2;
ipoff++;
}
}
return opa;
}
int
ptarray_append_ptarray(POINTARRAY *pa1, POINTARRAY *pa2, double gap_tolerance)
{
unsigned int poff = 0;
unsigned int npoints;
unsigned int ncap;
unsigned int ptsize;
/* Check for pathology */
if( ! pa1 || ! pa2 )
{
lwerror("ptarray_append_ptarray: null input");
return LW_FAILURE;
}
npoints = pa2->npoints;
if ( ! npoints ) return LW_SUCCESS; /* nothing more to do */
if( FLAGS_GET_READONLY(pa1->flags) )
{
lwerror("ptarray_append_ptarray: target pointarray is read-only");
return LW_FAILURE;
}
if( FLAGS_GET_ZM(pa1->flags) != FLAGS_GET_ZM(pa2->flags) )
{
lwerror("ptarray_append_ptarray: appending mixed dimensionality is not allowed");
return LW_FAILURE;
}
ptsize = ptarray_point_size(pa1);
/* Check for duplicate end point */
if ( pa1->npoints )
{
POINT2D tmp1, tmp2;
getPoint2d_p(pa1, pa1->npoints-1, &tmp1);
getPoint2d_p(pa2, 0, &tmp2);
/* If the end point and start point are the same, then don't copy start point */
if (p2d_same(&tmp1, &tmp2)) {
poff = 1;
--npoints;
}
else if ( gap_tolerance == 0 || ( gap_tolerance > 0 &&
distance2d_pt_pt(&tmp1, &tmp2) > gap_tolerance ) )
{
lwerror("Second line start point too far from first line end point");
return LW_FAILURE;
}
}
/* Check if we need extra space */
ncap = pa1->npoints + npoints;
if ( pa1->maxpoints < ncap )
{
pa1->maxpoints = ncap > pa1->maxpoints*2 ?
ncap : pa1->maxpoints*2;
pa1->serialized_pointlist = (uint8_t *)lwrealloc(pa1->serialized_pointlist, ptsize * pa1->maxpoints);
}
memcpy(getPoint_internal(pa1, pa1->npoints),
getPoint_internal(pa2, poff), ptsize * npoints);
pa1->npoints = ncap;
return LW_SUCCESS;
}
int
ptarrayarc_contains_point_partial(const POINTARRAY *pa, const POINT2D *pt, int check_closed, int *winding_number)
{
int wn = 0;
int i, side;
const POINT2D *seg1;
const POINT2D *seg2;
const POINT2D *seg3;
GBOX gbox;
/* Check for not an arc ring (always have odd # of points) */
if ( (pa->npoints % 2) == 0 )
{
lwerror("ptarrayarc_contains_point called with even number of points");
return LW_OUTSIDE;
}
/* Check for not an arc ring (always have >= 3 points) */
if ( pa->npoints < 3 )
{
lwerror("ptarrayarc_contains_point called too-short pointarray");
return LW_OUTSIDE;
}
/* Check for unclosed case */
seg1 = getPoint2d_cp(pa, 0);
seg3 = getPoint2d_cp(pa, pa->npoints-1);
if ( check_closed && ! p2d_same(seg1, seg3) )
{
lwerror("ptarrayarc_contains_point called on unclosed ring");
return LW_OUTSIDE;
}
/* OK, it's closed. Is it just one circle? */
else if ( p2d_same(seg1, seg3) && pa->npoints == 3 )
{
double radius, d;
POINT2D c;
seg2 = getPoint2d_cp(pa, 1);
/* Wait, it's just a point, so it can't contain anything */
if ( lw_arc_is_pt(seg1, seg2, seg3) )
return LW_OUTSIDE;
/* See if the point is within the circle radius */
radius = lw_arc_center(seg1, seg2, seg3, &c);
d = distance2d_pt_pt(pt, &c);
if ( FP_EQUALS(d, radius) )
return LW_BOUNDARY; /* Boundary of circle */
else if ( d < radius )
return LW_INSIDE; /* Inside circle */
else
return LW_OUTSIDE; /* Outside circle */
}
else if ( p2d_same(seg1, pt) || p2d_same(seg3, pt) )
{
return LW_BOUNDARY; /* Boundary case */
}
/* Start on the ring */
seg1 = getPoint2d_cp(pa, 0);
for ( i=1; i < pa->npoints; i += 2 )
{
seg2 = getPoint2d_cp(pa, i);
seg3 = getPoint2d_cp(pa, i+1);
/* Catch an easy boundary case */
if( p2d_same(seg3, pt) )
return LW_BOUNDARY;
/* Skip arcs that have no size */
if ( lw_arc_is_pt(seg1, seg2, seg3) )
{
seg1 = seg3;
continue;
}
/* Only test segments in our vertical range */
lw_arc_calculate_gbox_cartesian_2d(seg1, seg2, seg3, &gbox);
if ( pt->y > gbox.ymax || pt->y < gbox.ymin )
{
seg1 = seg3;
continue;
}
/* Outside of horizontal range, and not between end points we also skip */
if ( (pt->x > gbox.xmax || pt->x < gbox.xmin) &&
(pt->y > FP_MAX(seg1->y, seg3->y) || pt->y < FP_MIN(seg1->y, seg3->y)) )
{
seg1 = seg3;
continue;
}
side = lw_arc_side(seg1, seg2, seg3, pt);
/* On the boundary */
if ( (side == 0) && lw_pt_in_arc(pt, seg1, seg2, seg3) )
{
return LW_BOUNDARY;
}
/* Going "up"! Point to left of arc. */
if ( side < 0 && (seg1->y <= pt->y) && (pt->y < seg3->y) )
{
wn++;
}
/* Going "down"! */
if ( side > 0 && (seg2->y <= pt->y) && (pt->y < seg1->y) )
{
wn--;
}
/* Inside the arc! */
if ( pt->x <= gbox.xmax && pt->x >= gbox.xmin )
{
POINT2D C;
double radius = lw_arc_center(seg1, seg2, seg3, &C);
double d = distance2d_pt_pt(pt, &C);
/* On the boundary! */
if ( d == radius )
return LW_BOUNDARY;
/* Within the arc! */
if ( d < radius )
{
/* Left side, increment winding number */
if ( side < 0 )
wn++;
/* Right side, decrement winding number */
if ( side > 0 )
wn--;
}
}
seg1 = seg3;
}
/* Sent out the winding number for calls that are building on this as a primitive */
if ( winding_number )
*winding_number = wn;
/* Outside */
if (wn == 0)
{
return LW_OUTSIDE;
}
/* Inside */
return LW_INSIDE;
}
