ptarrayarc_contains_point_partial()

int ptarrayarc_contains_point_partial	(	const POINTARRAY *	pa,
		const POINT2D *	pt,
		int	check_closed,
		int *	winding_number
	)

Definition at line 862 of file ptarray.c.

{
        int wn = 0;
        uint32_t i;
        int 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 && (seg3->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;
}

References distance2d_pt_pt(), FP_EQUALS, FP_MAX, FP_MIN, getPoint2d_cp(), lw_arc_calculate_gbox_cartesian_2d(), lw_arc_center(), lw_arc_is_pt(), lw_arc_side(), LW_BOUNDARY, LW_INSIDE, LW_OUTSIDE, lw_pt_in_arc(), lwerror(), POINTARRAY::npoints, p2d_same(), POINT2D::x, GBOX::xmax, GBOX::xmin, POINT2D::y, GBOX::ymax, and GBOX::ymin.

Referenced by lwcompound_contains_point(), and ptarrayarc_contains_point().

Here is the call graph for this function:

Here is the caller graph for this function: