rtpg_nmapalgebra_callback()

static int rtpg_nmapalgebra_callback ( rt_iterator_arg  arg, void *  userarg, double *  value, int *  nodata  )

static

Definition at line 365 of file rtpg_mapalgebra.c.

References rt_iterator_arg_t::columns, rt_iterator_arg_t::dst_pixel, if(), rt_iterator_arg_t::nodata, PG_FUNCTION_INFO_V1(), POSTGIS_RT_DEBUGF, RASTER_nMapAlgebra(), rt_iterator_arg_t::rasters, rt_iterator_arg_t::rows, rt_iterator_arg_t::src_pixel, rtpg_nmapalgebra_callback_arg::ufc_info, rtpg_nmapalgebra_callback_arg::ufc_rettype, rt_iterator_arg_t::values, pixval::x, and pixval::y.

Referenced by RASTER_nMapAlgebra().

  {
        rtpg_nmapalgebra_callback_arg *callback = (rtpg_nmapalgebra_callback_arg *) userarg;

        int16 typlen;
        bool typbyval;
        char typalign;

        ArrayType *mdValues = NULL;
        Datum *_values = NULL;
        bool *_nodata = NULL;

        ArrayType *mdPos = NULL;
        Datum *_pos = NULL;
        bool *_null = NULL;

        int i = 0;
        int x = 0;
        int y = 0;
        int z = 0;
        int dim[3] = {0};
        int lbound[3] = {1, 1, 1};
        Datum datum = (Datum) NULL;

        if (arg == NULL)
                return 0;

        *value = 0;
        *nodata = 0;

        dim[0] = arg->rasters;
        dim[1] = arg->rows;
        dim[2] = arg->columns;

        _values = palloc(sizeof(Datum) * arg->rasters * arg->rows * arg->columns);
        _nodata = palloc(sizeof(bool) * arg->rasters * arg->rows * arg->columns);
        if (_values == NULL || _nodata == NULL) {
                elog(ERROR, "rtpg_nmapalgebra_callback: Could not allocate memory for values array");
                return 0;
        }

        /* build mdValues */
        i = 0;
        /* raster */
        for (z = 0; z < arg->rasters; z++) {
                /* Y axis */
                for (y = 0; y < arg->rows; y++) {
                        /* X axis */
                        for (x = 0; x < arg->columns; x++) {
                                POSTGIS_RT_DEBUGF(4, "(z, y ,x) = (%d, %d, %d)", z, y, x);
                                POSTGIS_RT_DEBUGF(4, "(value, nodata) = (%f, %d)", arg->values[z][y][x], arg->nodata[z][y][x]);

                                _nodata[i] = (bool) arg->nodata[z][y][x];
                                if (!_nodata[i])
                                        _values[i] = Float8GetDatum(arg->values[z][y][x]);
                                else
                                        _values[i] = (Datum) NULL;

                                i++;
                        }
                }
        }

        /* info about the type of item in the multi-dimensional array (float8). */
        get_typlenbyvalalign(FLOAT8OID, &typlen, &typbyval, &typalign);

        /* construct mdValues */
        mdValues = construct_md_array(
                _values, _nodata,
                3, dim, lbound,
                FLOAT8OID,
                typlen, typbyval, typalign
        );
        pfree(_nodata);
        pfree(_values);

        _pos = palloc(sizeof(Datum) * (arg->rasters + 1) * 2);
        _null = palloc(sizeof(bool) * (arg->rasters + 1) * 2);
        if (_pos == NULL || _null == NULL) {
                pfree(mdValues);
                elog(ERROR, "rtpg_nmapalgebra_callback: Could not allocate memory for position array");
                return 0;
        }
        memset(_null, 0, sizeof(bool) * (arg->rasters + 1) * 2);

        /* build mdPos */
        i = 0;
        _pos[i] = arg->dst_pixel[0] + 1;
        i++;
        _pos[i] = arg->dst_pixel[1] + 1;
        i++;

        for (z = 0; z < arg->rasters; z++) {
                _pos[i] = arg->src_pixel[z][0] + 1;
                i++;

                _pos[i] = arg->src_pixel[z][1] + 1;
                i++;
        }

        /* info about the type of item in the multi-dimensional array (int4). */
        get_typlenbyvalalign(INT4OID, &typlen, &typbyval, &typalign);

        /* reuse dim and lbound, just tweak to what we need */
        dim[0] = arg->rasters + 1;
        dim[1] = 2;
        lbound[0] = 0;

        /* construct mdPos */
        mdPos = construct_md_array(
                _pos, _null,
                2, dim, lbound,
                INT4OID,
                typlen, typbyval, typalign
        );
        pfree(_pos);
        pfree(_null);

#if POSTGIS_PGSQL_VERSION < 120
        callback->ufc_info.arg[0] = PointerGetDatum(mdValues);
        callback->ufc_info.arg[1] = PointerGetDatum(mdPos);
#else
        callback->ufc_info->args[0].value = PointerGetDatum(mdValues);
        callback->ufc_info->args[1].value = PointerGetDatum(mdPos);
#endif

        /* call user callback function */
#if POSTGIS_PGSQL_VERSION < 120
        datum = FunctionCallInvoke(&(callback->ufc_info));
#else
        datum = FunctionCallInvoke(callback->ufc_info);
#endif
        pfree(mdValues);
        pfree(mdPos);

        /* result is not null*/
#if POSTGIS_PGSQL_VERSION < 120
        if (!callback->ufc_info.isnull) {
#else
        if (!callback->ufc_info->isnull)
        {
#endif
                switch (callback->ufc_rettype) {
                        case FLOAT8OID:
                                *value = DatumGetFloat8(datum);
                                break;
                        case FLOAT4OID:
                                *value = (double) DatumGetFloat4(datum);
                                break;
                        case INT4OID:
                                *value = (double) DatumGetInt32(datum);
                                break;
                        case INT2OID:
                                *value = (double) DatumGetInt16(datum);
                                break;
                }
        }
        else
                *nodata = 1;

        return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function: