LWGEOM2GEOS()

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

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

{
        GEOSCoordSeq sq;
        GEOSGeom g, shell;
        GEOSGeom* geoms = NULL;
        uint32_t ngeoms, i, j;
        int is_empty = LW_FALSE;
#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_type_arc(lwgeom))
        {
                LWGEOM* lwgeom_stroked = lwgeom_stroke(lwgeom, 32);
                GEOSGeometry* g = LWGEOM2GEOS(lwgeom_stroked, autofix);
                lwgeom_free(lwgeom_stroked);
                return g;
        }
 
        is_empty = lwgeom_is_empty(lwgeom);
 
        switch (lwgeom->type)
        {
                case POINTTYPE:
                {
                        if (is_empty)
                                g = GEOSGeom_createEmptyPoint();
                        else
                        {
                                LWPOINT* lwp = (LWPOINT*)lwgeom;
                                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);
                                }
                        }
                        if (!g) return NULL;
                        break;
                }
 
                case LINETYPE:
                {
                        if (is_empty)
                                g = GEOSGeom_createEmptyLineString();
                        else
                        {
                                LWLINE* 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 = (LWPOLY*)lwgeom;
                        if (is_empty)
                                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 (is_empty)
                                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:
                {
                        int geostype;
                        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;
 
                        LWCOLLECTION* 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);
        GEOSFree(wkt);
#endif
 
        return g;
}

References COLLECTIONTYPE, POINTARRAY::flags, FLAGS_NDIMS, LWCOLLECTION::geoms, getPoint2d_cp(), getPoint_internal(), LINETYPE, LW_FALSE, lwalloc(), LWDEBUGF, lwerror(), lwfree(), LWGEOM2GEOS(), lwgeom_free(), lwgeom_has_z(), lwgeom_is_empty(), lwgeom_stroke(), lwgeom_type_arc(), 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_AddLine(), _lwt_CheckEdgeCrossing(), _lwt_FindFaceContainingRing(), _lwt_GetEqualEdge(), _lwt_SnapEdge_checkMotion(), isvalid(), LWGEOM2GEOS(), lwgeom_buildarea(), lwgeom_centroid(), lwgeom_clip_by_rect(), lwgeom_concavehull(), lwgeom_delaunay_triangulation(), LWGEOM_dfullywithin(), lwgeom_difference_prec(), lwgeom_extract_unique_endpoints(), lwgeom_geos_noop(), lwgeom_intersection_prec(), lwgeom_is_simple(), lwgeom_linemerge_directed(), lwgeom_make_valid_params(), lwgeom_node(), lwgeom_normalize(), lwgeom_pointonsurface(), lwgeom_reduceprecision(), lwgeom_sharedpaths(), lwgeom_simplify_polygonal(), lwgeom_snap(), lwgeom_symdifference_prec(), lwgeom_triangulate_polygon(), lwgeom_unaryunion_prec(), lwgeom_union_prec(), LWGEOMARRAY2GEOS(), lwline_offsetcurve(), lwline_split_by_line(), lwpoly_split_by_line(), lwpoly_to_points(), lwt_AddPolygon(), POSTGIS2GEOS(), PrepGeomCacheBuilder(), read_geos_from_partition(), rt_raster_compute_skewed_raster(), 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: