lw_dist3d_ptarray_poly()

int lw_dist3d_ptarray_poly	(	const POINTARRAY *	pa,
		const LWPOLY *	poly,
		PLANE3D *	plane,
		DISTPTS3D *	dl
	)

Computes pointarray to polygon distance.

Definition at line 1333 of file measures3d.c.

{
        uint32_t i, j, k;
        double f, s1, s2;
        VECTOR3D projp1_projp2;
        POINT3DZ p1, p2, projp1, projp2, intersectionp;
 
        getPoint3dz_p(pa, 0, &p1);
 
        /* the sign of s1 tells us on which side of the plane the point is. */
        s1 = project_point_on_plane(&p1, plane, &projp1);
        lw_dist3d_pt_poly(&p1, poly, plane, &projp1, dl);
        if ((s1 == 0.0) && (dl->distance < dl->tolerance))
                return LW_TRUE;
 
        for (i = 1; i < pa->npoints; i++)
        {
                int intersects;
                getPoint3dz_p(pa, i, &p2);
                s2 = project_point_on_plane(&p2, plane, &projp2);
                lw_dist3d_pt_poly(&p2, poly, plane, &projp2, dl);
                if ((s2 == 0.0) && (dl->distance < dl->tolerance))
                        return LW_TRUE;
 
                /* If s1 and s2 has different signs that means they are on different sides of the plane of the polygon.
                 * That means that the edge between the points crosses the plane and might intersect with the polygon */
                if ((s1 * s2) < 0)
                {
                        /* The size of s1 and s2 is the distance from the point to the plane. */
                        f = fabs(s1) / (fabs(s1) + fabs(s2));
                        get_3dvector_from_points(&projp1, &projp2, &projp1_projp2);
 
                        /* Get the point where the line segment crosses the plane */
                        intersectionp.x = projp1.x + f * projp1_projp2.x;
                        intersectionp.y = projp1.y + f * projp1_projp2.y;
                        intersectionp.z = projp1.z + f * projp1_projp2.z;
 
                        /* We set intersects to true until the opposite is proved */
                        intersects = LW_TRUE;
 
                        if (pt_in_ring_3d(&intersectionp, poly->rings[0], plane)) /*Inside outer ring*/
                        {
                                for (k = 1; k < poly->nrings; k++)
                                {
                                        /* Inside a hole, so no intersection with the polygon*/
                                        if (pt_in_ring_3d(&intersectionp, poly->rings[k], plane))
                                        {
                                                intersects = LW_FALSE;
                                                break;
                                        }
                                }
                                if (intersects)
                                {
                                        dl->distance = 0.0;
                                        dl->p1.x = intersectionp.x;
                                        dl->p1.y = intersectionp.y;
                                        dl->p1.z = intersectionp.z;
 
                                        dl->p2.x = intersectionp.x;
                                        dl->p2.y = intersectionp.y;
                                        dl->p2.z = intersectionp.z;
                                        return LW_TRUE;
                                }
                        }
                }
 
                projp1 = projp2;
                s1 = s2;
                p1 = p2;
        }
 
        /* check our pointarray against boundary and inner boundaries of the polygon */
        for (j = 0; j < poly->nrings; j++)
                lw_dist3d_ptarray_ptarray(pa, poly->rings[j], dl);
 
        return LW_TRUE;
}

References DISTPTS3D::distance, get_3dvector_from_points(), getPoint3dz_p(), lw_dist3d_pt_poly(), lw_dist3d_ptarray_ptarray(), LW_FALSE, LW_TRUE, POINTARRAY::npoints, LWPOLY::nrings, DISTPTS3D::p1, DISTPTS3D::p2, project_point_on_plane(), pt_in_ring_3d(), LWPOLY::rings, DISTPTS3D::tolerance, POINT3DZ::x, VECTOR3D::x, POINT3DZ::y, VECTOR3D::y, POINT3DZ::z, and VECTOR3D::z.

Referenced by lw_dist3d_line_poly(), lw_dist3d_poly_poly(), and lw_dist3d_poly_tri().

Here is the call graph for this function:

Here is the caller graph for this function: