ST_ShapeGrid()

Datum ST_ShapeGrid

(

PG_FUNCTION_ARGS

)

Definition at line 233 of file lwgeom_generate_grid.c.

{
        FuncCallContext *funcctx;
 
        GSERIALIZED *gbounds;
        GeometryGridState *state;
 
        LWGEOM *lwgeom;
        bool isnull[3] = {0,0,0}; /* needed to say no value is null */
        Datum tuple_arr[3]; /* used to construct the composite return value */
        HeapTuple tuple;
        Datum result; /* the actual composite return value */
 
        if (SRF_IS_FIRSTCALL())
        {
                MemoryContext oldcontext;
                const char *func_name;
                char gbounds_is_empty;
                GBOX bounds;
                double size;
                funcctx = SRF_FIRSTCALL_INIT();
 
                /* Get a local copy of the bounds we are going to fill with shapes */
                gbounds = PG_GETARG_GSERIALIZED_P(1);
                size = PG_GETARG_FLOAT8(0);
 
                gbounds_is_empty = (gserialized_get_gbox_p(gbounds, &bounds) == LW_FAILURE);
 
                /* quick opt-out if we get nonsensical inputs  */
                if (size <= 0.0 || gbounds_is_empty)
                {
                        funcctx = SRF_PERCALL_SETUP();
                        SRF_RETURN_DONE(funcctx);
                }
 
                oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
                /*
                * Support both hexagon and square grids with one function,
                * by checking the calling signature up front.
                */
                func_name = get_func_name(fcinfo->flinfo->fn_oid);
                if (strcmp(func_name, "st_hexagongrid") == 0)
                {
                        state = (GeometryGridState*)hexagon_grid_state(size, &bounds, gserialized_get_srid(gbounds));
                }
                else if (strcmp(func_name, "st_squaregrid") == 0)
                {
                        state = (GeometryGridState*)square_grid_state(size, &bounds, gserialized_get_srid(gbounds));
                }
                else
                {
                        ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                errmsg("%s called from unsupported functional context '%s'", __func__, func_name)));
                }
 
                funcctx->user_fctx = state;
 
                /* get tuple description for return type */
                if (get_call_result_type(fcinfo, 0, &funcctx->tuple_desc) != TYPEFUNC_COMPOSITE)
                {
                        ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                errmsg("set-valued function called in context that cannot accept a set")));
                }
 
                BlessTupleDesc(funcctx->tuple_desc);
                MemoryContextSwitchTo(oldcontext);
        }
 
        /* stuff done on every call of the function */
        funcctx = SRF_PERCALL_SETUP();
 
        /* get state */
        state = funcctx->user_fctx;
 
        /* Stop when we've used up all the grid squares */
        if (state->done)
        {
                SRF_RETURN_DONE(funcctx);
        }
 
        /* Store grid cell coordinates */
        tuple_arr[1] = Int32GetDatum(state->i);
        tuple_arr[2] = Int32GetDatum(state->j);
 
        /* Generate geometry */
        switch (state->cell_shape)
        {
                case SHAPE_HEXAGON:
                        lwgeom = hexagon(0.0, 0.0, state->size, state->i, state->j, state->srid);
                        /* Increment to next cell */
                        hexagon_state_next((HexagonGridState*)state);
                        break;
                case SHAPE_SQUARE:
                        lwgeom = square(0.0, 0.0, state->size, state->i, state->j, state->srid);
                        /* Increment to next cell */
                        square_state_next((SquareGridState*)state);
                        break;
                default:
                        ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                errmsg("%s called from with unsupported shape '%d'", __func__, state->cell_shape)));
        }
 
        tuple_arr[0] = PointerGetDatum(geometry_serialize(lwgeom));
        lwfree(lwgeom);
 
        /* Form tuple and return */
        tuple = heap_form_tuple(funcctx->tuple_desc, tuple_arr, isnull);
        result = HeapTupleGetDatum(tuple);
        SRF_RETURN_NEXT(funcctx, result);
}

References GeometryGridState::cell_shape, HexagonGridState::cell_shape, GeometryGridState::done, gserialized_get_gbox_p(), gserialized_get_srid(), hexagon(), hexagon_grid_state(), hexagon_state_next(), GeometryGridState::i, HexagonGridState::i, GeometryGridState::j, HexagonGridState::j, LW_FAILURE, lwfree(), result, SHAPE_HEXAGON, SHAPE_SQUARE, GeometryGridState::size, HexagonGridState::size, square(), square_grid_state(), square_state_next(), GeometryGridState::srid, and HexagonGridState::srid.

Here is the call graph for this function: