rt_band_get_nearest_pixel()

uint32_t 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 1680 of file rt_band.c.

  {
        rt_pixel npixel = NULL;
        int extent[4] = {0};
        int max_extent[4] = {0};
        int d0 = 0;
        uint32_t 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 && (uint32_t) abs(x) > distance[0]) || (x - band->width >= (int)distance[0])) ||
                        ((y < 0 && (uint32_t) abs(y) > distance[1]) || (y - band->height >= (int)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 - (int)distance[0]; /* min X */
        max_extent[1] = y - (int)distance[1]; /* min Y */
        max_extent[2] = x + (int)distance[0]; /* max X */
        max_extent[3] = y + (int)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 - (int)_d[0]; /* min x */
                extent[1] = y - (int)_d[1]; /* min y */
                extent[2] = x + (int)_d[0]; /* max x */
                extent[3] = y + (int)_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 < (uint32_t) _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 thresholds 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;
}

References ovdump::band, genraster::count, distance(), ES_NONE, FALSE, rt_pixel_t::nodata, 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_pixel_t::x, pixval::x, rt_pixel_t::y, and pixval::y.

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

Here is the call graph for this function:

Here is the caller graph for this function: