RASTER_Contour()

Datum RASTER_Contour

(

PG_FUNCTION_ARGS

)

Definition at line 459 of file rtpg_gdal.c.

{
        /* For return values */
        typedef struct gdal_contour_result_t {
                size_t ncontours;
                struct rt_contour_t *contours;
        } gdal_contour_result_t;
 
        FuncCallContext *funcctx;
 
        if (SRF_IS_FIRSTCALL())
        {
                MemoryContext oldcontext;
                TupleDesc tupdesc;
                gdal_contour_result_t *result;
                rt_pgraster *pgraster = NULL;
 
                /* For reading the raster */
                int src_srid = SRID_UNKNOWN;
                char *src_srs = NULL;
                rt_raster raster = NULL;
                int num_bands;
                int band, rv;
 
                /* For reading the levels[] */
                ArrayType *array;
                size_t array_size = 0;
 
                /* For the level parameters */
                double level_base = 0.0;
                double level_interval = 100.0;
                double *fixed_levels = NULL;
                size_t fixed_levels_count = 0;
 
                /* for the polygonize flag */
                bool polygonize = false;
 
                /* create a function context for cross-call persistence */
                funcctx = SRF_FIRSTCALL_INIT();
 
                /* switch to memory context appropriate for multiple function calls */
                oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
                /* To carry the output from rt_raster_gdal_contour */
                result = palloc0(sizeof(gdal_contour_result_t));
 
                /* Build a tuple descriptor for our return result */
                if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) {
                        MemoryContextSwitchTo(oldcontext);
                        ereport(ERROR, (
                                errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                errmsg(
                                        "function returning record called in context "
                                        "that cannot accept type record"
                                )
                        ));
                }
                BlessTupleDesc(tupdesc);
                funcctx->tuple_desc = tupdesc;
 
                /* Read the raster */
                pgraster = (rt_pgraster *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
                raster = rt_raster_deserialize(pgraster, FALSE);
                num_bands = rt_raster_get_num_bands(raster);
                src_srid = clamp_srid(rt_raster_get_srid(raster));
                src_srs = rtpg_getSR(src_srid);
 
                /* Read the band number */
                band = PG_GETARG_INT32(1);
                if (band < 1 || band > num_bands) {
                        elog(ERROR, "%s: band number must be between 1 and %u inclusive", __func__, num_bands);
                }
 
                /* Read the level_interval */
                level_interval = PG_GETARG_FLOAT8(2);
 
                /* Read the level_base */
                level_base = PG_GETARG_FLOAT8(3);
 
                if (level_interval <= 0.0) {
                        elog(ERROR, "%s: level interval must be greater than zero", __func__);
                }
 
                /* Read the polygonize flag */
                polygonize = PG_GETARG_BOOL(5);
 
                /* Read the levels array */
                array = PG_GETARG_ARRAYTYPE_P(4);
                array_size = ArrayGetNItems(ARR_NDIM(array), ARR_DIMS(array));
                if (array_size > 0) {
                        Datum value;
                        bool isnull;
                        ArrayIterator iterator = array_create_iterator(array, 0, NULL);
                        fixed_levels = palloc0(array_size * sizeof(double));
                        while (array_iterate(iterator, &value, &isnull))
                        {
                                /* Skip nulls */
                                if (isnull)
                                        continue;
 
                                /* Can out if for some reason we are about to blow memory */
                                if (fixed_levels_count >= array_size)
                                        break;
 
                                fixed_levels[fixed_levels_count++] = DatumGetFloat8(value);
                        }
                }
 
                /* Run the contouring routine */
                rv = rt_raster_gdal_contour(
                        /* input parameters */
                        raster,
                        band,
                        src_srid,
                        src_srs,
                        level_interval,
                        level_base,
                        fixed_levels_count,
                        fixed_levels,
                        polygonize,
                        /* output parameters */
                        &(result->ncontours),
                        &(result->contours)
                        );
 
                /* No-op on bad return */
                if (rv == FALSE) {
                        PG_RETURN_NULL();
                }
 
                funcctx->user_fctx = result;
                funcctx->max_calls = result->ncontours;
                MemoryContextSwitchTo(oldcontext);
        }
 
        /* stuff done on every call of the function */
        funcctx = SRF_PERCALL_SETUP();
 
        /* do when there is more left to send */
        if (funcctx->call_cntr < funcctx->max_calls) {
 
                HeapTuple tuple;
                Datum srf_result;
                Datum values[3] = {0, 0, 0};
                bool nulls[3] = {0, 0, 0};
 
                gdal_contour_result_t *result = funcctx->user_fctx;
                struct rt_contour_t c = result->contours[funcctx->call_cntr];
 
                if (c.geom) {
                        values[0] = PointerGetDatum(c.geom);
                        values[1] = Int32GetDatum(c.id);
                        values[2] = Float8GetDatum(c.elevation);
                }
                else {
                        nulls[0] = true;
                        nulls[1] = true;
                        nulls[2] = true;
                }
 
                /* return a tuple */
                tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
                srf_result = HeapTupleGetDatum(tuple);
                SRF_RETURN_NEXT(funcctx, srf_result);
        }
        else {
                SRF_RETURN_DONE(funcctx);
        }
}

References clamp_srid(), rt_contour_t::elevation, FALSE, rt_contour_t::geom, rt_contour_t::id, result, rt_raster_deserialize(), rt_raster_gdal_contour(), rt_raster_get_num_bands(), rt_raster_get_srid(), rtpg_getSR(), and SRID_UNKNOWN.

Here is the call graph for this function: