buffer()

Datum buffer

(

PG_FUNCTION_ARGS

)

Definition at line 796 of file postgis/lwgeom_geos.c.

{
        GSERIALIZED     *geom1;
        double  size;
        GEOSBufferParams *bufferparams;
        GEOSGeometry *g1, *g3 = NULL;
        GSERIALIZED *result;
        int quadsegs = 8; /* the default */
        int nargs;
        int singleside = 0; /* the default */
        enum
        {
            ENDCAP_ROUND = 1,
            ENDCAP_FLAT = 2,
            ENDCAP_SQUARE = 3
        };
        enum
        {
            JOIN_ROUND = 1,
            JOIN_MITRE = 2,
            JOIN_BEVEL = 3
        };
        static const double DEFAULT_MITRE_LIMIT = 5.0;
        static const int DEFAULT_ENDCAP_STYLE = ENDCAP_ROUND;
        static const int DEFAULT_JOIN_STYLE = JOIN_ROUND;
 
        double mitreLimit = DEFAULT_MITRE_LIMIT;
        int endCapStyle = DEFAULT_ENDCAP_STYLE;
        int joinStyle  = DEFAULT_JOIN_STYLE;
        char *param;
        char *params = NULL;
        LWGEOM *lwg;
 
        geom1 = PG_GETARG_GSERIALIZED_P(0);
        size = PG_GETARG_FLOAT8(1);
 
        /* Empty.Buffer() == Empty[polygon] */
        if ( gserialized_is_empty(geom1) )
        {
                lwg = lwpoly_as_lwgeom(lwpoly_construct_empty(
                        gserialized_get_srid(geom1),
                        0, 0)); // buffer wouldn't give back z or m anyway
                PG_RETURN_POINTER(geometry_serialize(lwg));
        }
 
        nargs = PG_NARGS();
 
        initGEOS(lwpgnotice, lwgeom_geos_error);
 
        g1 = POSTGIS2GEOS(geom1);
        if (!g1)
                HANDLE_GEOS_ERROR("First argument geometry could not be converted to GEOS");
 
        if (nargs > 2)
        {
                /* We strdup `cause we're going to modify it */
                params = pstrdup(PG_GETARG_CSTRING(2));
 
                POSTGIS_DEBUGF(3, "Params: %s", params);
 
                for (param=params; ; param=NULL)
                {
                        char *key, *val;
                        param = strtok(param, " ");
                        if (!param) break;
                        POSTGIS_DEBUGF(3, "Param: %s", param);
 
                        key = param;
                        val = strchr(key, '=');
                        if (!val || *(val + 1) == '\0')
                        {
                                lwpgerror("Missing value for buffer parameter %s", key);
                                break;
                        }
                        *val = '\0';
                        ++val;
 
                        POSTGIS_DEBUGF(3, "Param: %s : %s", key, val);
 
                        if ( !strcmp(key, "endcap") )
                        {
                                /* Supported end cap styles:
                                 *   "round", "flat", "square"
                                 */
                                if ( !strcmp(val, "round") )
                                {
                                        endCapStyle = ENDCAP_ROUND;
                                }
                                else if ( !strcmp(val, "flat") ||
                                          !strcmp(val, "butt")    )
                                {
                                        endCapStyle = ENDCAP_FLAT;
                                }
                                else if ( !strcmp(val, "square") )
                                {
                                        endCapStyle = ENDCAP_SQUARE;
                                }
                                else
                                {
                                        lwpgerror("Invalid buffer end cap "
                                                "style: %s (accept: "
                                                "'round', 'flat', 'butt' "
                                                "or 'square'"
                                                ")", val);
                                        break;
                                }
 
                        }
                        else if ( !strcmp(key, "join") )
                        {
                                if ( !strcmp(val, "round") )
                                {
                                        joinStyle = JOIN_ROUND;
                                }
                                else if ( !strcmp(val, "mitre") ||
                                          !strcmp(val, "miter")    )
                                {
                                        joinStyle = JOIN_MITRE;
                                }
                                else if ( !strcmp(val, "bevel") )
                                {
                                        joinStyle = JOIN_BEVEL;
                                }
                                else
                                {
                                        lwpgerror("Invalid buffer end cap "
                                                "style: %s (accept: "
                                                "'round', 'mitre', 'miter' "
                                                " or 'bevel'"
                                                ")", val);
                                        break;
                                }
                        }
                        else if ( !strcmp(key, "mitre_limit") ||
                                  !strcmp(key, "miter_limit")    )
                        {
                                /* mitreLimit is a float */
                                mitreLimit = atof(val);
                        }
                        else if ( !strcmp(key, "quad_segs") )
                        {
                                /* quadrant segments is an int */
                                quadsegs = atoi(val);
                        }
                        else if ( !strcmp(key, "side") ||
                                          !strcmp(key, "side") )
                        {
                                if ( !strcmp(val, "both") )
                                {
                                        singleside = 0;
                                }
                                else if ( !strcmp(val, "left") )
                                {
                                        singleside = 1;
                                }
                                else if ( !strcmp(val, "right") )
                                {
                                        singleside = 1;
                                        size *= -1;
                                }
                                else
                                {
                                        lwpgerror("Invalid side parameter: %s (accept: 'right', 'left', 'both')", val);
                                        break;
                                }
                        }
                        else
                        {
                                lwpgerror(
                                    "Invalid buffer parameter: %s (accept: 'endcap', 'join', 'mitre_limit', 'miter_limit', 'quad_segs' and 'side')",
                                    key);
                                break;
                        }
                }
 
                pfree(params); /* was pstrduped */
 
                POSTGIS_DEBUGF(3, "endCap:%d joinStyle:%d mitreLimit:%g",
                               endCapStyle, joinStyle, mitreLimit);
 
        }
 
        bufferparams = GEOSBufferParams_create();
        if (bufferparams)
        {
                if (GEOSBufferParams_setEndCapStyle(bufferparams, endCapStyle) &&
                        GEOSBufferParams_setJoinStyle(bufferparams, joinStyle) &&
                        GEOSBufferParams_setMitreLimit(bufferparams, mitreLimit) &&
                        GEOSBufferParams_setQuadrantSegments(bufferparams, quadsegs) &&
                        GEOSBufferParams_setSingleSided(bufferparams, singleside))
                {
                        g3 = GEOSBufferWithParams(g1, bufferparams, size);
                }
                else
                {
                        lwpgerror("Error setting buffer parameters.");
                }
                GEOSBufferParams_destroy(bufferparams);
        }
        else
        {
                lwpgerror("Error setting buffer parameters.");
        }
 
        GEOSGeom_destroy(g1);
 
        if (!g3) HANDLE_GEOS_ERROR("GEOSBuffer");
 
        POSTGIS_DEBUGF(3, "result: %s", GEOSGeomToWKT(g3));
 
        GEOSSetSRID(g3, gserialized_get_srid(geom1));
 
        result = GEOS2POSTGIS(g3, gserialized_has_z(geom1));
        GEOSGeom_destroy(g3);
 
        if (!result)
        {
                elog(ERROR,"GEOS buffer() threw an error (result postgis geometry formation)!");
                PG_RETURN_NULL(); /* never get here */
        }
 
        PG_FREE_IF_COPY(geom1, 0);
        PG_RETURN_POINTER(result);
}

References geometry_serialize(), GEOS2POSTGIS(), gserialized_get_srid(), gserialized_has_z(), gserialized_is_empty(), HANDLE_GEOS_ERROR, lwgeom_geos_error(), lwpoly_as_lwgeom(), lwpoly_construct_empty(), and POSTGIS2GEOS().

Referenced by do_test_s64_roundtrip(), do_test_u64_roundtrip(), encode_ptarray(), encode_ptarray_initial(), init_homogenizebuffer(), lwcollection_build_buffer(), lwcollection_homogenize(), mvt_clip_and_validate_geos(), mvt_geom(), spatial_index_read_extent(), and ST_AsMVTGeom().

Here is the call graph for this function:

Here is the caller graph for this function: