rt_raster_get_perimeter()

rt_errorstate rt_raster_get_perimeter	(	rt_raster	raster,
		int	nband,
		LWGEOM **	perimeter
	)

Get raster perimeter.

The perimeter is a 4 vertices (5 to be closed) single ring polygon bearing the raster's rotation and using projection coordinates.

Parameters

raster	: the raster to get info from
nband	: the band for the perimeter. 0-based value less than zero means all bands
**perimeter	: pointer to perimeter

Returns

ES_NONE if success, ES_ERROR if error

Definition at line 182 of file rt_geometry.c.

  {
        rt_band band = NULL;
        int numband = 0;
        uint16_t *_nband = NULL;
        int i = 0;
        int j = 0;
        uint16_t _trim[4] = {0};
        uint16_t trim[4] = {0}; /* top, right, bottom, left */
        int isset[4] = {0};
        double gt[6] = {0.0};
        int srid = SRID_UNKNOWN;
 
        POINTARRAY *pts = NULL;
        POINT4D p4d;
        POINTARRAY **rings = NULL;
        LWPOLY* poly = NULL;
 
        assert(perimeter != NULL);
 
        *perimeter = NULL;
 
        /* empty raster, no perimeter */
        if (rt_raster_is_empty(raster))
                return ES_NONE;
 
        /* raster metadata */
        srid = rt_raster_get_srid(raster);
        rt_raster_get_geotransform_matrix(raster, gt);
        numband = rt_raster_get_num_bands(raster);
 
        RASTER_DEBUGF(3, "rt_raster_get_perimeter: raster is %dx%d", raster->width, raster->height);
 
        /* nband < 0 means all bands */
        if (nband >= 0) {
                if (nband >= numband) {
                        rterror("rt_raster_get_boundary: Band %d not found for raster", nband);
                        return ES_ERROR;
                }
 
                numband = 1;
        }
        else
                nband = -1;
 
        RASTER_DEBUGF(3, "rt_raster_get_perimeter: nband, numband = %d, %d", nband, numband);
 
        _nband = rtalloc(sizeof(uint16_t) * numband);
        if (_nband == NULL) {
                rterror("rt_raster_get_boundary: Could not allocate memory for band indices");
                return ES_ERROR;
        }
 
        if (nband < 0) {
                for (i = 0; i < numband; i++)
                        _nband[i] = i;
        }
        else
                _nband[0] = nband;
 
        for (i = 0; i < numband; i++) {
                band = rt_raster_get_band(raster, _nband[i]);
                if (band == NULL) {
                        rterror("rt_raster_get_boundary: Could not get band at index %d", _nband[i]);
                        rtdealloc(_nband);
                        return ES_ERROR;
                }
 
                /* band is nodata */
                if (rt_band_get_isnodata_flag(band) != 0)
                        continue;
 
                if (_rti_raster_get_band_perimeter(band, trim) != ES_NONE) {
                        rterror("rt_raster_get_boundary: Could not get band perimeter");
                        rtdealloc(_nband);
                        return ES_ERROR;
                }
 
                for (j = 0; j < 4; j++) {
                        if (!isset[j] || trim[j] < _trim[j]) {
                                _trim[j] = trim[j];
                                isset[j] = 1;
                        }
                }
        }
 
        /* no longer needed */
        rtdealloc(_nband);
 
        /* check isset, just need to check one element */
        if (!isset[0]) {
                /* return NULL as bands are empty */
                return ES_NONE;
        }
 
        RASTER_DEBUGF(4, "trim = (%d, %d, %d, %d)",
                trim[0], trim[1], trim[2], trim[3]);
 
        /* only one ring */
        rings = (POINTARRAY **) rtalloc(sizeof (POINTARRAY*));
        if (!rings) {
                rterror("rt_raster_get_perimeter: Could not allocate memory for polygon ring");
                return ES_ERROR;
        }
        rings[0] = ptarray_construct(0, 0, 5);
        if (!rings[0]) {
                rterror("rt_raster_get_perimeter: Could not construct point array");
                return ES_ERROR;
        }
        pts = rings[0];
 
        /* Upper-left corner (first and last points) */
        rt_raster_cell_to_geopoint(
                raster,
                _trim[3], _trim[0],
                &p4d.x, &p4d.y,
                gt
        );
        ptarray_set_point4d(pts, 0, &p4d);
        ptarray_set_point4d(pts, 4, &p4d);
 
        /* Upper-right corner (we go clockwise) */
        rt_raster_cell_to_geopoint(
                raster,
                raster->width - _trim[1], _trim[0],
                &p4d.x, &p4d.y,
                gt
        );
        ptarray_set_point4d(pts, 1, &p4d);
 
        /* Lower-right corner */
        rt_raster_cell_to_geopoint(
                raster,
                raster->width - _trim[1], raster->height - _trim[2],
                &p4d.x, &p4d.y,
                gt
        );
        ptarray_set_point4d(pts, 2, &p4d);
 
        /* Lower-left corner */
        rt_raster_cell_to_geopoint(
                raster,
                _trim[3], raster->height - _trim[2],
                &p4d.x, &p4d.y,
                gt
        );
        ptarray_set_point4d(pts, 3, &p4d);
 
        poly = lwpoly_construct(srid, 0, 1, rings);
        *perimeter = lwpoly_as_lwgeom(poly);
 
        return ES_NONE;
}

References _rti_raster_get_band_perimeter(), ovdump::band, ES_ERROR, ES_NONE, window::gt, lwpoly_as_lwgeom(), lwpoly_construct(), pixval::nband, ptarray_construct(), ptarray_set_point4d(), rtrowdump::raster, RASTER_DEBUGF, rt_band_get_isnodata_flag(), rt_raster_cell_to_geopoint(), rt_raster_get_band(), rt_raster_get_geotransform_matrix(), rt_raster_get_num_bands(), rt_raster_get_srid(), rt_raster_is_empty(), rtalloc(), rtdealloc(), rterror(), SRID_UNKNOWN, trim(), POINT4D::x, and POINT4D::y.

Referenced by RASTER_convex_hull(), and test_raster_perimeter().

Here is the call graph for this function:

Here is the caller graph for this function: