rt_band_get_nearest_pixel()

int rt_band_get_nearest_pixel	(	rt_band	band,
		int	x,
		int	y,
		uint16_t	distancex,
		uint16_t	distancey,
		int	exclude_nodata_value,
		rt_pixel *	npixels
	)

Get nearest pixel(s) with value (not NODATA) to specified pixel.

Parameters

band	: the band to get nearest pixel(s) from
x	: the column of the pixel (0-based)
y	: the line of the pixel (0-based)
distancex	: the number of pixels around the specified pixel along the X axis
distancey	: the number of pixels around the specified pixel along the Y axis
exclude_nodata_value	: if non-zero, ignore nodata values to check for pixels with value
npixels	: return set of rt_pixel object or NULL

Returns

-1 on error, otherwise the number of rt_pixel objects in npixels

Definition at line 1241 of file rt_band.c.

References genraster::count, distance(), ES_NONE, FALSE, rt_band_t::hasnodata, rt_band_t::height, rt_band_t::isnodata, rt_pixel_t::nodata, rt_band_t::nodataval, rt_band_t::pixtype, pixval::pixval, RASTER_DEBUG, RASTER_DEBUGF, rt_band_get_pixel(), rt_pixtype_get_min_value(), rt_pixtype_name(), rtalloc(), rtdealloc(), rterror(), rtrealloc(), rt_pixel_t::value, rt_band_t::width, rt_pixel_t::x, and rt_pixel_t::y.

Referenced by RASTER_nearestValue(), RASTER_neighborhood(), rt_raster_iterator(), test_band_get_nearest_pixel(), and test_pixel_set_to_array().

  {
        rt_pixel npixel = NULL;
        int extent[4] = {0};
        int max_extent[4] = {0};
        int d0 = 0;
        int distance[2] = {0};
        uint32_t _d[2] = {0};
        uint32_t i = 0;
        uint32_t j = 0;
        uint32_t k = 0;
        int _max = 0;
        int _x = 0;
        int _y = 0;
        int *_min = NULL;
        double pixval = 0;
        double minval = 0;
        uint32_t count = 0;
        int isnodata = 0;

        int inextent = 0;

        assert(NULL != band);
        assert(NULL != npixels);

        RASTER_DEBUG(3, "Starting");

        /* process distance */
        distance[0] = distancex;
        distance[1] = distancey;

        /* no distance, means get nearest pixels and return */
        if (!distance[0] && !distance[1])
                d0 = 1;

        RASTER_DEBUGF(4, "Selected pixel: %d x %d", x, y);
        RASTER_DEBUGF(4, "Distances: %d x %d", distance[0], distance[1]);

        /* shortcuts if outside band extent */
        if (
                exclude_nodata_value && (
                        (x < 0 || x > band->width) ||
                        (y < 0 || y > band->height)
                )
        ) {
                /* no distances specified, jump to pixel close to extent */
                if (d0) {
                        if (x < 0)
                                x = -1;
                        else if (x > band->width)
                                x = band->width;

                        if (y < 0)
                                y = -1;
                        else if (y > band->height)
                                y = band->height;

                        RASTER_DEBUGF(4, "Moved selected pixel: %d x %d", x, y);
                }
                /*
                        distances specified
                        if distances won't capture extent of band, return 0
                */
                else if (
                        ((x < 0 && abs(x) > distance[0]) || (x - band->width >= distance[0])) ||
                        ((y < 0 && abs(y) > distance[1]) || (y - band->height >= distance[1]))
                ) {
                        RASTER_DEBUG(4, "No nearest pixels possible for provided pixel and distances");
                        return 0;
                }
        }

        /* no NODATA, exclude is FALSE */
        if (!band->hasnodata)
                exclude_nodata_value = FALSE;
        /* band is NODATA and excluding NODATA */
        else if (exclude_nodata_value && band->isnodata) {
                RASTER_DEBUG(4, "No nearest pixels possible as band is NODATA and excluding NODATA values");
                return 0;
        }

        /* determine the maximum distance to prevent an infinite loop */
        if (d0) {
                int a, b;

                /* X axis */
                a = abs(x);
                b = abs(x - band->width);

                if (a > b)
                        distance[0] = a;
                else
                        distance[0] = b;

                /* Y axis */
                a = abs(y);
                b = abs(y - band->height);
                if (a > b)
                        distance[1] = a;
                else
                        distance[1] = b;

                RASTER_DEBUGF(4, "Maximum distances: %d x %d", distance[0], distance[1]);
        }

        /* minimum possible value for pixel type */
        minval = rt_pixtype_get_min_value(band->pixtype);
        RASTER_DEBUGF(4, "pixtype: %s", rt_pixtype_name(band->pixtype));
        RASTER_DEBUGF(4, "minval: %f", minval);

        /* set variables */
        count = 0;
        *npixels = NULL;

        /* maximum extent */
        max_extent[0] = x - distance[0]; /* min X */
        max_extent[1] = y - distance[1]; /* min Y */
        max_extent[2] = x + distance[0]; /* max X */
        max_extent[3] = y + distance[1]; /* max Y */
        RASTER_DEBUGF(4, "Maximum Extent: (%d, %d, %d, %d)",
                max_extent[0], max_extent[1], max_extent[2], max_extent[3]);

        _d[0] = 0;
        _d[1] = 0;
        do {
                _d[0]++;
                _d[1]++;

                extent[0] = x - _d[0]; /* min x */
                extent[1] = y - _d[1]; /* min y */
                extent[2] = x + _d[0]; /* max x */
                extent[3] = y + _d[1]; /* max y */

                RASTER_DEBUGF(4, "Processing distances: %d x %d", _d[0], _d[1]);
                RASTER_DEBUGF(4, "Extent: (%d, %d, %d, %d)",
                        extent[0], extent[1], extent[2], extent[3]);

                for (i = 0; i < 2; i++) {

                        /* by row */
                        if (i < 1)
                                _max = extent[2] - extent[0] + 1;
                        /* by column */
                        else
                                _max = extent[3] - extent[1] + 1;
                        _max = abs(_max);

                        for (j = 0; j < 2; j++) {
                                /* by row */
                                if (i < 1) {
                                        _x = extent[0];
                                        _min = &_x;

                                        /* top row */
                                        if (j < 1)
                                                _y = extent[1];
                                        /* bottom row */
                                        else
                                                _y = extent[3];
                                }
                                /* by column */
                                else {
                                        _y = extent[1] + 1;
                                        _min = &_y;

                                        /* left column */
                                        if (j < 1) {
                                                _x = extent[0];
                                                _max -= 2;
                                        }
                                        /* right column */
                                        else
                                                _x = extent[2];
                                }

                                RASTER_DEBUGF(4, "_min, _max: %d, %d", *_min, _max);
                                for (k = 0; k < _max; k++) {
                                        /* check that _x and _y are not outside max extent */
                                        if (
                                                _x < max_extent[0] || _x > max_extent[2] ||
                                                _y < max_extent[1] || _y > max_extent[3]
                                        ) {
                                                (*_min)++;
                                                continue;
                                        }

                                        /* outside band extent, set to NODATA */
                                        if (
                                                (_x < 0 || _x >= band->width) ||
                                                (_y < 0 || _y >= band->height)
                                        ) {
                                                /* no NODATA, set to minimum possible value */
                                                if (!band->hasnodata)
                                                        pixval = minval;
                                                /* has NODATA, use NODATA */
                                                else
                                                        pixval = band->nodataval;
                                                RASTER_DEBUGF(4, "NODATA pixel outside band extent: (x, y, val) = (%d, %d, %f)", _x, _y, pixval);
                                                inextent = 0;
                                                isnodata = 1;
                                        }
                                        else {
                                                if (rt_band_get_pixel(
                                                        band,
                                                        _x, _y,
                                                        &pixval,
                                                        &isnodata
                                                ) != ES_NONE) {
                                                        rterror("rt_band_get_nearest_pixel: Could not get pixel value");
                                                        if (count) rtdealloc(*npixels);
                                                        return -1;
                                                }
                                                RASTER_DEBUGF(4, "Pixel: (x, y, val) = (%d, %d, %f)", _x, _y, pixval);
                                                inextent = 1;
                                        }

                                        /* use pixval? */
                                        if (!exclude_nodata_value || (exclude_nodata_value && !isnodata)) {
                                                /* add pixel to result set */
                                                RASTER_DEBUGF(4, "Adding pixel to set of nearest pixels: (x, y, val) = (%d, %d, %f)", _x, _y, pixval);
                                                count++;

                                                if (*npixels == NULL)
                                                        *npixels = (rt_pixel) rtalloc(sizeof(struct rt_pixel_t) * count);
                                                else
                                                        *npixels = (rt_pixel) rtrealloc(*npixels, sizeof(struct rt_pixel_t) * count);
                                                if (*npixels == NULL) {
                                                        rterror("rt_band_get_nearest_pixel: Could not allocate memory for nearest pixel(s)");
                                                        return -1;
                                                }

                                                npixel = &((*npixels)[count - 1]);
                                                npixel->x = _x;
                                                npixel->y = _y;
                                                npixel->value = pixval;

                                                /* special case for when outside band extent */
                                                if (!inextent && !band->hasnodata)
                                                        npixel->nodata = 1;
                                                else
                                                        npixel->nodata = 0;
                                        }

                                        (*_min)++;
                                }
                        }
                }

                /* distance threshholds met */
                if (_d[0] >= distance[0] && _d[1] >= distance[1])
                        break;
                else if (d0 && count)
                        break;
        }
        while (1);

        RASTER_DEBUGF(3, "Nearest pixels in return: %d", count);

        return count;
}

Here is the call graph for this function:

Here is the caller graph for this function: