ST_TileEnvelope()

Datum ST_TileEnvelope

(

PG_FUNCTION_ARGS

)

Definition at line 2091 of file lwgeom_functions_basic.c.

{
        GSERIALIZED *bounds;
        uint32_t zoomu;
        int32_t x, y, zoom;
        uint32_t worldTileSize;
        double tileGeoSizeX, tileGeoSizeY;
        double boundsWidth, boundsHeight;
        double x1, y1, x2, y2;
        double margin;
        /* This is broken, since 3857 doesn't mean "web mercator", it means
           the contents of the row in spatial_ref_sys with srid = 3857.
           For practical purposes this will work, but in good implementation
           we should de-reference in spatial ref sys to confirm that the
           srid of the object is EPSG:3857. */
        int32_t srid;
        GBOX bbox;
        LWGEOM *g = NULL;
 
        POSTGIS_DEBUG(2, "ST_TileEnvelope called");
 
        zoom = PG_GETARG_INT32(0);
        x = PG_GETARG_INT32(1);
        y = PG_GETARG_INT32(2);
 
        bounds = PG_GETARG_GSERIALIZED_P(3);
        /*
         * We deserialize the geometry and recalculate the bounding box here to get
         * 64b floating point precision. The serialized bbox has 32b float is not
         * precise enough with big numbers such as the ones used in the default
         * parameters, e.g: -20037508.3427892 is transformed into -20037510
         */
        g = lwgeom_from_gserialized(bounds);
        if (lwgeom_calculate_gbox(g, &bbox) != LW_SUCCESS)
                elog(ERROR, "%s: Unable to compute bbox", __func__);
        srid = g->srid;
        lwgeom_free(g);
 
        /* Avoid crashing with old signature (old sql code with 3 args, new C code with 4) */
        margin = PG_NARGS() < 4 ? 0 : PG_GETARG_FLOAT8(4);
        /* shrinking by more than 50% would eliminate the tile outright */
        if (margin < -0.5)
                elog(ERROR, "%s: Margin must not be less than -50%%, margin=%f", __func__, margin);
 
        boundsWidth  = bbox.xmax - bbox.xmin;
        boundsHeight = bbox.ymax - bbox.ymin;
        if (boundsWidth <= 0 || boundsHeight <= 0)
                elog(ERROR, "%s: Geometric bounds are too small", __func__);
 
        if (zoom < 0 || zoom >= 32)
                elog(ERROR, "%s: Invalid tile zoom value, %d", __func__, zoom);
 
        zoomu = (uint32_t)zoom;
        worldTileSize = 0x01u << (zoomu > 31 ? 31 : zoomu);
 
        if (x < 0 || (uint32_t)x >= worldTileSize)
                elog(ERROR, "%s: Invalid tile x value, %d", __func__, x);
        if (y < 0 || (uint32_t)y >= worldTileSize)
                elog(ERROR, "%s: Invalid tile y value, %d", __func__, y);
 
        tileGeoSizeX = boundsWidth / worldTileSize;
        tileGeoSizeY = boundsHeight / worldTileSize;
 
        /*
         * 1 margin (100%) is the same as a single tile width
         * if the size of the tile with margins span more than the total number of tiles,
         * reset x1/x2 to the bounds
         */
        if ((1 + margin * 2) > worldTileSize)
        {
                x1 = bbox.xmin;
                x2 = bbox.xmax;
        }
        else
        {
                x1 = bbox.xmin + tileGeoSizeX * (x - margin);
                x2 = bbox.xmin + tileGeoSizeX * (x + 1 + margin);
        }
 
        y1 = bbox.ymax - tileGeoSizeY * (y + 1 + margin);
        y2 = bbox.ymax - tileGeoSizeY * (y - margin);
 
        /* Clip the final tile bounds to the bounds of the tile plane */
        if (y1 < bbox.ymin) y1 = bbox.ymin;
        if (y2 > bbox.ymax) y2 = bbox.ymax;
        if (x1 < bbox.xmin) x1 = bbox.xmin;
        if (x2 > bbox.xmax) x2 = bbox.xmax;
 
        PG_RETURN_POINTER(
                geometry_serialize(
                lwpoly_as_lwgeom(
                lwpoly_construct_envelope(
                        srid, x1, y1, x2, y2))));
}

References LW_SUCCESS, lwgeom_calculate_gbox(), lwgeom_free(), lwgeom_from_gserialized(), lwpoly_as_lwgeom(), lwpoly_construct_envelope(), LWGEOM::srid, pixval::x, GBOX::xmax, GBOX::xmin, pixval::y, GBOX::ymax, and GBOX::ymin.

Here is the call graph for this function: