ptarrayarc_raycast_intersections()

int ptarrayarc_raycast_intersections	(	const POINTARRAY *	pa,
		const POINT2D *	p,
		int *	on_boundary
	)

Definition at line 935 of file ptarray.c.

{
        int intersections = 0;
        double px = p->x;
        double py = p->y;
 
        assert(on_boundary);
 
        // A valid circular arc must have at least 3 vertices (circle).
        if (pa->npoints < 3)
                lwerror("%s called on invalid circularstring", __func__);
 
        if (pa->npoints % 2 == 0)
                lwerror("%s called with even number of points", __func__);
 
        // Iterate through each arc of the circularstring
        for (uint32_t i = 1; i < pa->npoints-1; i +=2)
        {
                const POINT2D* p0 = getPoint2d_cp(pa, i-1);
                const POINT2D* p1 = getPoint2d_cp(pa, i);
                const POINT2D* p2 = getPoint2d_cp(pa, i+1);
                POINT2D center = {0,0};
                double radius, d;
                GBOX gbox;
 
                // Skip zero-length arc
                if (lw_arc_is_pt(p0, p1, p2))
                        continue;
 
                // --- Step 1: Check if the point is ON the boundary edge ---
                if (p2d_same(p0, p) || p2d_same(p1, p) || p2d_same(p2, p))
                {
                        *on_boundary = LW_TRUE;
                        return 0;
                }
 
                // Calculate some important pieces
                radius = lw_arc_center(p0, p1, p2, &center);
 
                d = distance2d_pt_pt(p, &center);
                if (FP_EQUALS(d, radius) && lw_pt_in_arc(p, p0, p1, p2))
                {
                        *on_boundary = LW_TRUE;
                        return 0;
                }
 
                // --- Step 2: Perform the Ray Casting intersection test ---
 
                // Only process arcs that our ray crosses
                lw_arc_calculate_gbox_cartesian_2d(p0, p1, p2, &gbox);
                if ((gbox.ymin <= py) && (py < gbox.ymax))
                {
                        // Point of intersection on the circle that defines the arc
                        POINT2D i0, i1;
 
                        // How many points of intersection are there
                        int iCount = circle_raycast_intersections(&center, radius, py, &i0, &i1);
 
                        // Nothing to see here
                        if (iCount == 0)
                                continue;
 
                        // Cannot think of a case where a grazing is not a
                        // no-op
                        if (iCount == 1)
                                continue;
 
                        // So we must have 2 intersections
                        // Only increment the counter for intersections to the right
                        // of the test point
                        if (i0.x > px && lw_pt_in_arc(&i0, p0, p1, p2))
                                intersections++;
 
                        if (i1.x > px && lw_pt_in_arc(&i1, p0, p1, p2))
                                intersections++;
                }
        }
 
        return intersections;
}

References circle_raycast_intersections(), distance2d_pt_pt(), FP_EQUALS, getPoint2d_cp(), lw_arc_calculate_gbox_cartesian_2d(), lw_arc_center(), lw_arc_is_pt(), lw_pt_in_arc(), LW_TRUE, lwerror(), POINTARRAY::npoints, p2d_same(), POINT2D::x, 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: