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.

References _rti_raster_get_band_perimeter(), ovdump::band, ES_ERROR, ES_NONE, window::gt, rt_raster_t::height, lwpoly_as_lwgeom(), lwpoly_construct(), pixval::nband, ptarray_construct(), ptarray_set_point4d(), 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(), rt_raster_t::width, POINT4D::x, and POINT4D::y.

Referenced by RASTER_convex_hull(), and test_raster_perimeter().

  {
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function: