LWGEOM2GEOS()

GEOSGeometry * LWGEOM2GEOS	(	const LWGEOM *	g,
		uint8_t	autofix
	)

Definition at line 390 of file liblwgeom/lwgeom_geos.c.

{
        GEOSCoordSeq sq;
        GEOSGeom g, shell;
        GEOSGeom* geoms = NULL;
        uint32_t ngeoms, i, j;
        int geostype;
#if LWDEBUG_LEVEL >= 4
        char* wkt;
#endif
 
        if (autofix)
        {
                /* cross fingers and try without autofix, maybe it'll work? */
                g = LWGEOM2GEOS(lwgeom, LW_FALSE);
                if (g) return g;
        }
 
        LWDEBUGF(4, "LWGEOM2GEOS got a %s", lwtype_name(lwgeom->type));
 
        if (lwgeom_has_arc(lwgeom))
        {
                LWGEOM* lwgeom_stroked = lwgeom_stroke(lwgeom, 32);
                GEOSGeometry* g = LWGEOM2GEOS(lwgeom_stroked, autofix);
                lwgeom_free(lwgeom_stroked);
                return g;
        }
 
        LWPOINT* lwp = NULL;
        LWPOLY* lwpoly = NULL;
        LWLINE* lwl = NULL;
        LWCOLLECTION* lwc = NULL;
 
        switch (lwgeom->type)
        {
        case POINTTYPE:
                lwp = (LWPOINT*)lwgeom;
 
                if (lwgeom_is_empty(lwgeom))
                        g = GEOSGeom_createEmptyPolygon();
                else
                {
#if POSTGIS_GEOS_VERSION < 38
                        sq = ptarray_to_GEOSCoordSeq(lwp->point, 0);
                        g = GEOSGeom_createPoint(sq);
#else
                        if (lwgeom_has_z(lwgeom))
                        {
                                sq = ptarray_to_GEOSCoordSeq(lwp->point, 0);
                                g = GEOSGeom_createPoint(sq);
                        }
                        else
                        {
                                const POINT2D* p = getPoint2d_cp(lwp->point, 0);
                                g = GEOSGeom_createPointFromXY(p->x, p->y);
                        }
#endif
                }
                if (!g) return NULL;
                break;
 
        case LINETYPE:
                lwl = (LWLINE*)lwgeom;
                /* TODO: if (autofix) */
                if (lwl->points->npoints == 1)
                {
                        /* Duplicate point, to make geos-friendly */
                        lwl->points = ptarray_addPoint(lwl->points,
                                                       getPoint_internal(lwl->points, 0),
                                                       FLAGS_NDIMS(lwl->points->flags),
                                                       lwl->points->npoints);
                }
                sq = ptarray_to_GEOSCoordSeq(lwl->points, 0);
                g = GEOSGeom_createLineString(sq);
                if (!g) return NULL;
                break;
 
        case POLYGONTYPE:
                lwpoly = (LWPOLY*)lwgeom;
                if (lwgeom_is_empty(lwgeom))
                        g = GEOSGeom_createEmptyPolygon();
                else
                {
                        shell = ptarray_to_GEOSLinearRing(lwpoly->rings[0], autofix);
                        if (!shell) return NULL;
                        ngeoms = lwpoly->nrings - 1;
                        if (ngeoms > 0) geoms = lwalloc(sizeof(GEOSGeom) * ngeoms);
 
                        for (i = 1; i < lwpoly->nrings; i++)
                        {
                                geoms[i - 1] = ptarray_to_GEOSLinearRing(lwpoly->rings[i], autofix);
                                if (!geoms[i - 1])
                                {
                                        uint32_t k;
                                        for (k = 0; k < i - 1; k++)
                                                GEOSGeom_destroy(geoms[k]);
                                        lwfree(geoms);
                                        GEOSGeom_destroy(shell);
                                        return NULL;
                                }
                        }
                        g = GEOSGeom_createPolygon(shell, geoms, ngeoms);
                        if (geoms) lwfree(geoms);
                }
                if (!g) return NULL;
                break;
 
        case TRIANGLETYPE:
                if (lwgeom_is_empty(lwgeom))
                        g = GEOSGeom_createEmptyPolygon();
                else
                {
                        LWTRIANGLE *lwt = (LWTRIANGLE *)lwgeom;
                        shell = ptarray_to_GEOSLinearRing(lwt->points, autofix);
                        if (!shell)
                                return NULL;
                        g = GEOSGeom_createPolygon(shell, NULL, 0);
                }
                if (!g)
                        return NULL;
                break;
        case MULTIPOINTTYPE:
        case MULTILINETYPE:
        case MULTIPOLYGONTYPE:
        case TINTYPE:
        case COLLECTIONTYPE:
                if (lwgeom->type == MULTIPOINTTYPE)
                        geostype = GEOS_MULTIPOINT;
                else if (lwgeom->type == MULTILINETYPE)
                        geostype = GEOS_MULTILINESTRING;
                else if (lwgeom->type == MULTIPOLYGONTYPE)
                        geostype = GEOS_MULTIPOLYGON;
                else
                        geostype = GEOS_GEOMETRYCOLLECTION;
 
                lwc = (LWCOLLECTION*)lwgeom;
 
                ngeoms = lwc->ngeoms;
                if (ngeoms > 0) geoms = lwalloc(sizeof(GEOSGeom) * ngeoms);
 
                j = 0;
                for (i = 0; i < ngeoms; ++i)
                {
                        GEOSGeometry* g;
 
                        if (lwgeom_is_empty(lwc->geoms[i])) continue;
 
                        g = LWGEOM2GEOS(lwc->geoms[i], 0);
                        if (!g)
                        {
                                uint32_t k;
                                for (k = 0; k < j; k++)
                                        GEOSGeom_destroy(geoms[k]);
                                lwfree(geoms);
                                return NULL;
                        }
                        geoms[j++] = g;
                }
                g = GEOSGeom_createCollection(geostype, geoms, j);
                if (ngeoms > 0) lwfree(geoms);
                if (!g) return NULL;
                break;
 
        default:
                lwerror("Unknown geometry type: %d - %s", lwgeom->type, lwtype_name(lwgeom->type));
                return NULL;
        }
 
        GEOSSetSRID(g, lwgeom->srid);
 
#if LWDEBUG_LEVEL >= 4
        wkt = GEOSGeomToWKT(g);
        LWDEBUGF(4, "LWGEOM2GEOS: GEOSGeom: %s", wkt);
        free(wkt);
#endif
 
        return g;
}

References COLLECTIONTYPE, POINTARRAY::flags, FLAGS_NDIMS, free(), LWCOLLECTION::geoms, getPoint2d_cp(), getPoint_internal(), LINETYPE, LW_FALSE, lwalloc(), LWDEBUGF, lwerror(), lwfree(), LWGEOM2GEOS(), lwgeom_free(), lwgeom_has_arc(), lwgeom_has_z(), lwgeom_is_empty(), lwgeom_stroke(), lwtype_name(), MULTILINETYPE, MULTIPOINTTYPE, MULTIPOLYGONTYPE, LWCOLLECTION::ngeoms, POINTARRAY::npoints, LWPOLY::nrings, LWPOINT::point, LWLINE::points, LWTRIANGLE::points, POINTTYPE, POLYGONTYPE, ptarray_addPoint(), ptarray_to_GEOSCoordSeq(), ptarray_to_GEOSLinearRing(), LWPOLY::rings, LWGEOM::srid, TINTYPE, TRIANGLETYPE, LWGEOM::type, POINT2D::x, and POINT2D::y.

Referenced by _lwt_CheckEdgeCrossing(), _lwt_FindFaceContainingRing(), _lwt_GetEqualEdge(), boundary(), isvalid(), LWGEOM2GEOS(), lwgeom_buildarea(), lwgeom_centroid(), lwgeom_clip_by_rect(), lwgeom_delaunay_triangulation(), lwgeom_difference(), lwgeom_extract_unique_endpoints(), lwgeom_geos_noop(), lwgeom_intersection(), lwgeom_is_simple(), lwgeom_linemerge(), lwgeom_make_valid(), lwgeom_node(), lwgeom_normalize(), lwgeom_pointonsurface(), lwgeom_sharedpaths(), lwgeom_snap(), lwgeom_symdifference(), lwgeom_unaryunion(), lwgeom_union(), LWGEOMARRAY2GEOS(), lwline_offsetcurve(), lwline_split_by_line(), lwpoly_split_by_line(), lwpoly_to_points(), lwt_AddPolygon(), mvt_grid_and_validate_geos(), mvt_safe_clip_polygon_by_box(), pgis_geometry_union_finalfn(), POSTGIS2GEOS(), PrepGeomCacheBuilder(), rt_raster_compute_skewed_raster(), rt_raster_gdal_polygonize(), rt_raster_geos_spatial_relationship(), rt_raster_intersects(), rt_raster_surface(), and topologypreservesimplify().

Here is the call graph for this function:

Here is the caller graph for this function: