clip_seg_by_m_range()

static int clip_seg_by_m_range ( POINT4D *  p1, POINT4D *  p2, double  m0, double  m1  )

static

Definition at line 303 of file lwgeom_functions_lrs.c.

{
        double dM0, dM1, dX, dY, dZ;
        POINT4D *tmp;
        int swapped=0;
        int ret=0;
 
        POSTGIS_DEBUGF(3, "m0: %g m1: %g", m0, m1);
 
        /* Handle corner case of m values being the same */
        if ( p1->m == p2->m )
        {
                /* out of range, no clipping */
                if ( p1->m < m0 || p1->m > m1 )
                        return 0;
 
                /* inside range, no clipping */
                return 1;
        }
 
        /*
         * Order points so that p1 has the smaller M
         */
        if ( p1->m > p2->m )
        {
                tmp=p2;
                p2=p1;
                p1=tmp;
                swapped=1;
        }
 
        /*
         * The M range is not intersected, segment
         * fully out of range, no clipping.
         */
        if ( p2->m < m0 || p1->m > m1 )
                return 0;
 
        /*
         * The segment is fully inside the range,
         * no clipping.
         */
        if ( p1->m >= m0 && p2->m <= m1 )
                return 1;
 
        /*
         * Segment intersects range, lets compute
         * the proportional location of the two
         * measures wrt p1/p2 m range.
         *
         * if p1 and p2 have the same measure
         * this should never be reached (either
         * both inside or both outside)
         *
         */
        dM0=(m0-p1->m)/(p2->m-p1->m); /* delta-M0 */
        dM1=(m1-p2->m)/(p2->m-p1->m); /* delta-M1 */
        dX=p2->x-p1->x;
        dY=p2->y-p1->y;
        dZ=p2->z-p1->z;
 
        POSTGIS_DEBUGF(3, "dM0:%g dM1:%g", dM0, dM1);
        POSTGIS_DEBUGF(3, "dX:%g dY:%g dZ:%g", dX, dY, dZ);
        POSTGIS_DEBUGF(3, "swapped: %d", swapped);
 
        /*
         * First point out of range, project
         * it on the range
         */
        if ( p1->m < m0 )
        {
                /*
                 * To prevent rounding errors, then if m0==m1 and p2 lies within the range, copy
                 * p1 as a direct copy of p2
                 */
                if (m0 == m1 && p2->m <= m1)
                {
                        memcpy(p1, p2, sizeof(POINT4D));
 
                        POSTGIS_DEBUG(3, "Projected p1 on range (as copy of p2)");
                }
                else
                {
                        /* Otherwise interpolate coordinates */
                        p1->x += (dX*dM0);
                        p1->y += (dY*dM0);
                        p1->z += (dZ*dM0);
                        p1->m = m0;
 
                        POSTGIS_DEBUG(3, "Projected p1 on range");
                }
 
                if ( swapped ) ret |= 0x0100;
                else ret |= 0x0010;
        }
 
        /*
         * Second point out of range, project
         * it on the range
         */
        if ( p2->m > m1 )
        {
                /*
                 * To prevent rounding errors, then if m0==m1 and p1 lies within the range, copy
                 * p2 as a direct copy of p1
                 */
                if (m0 == m1 && p1->m >= m0)
                {
                        memcpy(p2, p1, sizeof(POINT4D));
 
                        POSTGIS_DEBUG(3, "Projected p2 on range (as copy of p1)");
                }
                else
                {
                        /* Otherwise interpolate coordinates */
                        p2->x += (dX*dM1);
                        p2->y += (dY*dM1);
                        p2->z += (dZ*dM1);
                        p2->m = m1;
 
                        POSTGIS_DEBUG(3, "Projected p2 on range");
                }
 
                if ( swapped ) ret |= 0x0010;
                else ret |= 0x0100;
        }
 
        /* Clipping occurred */
        return ret;
 
}

References POINT4D::m, POINT4D::x, POINT4D::y, and POINT4D::z.

Referenced by ptarray_locate_between_m().

Here is the caller graph for this function: