rt_raster_get_convex_hull()

rt_errorstate rt_raster_get_convex_hull	(	rt_raster	raster,
		LWGEOM **	hull
	)

Get raster's convex hull.

The convex hull is typically 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
**hull	: pointer to convex hull

Returns

ES_NONE if success, ES_ERROR if error

Definition at line 839 of file rt_geometry.c.

                                                           {
        double gt[6] = {0.0};
        int32_t srid = SRID_UNKNOWN;
 
        POINTARRAY *pts = NULL;
        POINT4D p4d;
 
        assert(hull != NULL);
        *hull = NULL;
 
        /* raster is NULL, convex hull is NULL */
        if (raster == NULL)
                return ES_NONE;
 
        /* raster metadata */
        srid = rt_raster_get_srid(raster);
        rt_raster_get_geotransform_matrix(raster, gt);
 
        RASTER_DEBUGF(3, "rt_raster_get_convex_hull: raster is %dx%d", raster->width, raster->height);
 
        /* return point or line since at least one of the two dimensions is 0 */
        if ((!raster->width) || (!raster->height)) {
                p4d.x = gt[0];
                p4d.y = gt[3];
 
                /* return point */
                if (!raster->width && !raster->height) {
                        LWPOINT *point = lwpoint_make2d(srid, p4d.x, p4d.y);
                        *hull = lwpoint_as_lwgeom(point);
                }
                /* return linestring */
                else {
                        LWLINE *line = NULL;
                        pts = ptarray_construct_empty(0, 0, 2);
 
                        /* first point of line */
                        ptarray_append_point(pts, &p4d, LW_TRUE);
 
                        /* second point of line */
                        if (rt_raster_cell_to_geopoint(
                                raster,
                                rt_raster_get_width(raster), rt_raster_get_height(raster),
                                &p4d.x, &p4d.y,
                                gt
                        ) != ES_NONE) {
                                rterror("rt_raster_get_convex_hull: Could not get second point for linestring");
                                return ES_ERROR;
                        }
                        ptarray_append_point(pts, &p4d, LW_TRUE);
                        line = lwline_construct(srid, NULL, pts);
 
                        *hull = lwline_as_lwgeom(line);
                }
 
                return ES_NONE;
        }
        else {
                POINTARRAY **rings = NULL;
                LWPOLY* poly = NULL;
 
                /* only one ring */
                rings = (POINTARRAY **) rtalloc(sizeof (POINTARRAY*));
                if (!rings) {
                        rterror("rt_raster_get_convex_hull: Could not allocate memory for polygon ring");
                        return ES_ERROR;
                }
                rings[0] = ptarray_construct(0, 0, 5);
                /* TODO: handle error on ptarray construction */
                /* XXX jorgearevalo: the error conditions aren't managed in ptarray_construct */
                if (!rings[0]) {
                        rterror("rt_raster_get_convex_hull: Could not construct point array");
                        return ES_ERROR;
                }
                pts = rings[0];
 
                /* Upper-left corner (first and last points) */
                p4d.x = gt[0];
                p4d.y = gt[3];
                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, 0,
                        &p4d.x, &p4d.y,
                        gt
                );
                ptarray_set_point4d(pts, 1, &p4d);
 
                /* Lower-right corner */
                rt_raster_cell_to_geopoint(
                        raster,
                        raster->width, raster->height,
                        &p4d.x, &p4d.y,
                        gt
                );
                ptarray_set_point4d(pts, 2, &p4d);
 
                /* Lower-left corner */
                rt_raster_cell_to_geopoint(
                        raster,
                        0, raster->height,
                        &p4d.x, &p4d.y,
                        gt
                );
                ptarray_set_point4d(pts, 3, &p4d);
 
                poly = lwpoly_construct(srid, 0, 1, rings);
                *hull = lwpoly_as_lwgeom(poly);
        }
 
        return ES_NONE;
}

References ES_ERROR, ES_NONE, LW_TRUE, lwline_as_lwgeom(), lwline_construct(), lwpoint_as_lwgeom(), lwpoint_make2d(), lwpoly_as_lwgeom(), lwpoly_construct(), ptarray_append_point(), ptarray_construct(), ptarray_construct_empty(), ptarray_set_point4d(), RASTER_DEBUGF, rt_raster_cell_to_geopoint(), rt_raster_get_geotransform_matrix(), rt_raster_get_height(), rt_raster_get_srid(), rt_raster_get_width(), rtalloc(), rterror(), SRID_UNKNOWN, POINT4D::x, and POINT4D::y.

Referenced by RASTER_clip(), RASTER_convex_hull(), rt_raster_compute_skewed_raster(), rt_raster_intersects(), rt_raster_surface(), and test_raster_convex_hull().

Here is the call graph for this function:

Here is the caller graph for this function: