lwpoly_split_by_line()

static LWGEOM * lwpoly_split_by_line ( const LWPOLY *  lwgeom_in, const LWLINE *  blade_in  )

static

Definition at line 345 of file lwgeom_geos_split.c.

References COLLECTIONTYPE, contains(), LWPOLY::flags, FLAGS_GET_Z, LWCOLLECTION::geoms, GEOS2LWGEOM(), lwcollection_construct_empty(), lwerror(), LWGEOM2GEOS(), lwgeom_geos_errmsg, lwgeom_geos_error(), lwrealloc(), LWCOLLECTION::ngeoms, and LWGEOM::srid.

Referenced by lwpoly_split().

{
        LWCOLLECTION* out;
        GEOSGeometry* g1;
        GEOSGeometry* g2;
        GEOSGeometry* g1_bounds;
        GEOSGeometry* polygons;
        const GEOSGeometry *vgeoms[1];
        int i,n;
        int hasZ = FLAGS_GET_Z(lwpoly_in->flags);


        /* Possible outcomes:
         *
         *  1. The line does not split the polygon
         *      -> Return a collection with single element
         *  2. The line does split the polygon
         *      -> Return a collection of all elements resulting from the split
         */

        initGEOS(lwgeom_geos_error, lwgeom_geos_error);

        g1 = LWGEOM2GEOS((LWGEOM*)lwpoly_in, 0);
        if ( NULL == g1 )
        {
                lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
                return NULL;
        }
        g1_bounds = GEOSBoundary(g1);
        if ( NULL == g1_bounds )
        {
                GEOSGeom_destroy(g1);
                lwerror("GEOSBoundary: %s", lwgeom_geos_errmsg);
                return NULL;
        }

        g2 = LWGEOM2GEOS((LWGEOM*)blade_in, 0);
        if ( NULL == g2 )
        {
                GEOSGeom_destroy(g1);
                GEOSGeom_destroy(g1_bounds);
                lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
                return NULL;
        }

        vgeoms[0] = GEOSUnion(g1_bounds, g2);
        if ( NULL == vgeoms[0] )
        {
                GEOSGeom_destroy(g1);
                GEOSGeom_destroy(g2);
                GEOSGeom_destroy(g1_bounds);
                lwerror("GEOSUnion: %s", lwgeom_geos_errmsg);
                return NULL;
        }

        polygons = GEOSPolygonize(vgeoms, 1);
        if ( NULL == polygons )
        {
                GEOSGeom_destroy(g1);
                GEOSGeom_destroy(g2);
                GEOSGeom_destroy(g1_bounds);
                GEOSGeom_destroy((GEOSGeometry*)vgeoms[0]);
                lwerror("GEOSPolygonize: %s", lwgeom_geos_errmsg);
                return NULL;
        }

#if PARANOIA_LEVEL > 0
        if ( GEOSGeomTypeId(polygons) != COLLECTIONTYPE )
        {
                GEOSGeom_destroy(g1);
                GEOSGeom_destroy(g2);
                GEOSGeom_destroy(g1_bounds);
                GEOSGeom_destroy((GEOSGeometry*)vgeoms[0]);
                GEOSGeom_destroy(polygons);
                lwerror("%s [%s] Unexpected return from GEOSpolygonize", __FILE__, __LINE__);
                return 0;
        }
#endif

        /* We should now have all polygons, just skip
         * the ones which are in holes of the original
         * geometries and return the rest in a collection
         */
        n = GEOSGetNumGeometries(polygons);
        out = lwcollection_construct_empty(COLLECTIONTYPE, lwpoly_in->srid,
                                     hasZ, 0);
        /* Allocate space for all polys */
        out->geoms = lwrealloc(out->geoms, sizeof(LWGEOM*)*n);
        assert(0 == out->ngeoms);
        for (i=0; i<n; ++i)
        {
                GEOSGeometry* pos; /* point on surface */
                const GEOSGeometry* p = GEOSGetGeometryN(polygons, i);
                int contains;

                pos = GEOSPointOnSurface(p);
                if ( ! pos )
                {
                        GEOSGeom_destroy(g1);
                        GEOSGeom_destroy(g2);
                        GEOSGeom_destroy(g1_bounds);
                        GEOSGeom_destroy((GEOSGeometry*)vgeoms[0]);
                        GEOSGeom_destroy(polygons);
                        lwerror("GEOSPointOnSurface: %s", lwgeom_geos_errmsg);
                        return NULL;
                }

                contains = GEOSContains(g1, pos);
                if ( 2 == contains )
                {
                        GEOSGeom_destroy(g1);
                        GEOSGeom_destroy(g2);
                        GEOSGeom_destroy(g1_bounds);
                        GEOSGeom_destroy((GEOSGeometry*)vgeoms[0]);
                        GEOSGeom_destroy(polygons);
                        GEOSGeom_destroy(pos);
                        lwerror("GEOSContains: %s", lwgeom_geos_errmsg);
                        return NULL;
                }

                GEOSGeom_destroy(pos);

                if ( 0 == contains )
                {
                        /* Original geometry doesn't contain
                         * a point in this ring, must be an hole
                         */
                        continue;
                }

                out->geoms[out->ngeoms++] = GEOS2LWGEOM(p, hasZ);
        }

        GEOSGeom_destroy(g1);
        GEOSGeom_destroy(g2);
        GEOSGeom_destroy(g1_bounds);
        GEOSGeom_destroy((GEOSGeometry*)vgeoms[0]);
        GEOSGeom_destroy(polygons);

        return (LWGEOM*)out;
}

Here is the call graph for this function:

Here is the caller graph for this function: