LWGEOM2SFCGAL()

sfcgal_geometry_t* LWGEOM2SFCGAL

(

const LWGEOM *

geom

)

Definition at line 445 of file liblwgeom/lwgeom_sfcgal.c.

References COLLECTIONTYPE, LWPSURFACE::flags, FLAGS_GET_SOLID, LWCOLLECTION::geoms, LWPSURFACE::geoms, LWTIN::geoms, LINETYPE, lwerror(), LWGEOM2SFCGAL(), lwgeom_is_empty(), MULTILINETYPE, MULTIPOINTTYPE, MULTIPOLYGONTYPE, LWCOLLECTION::ngeoms, LWPSURFACE::ngeoms, LWTIN::ngeoms, LWPOLY::nrings, LWPOINT::point, LWLINE::points, LWTRIANGLE::points, POINTTYPE, POLYGONTYPE, POLYHEDRALSURFACETYPE, ptarray_to_SFCGAL(), LWPOLY::rings, TINTYPE, TRIANGLETYPE, and LWGEOM::type.

Referenced by LWGEOM2SFCGAL(), lwgeom_sfcgal_noop(), POSTGIS2SFCGALGeometry(), and POSTGIS2SFCGALPreparedGeometry().

{
        uint32_t i;
        sfcgal_geometry_t* ret_geom = NULL;

        assert(geom);

        switch (geom->type)
        {
        case POINTTYPE:
        {
                const LWPOINT* lwp = (const LWPOINT*) geom;
                if (lwgeom_is_empty(geom)) return sfcgal_point_create();

                return ptarray_to_SFCGAL(lwp->point, POINTTYPE);
        }
        break;

        case LINETYPE:
        {
                const LWLINE* line = (const LWLINE*) geom;
                if (lwgeom_is_empty(geom)) return sfcgal_linestring_create();

                return ptarray_to_SFCGAL(line->points, LINETYPE);
        }
        break;

        case TRIANGLETYPE:
        {
                const LWTRIANGLE* triangle = (const LWTRIANGLE*) geom;
                if (lwgeom_is_empty(geom)) return sfcgal_triangle_create();
                return ptarray_to_SFCGAL(triangle->points, TRIANGLETYPE);
        }
        break;

        case POLYGONTYPE:
        {
                const LWPOLY* poly = (const LWPOLY*) geom;
                uint32_t nrings = poly->nrings - 1;

                if (lwgeom_is_empty(geom)) return sfcgal_polygon_create();

                sfcgal_geometry_t* exterior_ring = ptarray_to_SFCGAL(poly->rings[0], LINETYPE);
                ret_geom = sfcgal_polygon_create_from_exterior_ring(exterior_ring);

                for (i = 0; i < nrings; i++)
                {
                        sfcgal_geometry_t* ring = ptarray_to_SFCGAL(poly->rings[i + 1], LINETYPE);
                        sfcgal_polygon_add_interior_ring(ret_geom, ring);
                }
                return ret_geom;
        }
        break;

        case MULTIPOINTTYPE:
        case MULTILINETYPE:
        case MULTIPOLYGONTYPE:
        case COLLECTIONTYPE:
        {
                if (geom->type == MULTIPOINTTYPE)        ret_geom = sfcgal_multi_point_create();
                else if (geom->type == MULTILINETYPE)    ret_geom = sfcgal_multi_linestring_create();
                else if (geom->type == MULTIPOLYGONTYPE) ret_geom = sfcgal_multi_polygon_create();
                else                                     ret_geom = sfcgal_geometry_collection_create();

                const LWCOLLECTION* lwc = (const LWCOLLECTION*)geom;
                for (i = 0; i < lwc->ngeoms; i++)
                {
                        sfcgal_geometry_t* g = LWGEOM2SFCGAL(lwc->geoms[i]);
                        sfcgal_geometry_collection_add_geometry(ret_geom, g);
                }

                return ret_geom;
        }
        break;

        case POLYHEDRALSURFACETYPE:
        {
                const LWPSURFACE* lwp = (const LWPSURFACE*) geom;
                ret_geom = sfcgal_polyhedral_surface_create();

                for (i = 0; i < lwp->ngeoms; i++)
                {
                        sfcgal_geometry_t* g = LWGEOM2SFCGAL((const LWGEOM*) lwp->geoms[i]);
                        sfcgal_polyhedral_surface_add_polygon(ret_geom, g);
                }
                /* We treat polyhedral surface as the only exterior shell,
                   since we can't distinguish exterior from interior shells ... */
                if (FLAGS_GET_SOLID(lwp->flags))
                {
                        return sfcgal_solid_create_from_exterior_shell(ret_geom);
                }

                return ret_geom;
        }
        break;

        case TINTYPE:
        {
                const LWTIN* lwp = (const LWTIN*) geom;
                ret_geom = sfcgal_triangulated_surface_create();

                for (i = 0; i < lwp->ngeoms; i++)
                {
                        sfcgal_geometry_t* g = LWGEOM2SFCGAL((const LWGEOM*) lwp->geoms[i]);
                        sfcgal_triangulated_surface_add_triangle(ret_geom, g);
                }

                return ret_geom;
        }
        break;

        default:
                lwerror("LWGEOM2SFCGAL: Unknown geometry type !");
                return NULL;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function: