RASTER_setPixelValuesArray()

Datum RASTER_setPixelValuesArray

(

PG_FUNCTION_ARGS

)

Definition at line 864 of file rtpg_pixel.c.

{
        rt_pgraster *pgraster = NULL;
        rt_pgraster *pgrtn = NULL;
        rt_raster raster = NULL;
        rt_band band = NULL;
        int numbands = 0;
 
        int nband = 0;
        int width = 0;
        int height = 0;
 
        ArrayType *array;
        Oid etype;
        Datum *elements;
        bool *nulls;
        int16 typlen;
        bool typbyval;
        char typalign;
        int ndims = 1;
        int *dims;
        int num = 0;
 
        int ul[2] = {0};
        struct pixelvalue {
                int x;
                int y;
 
                bool noset;
                bool nodata;
                double value;
        };
        struct pixelvalue *pixval = NULL;
        int numpixval = 0;
        int dimpixval[2] = {1, 1};
        int dimnoset[2] = {1, 1};
        int hasnodata = FALSE;
        double nodataval = 0;
        bool keepnodata = FALSE;
        bool hasnosetval = FALSE;
        bool nosetvalisnull = FALSE;
        double nosetval = 0;
 
        int rtn = 0;
        double val = 0;
        int isnodata = 0;
 
        int i = 0;
        int j = 0;
        int x = 0;
        int y = 0;
 
        /* pgraster is null, return null */
        if (PG_ARGISNULL(0))
                PG_RETURN_NULL();
        pgraster = (rt_pgraster *) PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(0));
 
        /* raster */
        raster = rt_raster_deserialize(pgraster, FALSE);
        if (!raster) {
                PG_FREE_IF_COPY(pgraster, 0);
                elog(ERROR, "RASTER_setPixelValuesArray: Could not deserialize raster");
                PG_RETURN_NULL();
        }
 
        /* raster attributes */
        numbands = rt_raster_get_num_bands(raster);
        width = rt_raster_get_width(raster);
        height = rt_raster_get_height(raster);
 
        /* nband */
        if (PG_ARGISNULL(1)) {
                elog(NOTICE, "Band index cannot be NULL.  Value must be 1-based.  Returning original raster");
                rt_raster_destroy(raster);
                PG_RETURN_POINTER(pgraster);
        }
 
        nband = PG_GETARG_INT32(1);
        if (nband < 1 || nband > numbands) {
                elog(NOTICE, "Band index is invalid.  Value must be 1-based.  Returning original raster");
                rt_raster_destroy(raster);
                PG_RETURN_POINTER(pgraster);
        }
 
        /* x, y */
        for (i = 2, j = 0; i < 4; i++, j++) {
                if (PG_ARGISNULL(i)) {
                        elog(NOTICE, "%s cannot be NULL.  Value must be 1-based.  Returning original raster", j < 1 ? "X" : "Y");
                        rt_raster_destroy(raster);
                        PG_RETURN_POINTER(pgraster);
                }
 
                ul[j] = PG_GETARG_INT32(i);
                if (
                        (ul[j] < 1) || (
                                (j < 1 && ul[j] > width) ||
                                (j > 0 && ul[j] > height)
                        )
                ) {
                        elog(NOTICE, "%s is invalid.  Value must be 1-based.  Returning original raster", j < 1 ? "X" : "Y");
                        rt_raster_destroy(raster);
                        PG_RETURN_POINTER(pgraster);
                }
 
                /* force 0-based from 1-based */
                ul[j] -= 1;
        }
 
        /* new value set */
        if (PG_ARGISNULL(4)) {
                elog(NOTICE, "No values to set.  Returning original raster");
                rt_raster_destroy(raster);
                PG_RETURN_POINTER(pgraster);
        }
 
        array = PG_GETARG_ARRAYTYPE_P(4);
        etype = ARR_ELEMTYPE(array);
        get_typlenbyvalalign(etype, &typlen, &typbyval, &typalign);
 
        switch (etype) {
                case FLOAT4OID:
                case FLOAT8OID:
                        break;
                default:
                        rt_raster_destroy(raster);
                        PG_FREE_IF_COPY(pgraster, 0);
                        elog(ERROR, "RASTER_setPixelValuesArray: Invalid data type for new values");
                        PG_RETURN_NULL();
                        break;
        }
 
        ndims = ARR_NDIM(array);
        dims = ARR_DIMS(array);
        POSTGIS_RT_DEBUGF(4, "ndims = %d", ndims);
 
        if (ndims < 1 || ndims > 2) {
                elog(NOTICE, "New values array must be of 1 or 2 dimensions.  Returning original raster");
                rt_raster_destroy(raster);
                PG_RETURN_POINTER(pgraster);
        }
        /* outer element, then inner element */
        /* i = 0, y */
        /* i = 1, x */
        if (ndims != 2)
                dimpixval[1] = dims[0];
        else {
                dimpixval[0] = dims[0];
                dimpixval[1] = dims[1];
        }
        POSTGIS_RT_DEBUGF(4, "dimpixval = (%d, %d)", dimpixval[0], dimpixval[1]);
 
        deconstruct_array(
                array,
                etype,
                typlen, typbyval, typalign,
                &elements, &nulls, &num
        );
 
        /* # of elements doesn't match dims */
        if (num < 1 || num != (dimpixval[0] * dimpixval[1])) {
                if (num) {
                        pfree(elements);
                        pfree(nulls);
                }
                rt_raster_destroy(raster);
                PG_FREE_IF_COPY(pgraster, 0);
                elog(ERROR, "RASTER_setPixelValuesArray: Could not deconstruct new values array");
                PG_RETURN_NULL();
        }
 
        /* allocate memory for pixval */
        numpixval = num;
        pixval = palloc(sizeof(struct pixelvalue) * numpixval);
        if (pixval == NULL) {
                pfree(elements);
                pfree(nulls);
                rt_raster_destroy(raster);
                PG_FREE_IF_COPY(pgraster, 0);
                elog(ERROR, "RASTER_setPixelValuesArray: Could not allocate memory for new pixel values");
                PG_RETURN_NULL();
        }
 
        /* load new values into pixval */
        i = 0;
        for (y = 0; y < dimpixval[0]; y++) {
                for (x = 0; x < dimpixval[1]; x++) {
                        /* 0-based */
                        pixval[i].x = ul[0] + x;
                        pixval[i].y = ul[1] + y;
 
                        pixval[i].noset = FALSE;
                        pixval[i].nodata = FALSE;
                        pixval[i].value = 0;
 
                        if (nulls[i])
                                pixval[i].nodata = TRUE;
                        else {
                                switch (etype) {
                                        case FLOAT4OID:
                                                pixval[i].value = DatumGetFloat4(elements[i]);
                                                break;
                                        case FLOAT8OID:
                                                pixval[i].value = DatumGetFloat8(elements[i]);
                                                break;
                                }
                        }
 
                        i++;
                }
        }
 
        pfree(elements);
        pfree(nulls);
 
        /* now load noset flags */
        if (!PG_ARGISNULL(5)) {
                array = PG_GETARG_ARRAYTYPE_P(5);
                etype = ARR_ELEMTYPE(array);
                get_typlenbyvalalign(etype, &typlen, &typbyval, &typalign);
 
                switch (etype) {
                        case BOOLOID:
                                break;
                        default:
                                pfree(pixval);
                                rt_raster_destroy(raster);
                                PG_FREE_IF_COPY(pgraster, 0);
                                elog(ERROR, "RASTER_setPixelValuesArray: Invalid data type for noset flags");
                                PG_RETURN_NULL();
                                break;
                }
 
                ndims = ARR_NDIM(array);
                dims = ARR_DIMS(array);
                POSTGIS_RT_DEBUGF(4, "ndims = %d", ndims);
 
                if (ndims < 1 || ndims > 2) {
                        elog(NOTICE, "Noset flags array must be of 1 or 2 dimensions.  Returning original raster");
                        pfree(pixval);
                        rt_raster_destroy(raster);
                        PG_RETURN_POINTER(pgraster);
                }
                /* outer element, then inner element */
                /* i = 0, y */
                /* i = 1, x */
                if (ndims != 2)
                        dimnoset[1] = dims[0];
                else {
                        dimnoset[0] = dims[0];
                        dimnoset[1] = dims[1];
                }
                POSTGIS_RT_DEBUGF(4, "dimnoset = (%d, %d)", dimnoset[0], dimnoset[1]);
 
                deconstruct_array(
                        array,
                        etype,
                        typlen, typbyval, typalign,
                        &elements, &nulls, &num
                );
 
                /* # of elements doesn't match dims */
                if (num < 1 || num != (dimnoset[0] * dimnoset[1])) {
                        pfree(pixval);
                        if (num) {
                                pfree(elements);
                                pfree(nulls);
                        }
                        rt_raster_destroy(raster);
                        PG_FREE_IF_COPY(pgraster, 0);
                        elog(ERROR, "RASTER_setPixelValuesArray: Could not deconstruct noset flags array");
                        PG_RETURN_NULL();
                }
 
                i = 0;
                j = 0;
                for (y = 0; y < dimnoset[0]; y++) {
                        if (y >= dimpixval[0]) break;
 
                        for (x = 0; x < dimnoset[1]; x++) {
                                /* fast forward noset elements */
                                if (x >= dimpixval[1]) {
                                        i += (dimnoset[1] - dimpixval[1]);
                                        break;
                                }
 
                                if (!nulls[i] && DatumGetBool(elements[i]))
                                        pixval[j].noset = TRUE;
 
                                i++;
                                j++;
                        }
 
                        /* fast forward pixval */
                        if (x < dimpixval[1])
                                j += (dimpixval[1] - dimnoset[1]);
                }
 
                pfree(elements);
                pfree(nulls);
        }
        /* hasnosetvalue and nosetvalue */
        else if (!PG_ARGISNULL(6) && PG_GETARG_BOOL(6)) {
                hasnosetval = TRUE;
                if (PG_ARGISNULL(7))
                        nosetvalisnull = TRUE;
                else
                        nosetval = PG_GETARG_FLOAT8(7);
        }
 
#if POSTGIS_DEBUG_LEVEL > 0
        for (i = 0; i < numpixval; i++) {
                POSTGIS_RT_DEBUGF(4, "pixval[%d](x, y, noset, nodata, value) = (%d, %d, %d, %d, %f)",
                        i,
                        pixval[i].x,
                        pixval[i].y,
                        pixval[i].noset,
                        pixval[i].nodata,
                        pixval[i].value
                );
        }
#endif
 
        /* keepnodata flag */
        if (!PG_ARGISNULL(8))
                keepnodata = PG_GETARG_BOOL(8);
 
        /* get band */
        band = rt_raster_get_band(raster, nband - 1);
        if (!band) {
                elog(NOTICE, "Could not find band at index %d. Returning original raster", nband);
                pfree(pixval);
                rt_raster_destroy(raster);
                PG_RETURN_POINTER(pgraster);
        }
 
        /* get band nodata info */
        /* has NODATA, use NODATA */
        hasnodata = rt_band_get_hasnodata_flag(band);
        if (hasnodata)
                rt_band_get_nodata(band, &nodataval);
        /* no NODATA, use min possible value */
        else
                nodataval = rt_band_get_min_value(band);
 
        /* set pixels */
        for (i = 0; i < numpixval; i++) {
                /* noset = true, skip */
                if (pixval[i].noset)
                        continue;
                /* check against nosetval */
                else if (hasnosetval) {
                        /* pixel = NULL AND nosetval = NULL */
                        if (pixval[i].nodata && nosetvalisnull)
                                continue;
                        /* pixel value = nosetval */
                        else if (!pixval[i].nodata && !nosetvalisnull && FLT_EQ(pixval[i].value, nosetval))
                                continue;
                }
 
                /* if pixel is outside bounds, skip */
                if (
                        (pixval[i].x < 0 || pixval[i].x >= width) ||
                        (pixval[i].y < 0 || pixval[i].y >= height)
                ) {
                        elog(NOTICE, "Cannot set value for pixel (%d, %d) outside raster bounds: %d x %d",
                                pixval[i].x + 1, pixval[i].y + 1,
                                width, height
                        );
                        continue;
                }
 
                /* if hasnodata = TRUE and keepnodata = TRUE, inspect pixel value */
                if (hasnodata && keepnodata) {
                        rtn = rt_band_get_pixel(band, pixval[i].x, pixval[i].y, &val, &isnodata);
                        if (rtn != ES_NONE) {
                                pfree(pixval);
                                rt_raster_destroy(raster);
                                PG_FREE_IF_COPY(pgraster, 0);
                                elog(ERROR, "Cannot get value of pixel");
                                PG_RETURN_NULL();
                        }
 
                        /* pixel value = NODATA, skip */
                        if (isnodata) {
                                continue;
                        }
                }
 
                if (pixval[i].nodata)
                        rt_band_set_pixel(band, pixval[i].x, pixval[i].y, nodataval, NULL);
                else
                        rt_band_set_pixel(band, pixval[i].x, pixval[i].y, pixval[i].value, NULL);
        }
 
        pfree(pixval);
 
        /* serialize new raster */
        pgrtn = rt_raster_serialize(raster);
        rt_raster_destroy(raster);
        PG_FREE_IF_COPY(pgraster, 0);
        if (!pgrtn)
                PG_RETURN_NULL();
 
        SET_VARSIZE(pgrtn, pgrtn->size);
        PG_RETURN_POINTER(pgrtn);
}

References ES_NONE, FALSE, FLT_EQ, POSTGIS_RT_DEBUGF, rt_band_get_hasnodata_flag(), rt_band_get_min_value(), rt_band_get_nodata(), rt_band_get_pixel(), rt_band_set_pixel(), rt_raster_deserialize(), rt_raster_destroy(), rt_raster_get_band(), rt_raster_get_height(), rt_raster_get_num_bands(), rt_raster_get_width(), rt_raster_serialize(), rt_raster_serialized_t::size, and TRUE.

Here is the call graph for this function: