pt_in_ring_3d()

int pt_in_ring_3d	(	const POINT3DZ *	p,
		const POINTARRAY *	ring,
		PLANE3D *	plane
	)

pt_in_ring_3d(): crossing number test for a point in a polygon input: p = a point, pa = vertex points of a ring V[n+1] with V[n]=V[0] plane=the plane that the vertex points are lying on returns: 0 = outside, 1 = inside

Our polygons have first and last point the same,

The difference in 3D variant is that we exclude the dimension that faces the plane least. That is the dimension with the highest number in pv

Definition at line 1277 of file measures3d.c.

{
 
        uint32_t cn = 0;    /* the crossing number counter */
        uint32_t i;
        POINT3DZ v1, v2;
 
        POINT3DZ        first, last;
 
        getPoint3dz_p(ring, 0, &first);
        getPoint3dz_p(ring, ring->npoints-1, &last);
        if ( memcmp(&first, &last, sizeof(POINT3DZ)) )
        {
                lwerror("pt_in_ring_3d: V[n] != V[0] (%g %g %g!= %g %g %g)",
                        first.x, first.y, first.z, last.x, last.y, last.z);
                return LW_FALSE;
        }
 
        LWDEBUGF(2, "pt_in_ring_3d called with point: %g %g %g", p->x, p->y, p->z);
        /* printPA(ring); */
 
        /* loop through all edges of the polygon */
        getPoint3dz_p(ring, 0, &v1);
 
 
        if(fabs(plane->pv.z)>=fabs(plane->pv.x)&&fabs(plane->pv.z)>=fabs(plane->pv.y))  /*If the z vector of the normal vector to the plane is larger than x and y vector we project the ring to the xy-plane*/
        {
                for (i=0; i<ring->npoints-1; i++)
                {
                        double vt;
                        getPoint3dz_p(ring, i+1, &v2);
 
                        /* edge from vertex i to vertex i+1 */
                        if
                        (
                            /* an upward crossing */
                            ((v1.y <= p->y) && (v2.y > p->y))
                            /* a downward crossing */
                            || ((v1.y > p->y) && (v2.y <= p->y))
                        )
                        {
 
                                vt = (double)(p->y - v1.y) / (v2.y - v1.y);
 
                                /* P.x <intersect */
                                if (p->x < v1.x + vt * (v2.x - v1.x))
                                {
                                        /* a valid crossing of y=p.y right of p.x */
                                        ++cn;
                                }
                        }
                        v1 = v2;
                }
        }
        else if(fabs(plane->pv.y)>=fabs(plane->pv.x)&&fabs(plane->pv.y)>=fabs(plane->pv.z))     /*If the y vector of the normal vector to the plane is larger than x and z vector we project the ring to the xz-plane*/
        {
                for (i=0; i<ring->npoints-1; i++)
                        {
                                double vt;
                                getPoint3dz_p(ring, i+1, &v2);
 
                                /* edge from vertex i to vertex i+1 */
                                if
                                (
                                    /* an upward crossing */
                                    ((v1.z <= p->z) && (v2.z > p->z))
                                    /* a downward crossing */
                                    || ((v1.z > p->z) && (v2.z <= p->z))
                                )
                                {
 
                                        vt = (double)(p->z - v1.z) / (v2.z - v1.z);
 
                                        /* P.x <intersect */
                                        if (p->x < v1.x + vt * (v2.x - v1.x))
                                        {
                                                /* a valid crossing of y=p.y right of p.x */
                                                ++cn;
                                        }
                                }
                                v1 = v2;
                        }
        }
        else    /*Hopefully we only have the cases where x part of the normal vector is largest left*/
        {
                for (i=0; i<ring->npoints-1; i++)
                        {
                                double vt;
                                getPoint3dz_p(ring, i+1, &v2);
 
                                /* edge from vertex i to vertex i+1 */
                                if
                                (
                                    /* an upward crossing */
                                    ((v1.z <= p->z) && (v2.z > p->z))
                                    /* a downward crossing */
                                    || ((v1.z > p->z) && (v2.z <= p->z))
                                )
                                {
 
                                        vt = (double)(p->z - v1.z) / (v2.z - v1.z);
 
                                        /* P.x <intersect */
                                        if (p->y < v1.y + vt * (v2.y - v1.y))
                                        {
                                                /* a valid crossing of y=p.y right of p.x */
                                                ++cn;
                                        }
                                }
                                v1 = v2;
                        }
        }
        LWDEBUGF(3, "pt_in_ring_3d returning %d", cn&1);
 
        return (cn&1);    /* 0 if even (out), and 1 if odd (in) */
}

References getPoint3dz_p(), LW_FALSE, LWDEBUGF, lwerror(), POINTARRAY::npoints, PLANE3D::pv, POINT3DZ::x, VECTOR3D::x, POINT3DZ::y, VECTOR3D::y, POINT3DZ::z, and VECTOR3D::z.

Referenced by lw_dist3d_pt_poly(), and lw_dist3d_ptarray_poly().

Here is the call graph for this function:

Here is the caller graph for this function: