lwline_split_by_point_to()

int lwline_split_by_point_to	(	const LWLINE *	ln,
		const LWPOINT *	pt,
		LWMLINE *	to
	)

Split a line by a point and push components to the provided multiline.

If the point doesn't split the line, push nothing to the container. Returns 0 if the point is off the line. Returns 1 if the point is on the line boundary (endpoints). Return 2 if the point is on the interior of the line (only case in which a split happens).

NOTE: the components pushed to the output vector have their SRID stripped

Definition at line 209 of file lwgeom_geos_split.c.

{
        double mindist = -1;
        POINT4D pt, pt_projected;
        POINT4D p1, p2;
        POINTARRAY *ipa = lwline_in->points;
        POINTARRAY* pa1;
        POINTARRAY* pa2;
        uint32_t i, nsegs, seg = UINT32_MAX;
 
        /* Possible outcomes:
         *
         *  1. The point is not on the line or on the boundary
         *      -> Leave collection untouched, return 0
         *  2. The point is on the boundary
         *      -> Leave collection untouched, return 1
         *  3. The point is in the line
         *      -> Push 2 elements on the collection:
         *         o start_point - cut_point
         *         o cut_point - last_point
         *      -> Return 2
         */
 
        getPoint4d_p(blade_in->point, 0, &pt);
 
        /* Find closest segment */
        if ( ipa->npoints < 1 ) return 0; /* empty input line */
        getPoint4d_p(ipa, 0, &p1);
        nsegs = ipa->npoints - 1;
        for ( i = 0; i < nsegs; i++ )
        {
                getPoint4d_p(ipa, i+1, &p2);
                double dist;
                dist = distance2d_pt_seg((POINT2D*)&pt, (POINT2D*)&p1, (POINT2D*)&p2);
                LWDEBUGF(4, " Distance of point %g %g to segment %g %g, %g %g: %g", pt.x, pt.y, p1.x, p1.y, p2.x, p2.y, dist);
                if (i==0 || dist < mindist )
                {
                        mindist = dist;
                        seg=i;
                        if ( mindist == 0.0 ) break; /* can't be closer than ON line */
                }
                p1 = p2;
        }
 
        LWDEBUGF(3, "Closest segment: %d", seg);
        LWDEBUGF(3, "mindist: %g", mindist);
 
        /* No intersection */
        if ( mindist > 0 ) return 0;
 
        /* empty or single-point line, intersection on boundary */
        if ( seg == UINT32_MAX ) return 1;
 
        /*
         * We need to project the
         * point on the closest segment,
         * to interpolate Z and M if needed
         */
        getPoint4d_p(ipa, seg, &p1);
        getPoint4d_p(ipa, seg+1, &p2);
        closest_point_on_segment(&pt, &p1, &p2, &pt_projected);
        /* But X and Y we want the ones of the input point,
         * as on some architectures the interpolation math moves the
         * coordinates (see #3422)
         */
        pt_projected.x = pt.x;
        pt_projected.y = pt.y;
 
        LWDEBUGF(3, "Projected point:(%g %g), seg:%d, p1:(%g %g), p2:(%g %g)", pt_projected.x, pt_projected.y, seg, p1.x, p1.y, p2.x, p2.y);
 
        /* When closest point == an endpoint, this is a boundary intersection */
        if ( ( (seg == nsegs-1) && p4d_same(&pt_projected, &p2) ) ||
             ( (seg == 0)       && p4d_same(&pt_projected, &p1) ) )
        {
                return 1;
        }
 
        /* This is an internal intersection, let's build the two new pointarrays */
 
        pa1 = ptarray_construct_empty(FLAGS_GET_Z(ipa->flags), FLAGS_GET_M(ipa->flags), seg+2);
        /* TODO: replace with a memcpy ? */
        for (i=0; i<=seg; ++i)
        {
                getPoint4d_p(ipa, i, &p1);
                ptarray_append_point(pa1, &p1, LW_FALSE);
        }
        ptarray_append_point(pa1, &pt_projected, LW_FALSE);
 
        pa2 = ptarray_construct_empty(FLAGS_GET_Z(ipa->flags), FLAGS_GET_M(ipa->flags), ipa->npoints-seg);
        ptarray_append_point(pa2, &pt_projected, LW_FALSE);
        /* TODO: replace with a memcpy (if so need to check for duplicated point) ? */
        for (i=seg+1; i<ipa->npoints; ++i)
        {
                getPoint4d_p(ipa, i, &p1);
                ptarray_append_point(pa2, &p1, LW_FALSE);
        }
 
        /* NOTE: I've seen empty pointarrays with loc != 0 and loc != 1 */
        if ( pa1->npoints == 0 || pa2->npoints == 0 ) {
                ptarray_free(pa1);
                ptarray_free(pa2);
                /* Intersection is on the boundary */
                return 1;
        }
 
        lwmline_add_lwline(v, lwline_construct(SRID_UNKNOWN, NULL, pa1));
        lwmline_add_lwline(v, lwline_construct(SRID_UNKNOWN, NULL, pa2));
        return 2;
}

References closest_point_on_segment(), distance2d_pt_seg(), POINTARRAY::flags, FLAGS_GET_M, FLAGS_GET_Z, getPoint4d_p(), LW_FALSE, LWDEBUGF, lwline_construct(), lwmline_add_lwline(), POINTARRAY::npoints, p4d_same(), LWPOINT::point, LWLINE::points, ptarray_append_point(), ptarray_construct_empty(), ptarray_free(), SRID_UNKNOWN, UINT32_MAX, POINT2D::x, POINT4D::x, POINT2D::y, and POINT4D::y.

Referenced by lwgeom_node(), lwline_split_by_mpoint(), lwline_split_by_point(), and test_lwline_split_by_point_to().

Here is the call graph for this function:

Here is the caller graph for this function: