rt_band_get_pixel_bilinear()

rt_errorstate rt_band_get_pixel_bilinear	(	rt_band	band,
		double	xr,
		double	yr,
		double *	r_value,
		int *	r_nodata
	)

Retrieve a point value from the raster using a world coordinate and bilinear interpolation.

Parameters

rast	: the raster to read for values
bandnum	: the band to read for the values
xw	: x world coordinate in
yw	: y world coordinate in
r_value	: return pointer for point value
r_nodata	: return pointer for if this is a nodata

Returns

ES_ERROR on error, otherwise ES_NONE

Definition at line 1435 of file rt_band.c.

{
        double xcenter, ycenter;
        double values[2][2];
        double nodatavalue = 0.0;
        int   nodatas[2][2];
        int x[2][2];
        int y[2][2];
        int xcell, ycell;
        int xdir, ydir;
        int i, j;
        uint16_t width, height;
 
        /* Cell coordinates */
        xcell = (int)floor(xr);
        ycell = (int)floor(yr);
        xcenter = xcell + 0.5;
        ycenter = ycell + 0.5;
 
        /* Raster geometry */
        width = rt_band_get_width(band);
        height = rt_band_get_height(band);
 
        /* Reject out-of-range sample */
        if(xcell < 0 || ycell < 0 || xcell >= width || ycell >= height) {
                rtwarn("Attempting to get pixel value with out of range raster coordinates: (%d, %d)", xcell, ycell);
                return ES_ERROR;
        }
 
        /* Quadrant of 2x2 grid the raster coordinate falls in */
        xdir = xr < xcenter ? 1 : 0;
        ydir = yr < ycenter ? 1 : 0;
 
        if (rt_band_get_hasnodata_flag(band) != FALSE) {
                        rt_band_get_nodata(band, &nodatavalue);
        }
        else {
                        nodatavalue = 0.0;
        }
 
        /* Read the 2x2 values from the band */
        for (i = 0; i < 2; i++) {
                for (j = 0; j < 2; j++) {
                        double value = nodatavalue;
                        int nodata = 0;
                        int xij = xcell + (i - xdir);
                        int yij = ycell + (j - ydir);
 
                        if(xij < 0 || yij < 0 || xij >= width || yij >= height) {
                                nodata = 1;
                        }
                        else {
                                rt_errorstate err = rt_band_get_pixel(
                                        band, xij, yij,
                                        &value, &nodata
                                        );
                                if (err != ES_NONE)
                                        nodata = 1;
                        }
                        x[i][j] = xij;
                        y[i][j] = yij;
                        values[i][j] = value;
                        nodatas[i][j] = nodata;
                }
        }
 
        /* Point falls in nodata cell, just return nodata */
        if (nodatas[xdir][ydir]) {
                *r_value = nodatavalue;
                *r_nodata = 1;
                return ES_NONE;
        }
 
        /* Normalize raster coordinate to the bottom left */
        /* so we are working on a unit square */
        xr = xr - (x[0][0] + 0.5);
        yr = yr - (y[0][0] + 0.5);
 
        /* Point is in cell with values, so we take nodata */
        /* neighbors off the table by matching them to the */
        /* most controlling cell */
        for (i = 0; i < 2; i++) {
                for (j = 0; j < 2; j++) {
                        if (nodatas[i][j])
                                values[i][j] = values[xdir][ydir];
                }
        }
 
        /* Calculate bilinear value */
        /* https://en.wikipedia.org/wiki/Bilinear_interpolation#Unit_square */
        *r_nodata = 0;
        *r_value = values[0][0] * (1-xr) * (1-yr) +
                   values[1][0] * (1-yr) * xr +
                   values[0][1] * (1-xr) * yr +
                   values[1][1] * xr * yr;
 
        return ES_NONE;
}

References ES_ERROR, ES_NONE, FALSE, rt_band_get_hasnodata_flag(), rt_band_get_height(), rt_band_get_nodata(), rt_band_get_pixel(), rt_band_get_width(), and rtwarn().

Referenced by rt_band_get_pixel_resample(), and test_raster_get_pixel_bilinear().

Here is the call graph for this function:

Here is the caller graph for this function: