rt_raster_from_wkb()

rt_raster rt_raster_from_wkb	(	const uint8_t *	wkb,
		uint32_t	wkbsize
	)

Construct an rt_raster from a binary WKB representation.

Parameters

wkb	: an octet stream
wkbsize	: size (in bytes) of the wkb octet stream

Returns

an rt_raster or NULL on error (out of memory or malformed WKB).

Definition at line 276 of file rt_wkb.c.

                                                         {
        const uint8_t *ptr = wkb;
        const uint8_t *wkbend = NULL;
        rt_raster rast = NULL;
        uint8_t endian = 0;
        uint16_t version = 0;
        uint16_t i = 0;
        uint16_t j = 0;
 
        assert(NULL != ptr);
 
        /* Check that wkbsize is >= sizeof(rt_raster_serialized) */
        if (wkbsize < RT_WKB_HDR_SZ) {
                rterror("rt_raster_from_wkb: wkb size (%d)  < min size (%d)",
                        wkbsize, RT_WKB_HDR_SZ);
                return NULL;
        }
        wkbend = wkb + wkbsize;
 
        RASTER_DEBUGF(3, "Parsing header from wkb position %d (expected 0)",
                d_binptr_to_pos(ptr, wkbend, wkbsize));
 
        CHECK_BINPTR_POSITION(ptr, wkbend, wkbsize, 0);
 
        /* Read endianness */
        endian = *ptr;
        ptr += 1;
 
        /* Read version of protocol */
        version = read_uint16(&ptr, endian);
        if (version != 0) {
                rterror("rt_raster_from_wkb: WKB version %d unsupported", version);
                return NULL;
        }
 
        /* Read other components of raster header */
        rast = (rt_raster) rtalloc(sizeof (struct rt_raster_t));
        if (!rast) {
                rterror("rt_raster_from_wkb: Out of memory allocating raster for wkb input");
                return NULL;
        }
 
        rast->numBands = read_uint16(&ptr, endian);
        rast->scaleX = read_float64(&ptr, endian);
        rast->scaleY = read_float64(&ptr, endian);
        rast->ipX = read_float64(&ptr, endian);
        rast->ipY = read_float64(&ptr, endian);
        rast->skewX = read_float64(&ptr, endian);
        rast->skewY = read_float64(&ptr, endian);
        rast->srid = clamp_srid(read_int32(&ptr, endian));
        rast->width = read_uint16(&ptr, endian);
        rast->height = read_uint16(&ptr, endian);
 
        /* Consistency checking, should have been checked before */
        assert(ptr <= wkbend);
 
        RASTER_DEBUGF(3, "rt_raster_from_wkb: Raster numBands: %d",
                rast->numBands);
        RASTER_DEBUGF(3, "rt_raster_from_wkb: Raster scale: %gx%g",
                rast->scaleX, rast->scaleY);
        RASTER_DEBUGF(3, "rt_raster_from_wkb: Raster ip: %gx%g",
                rast->ipX, rast->ipY);
        RASTER_DEBUGF(3, "rt_raster_from_wkb: Raster skew: %gx%g",
                rast->skewX, rast->skewY);
        RASTER_DEBUGF(3, "rt_raster_from_wkb: Raster srid: %d",
                rast->srid);
        RASTER_DEBUGF(3, "rt_raster_from_wkb: Raster dims: %dx%d",
                rast->width, rast->height);
        RASTER_DEBUGF(3, "Parsing raster header finished at wkb position %d (expected 61)",
                d_binptr_to_pos(ptr, wkbend, wkbsize));
 
        CHECK_BINPTR_POSITION(ptr, wkbend, wkbsize, 61);
 
        /* Read all bands of raster */
        if (!rast->numBands) {
                /* Here ptr should have been left to right after last used byte */
                if (ptr < wkbend) {
                        rtwarn("%d bytes of WKB remained unparsed", wkbend - ptr);
                }
                else if (ptr > wkbend) {
                        /* Easier to get a segfault before I guess */
                        rtwarn("We parsed %d bytes more then available!", ptr - wkbend);
                }
 
                rast->bands = NULL;
                return rast;
        }
 
        /* Now read the bands */
        rast->bands = (rt_band*) rtalloc(sizeof(rt_band) * rast->numBands);
        if (!rast->bands) {
                rterror("rt_raster_from_wkb: Out of memory allocating bands for WKB raster decoding");
                rt_raster_destroy(rast);
                return NULL;
        }
 
        /* ptr should now point to start of first band */
        /* we should have checked this before */
        assert(ptr <= wkbend);
 
        for (i = 0; i < rast->numBands; ++i) {
                RASTER_DEBUGF(3, "Parsing band %d from wkb position %d", i,
                        d_binptr_to_pos(ptr, wkbend, wkbsize));
 
                rt_band band = rt_band_from_wkb(rast->width, rast->height,
                        &ptr, wkbend, endian);
                if (!band) {
                        rterror("rt_raster_from_wkb: Error reading WKB form of band %d", i);
                        for (j = 0; j < i; j++) rt_band_destroy(rast->bands[j]);
                        rt_raster_destroy(rast);
                        return NULL;
                }
 
                band->raster = rast;
                rast->bands[i] = band;
        }
 
        /* Here ptr should have been left to right after last used byte */
        if (ptr < wkbend) {
                rtwarn("%d bytes of WKB remained unparsed", wkbend - ptr);
        }
        else if (ptr > wkbend) {
                /* Easier to get a segfault before I guess */
                rtwarn("We parsed %d bytes more then available!", ptr - wkbend);
        }
 
        return rast;
}

References CHECK_BINPTR_POSITION, clamp_srid(), RASTER_DEBUGF, read_float64(), read_int32(), read_uint16(), rt_band_destroy(), rt_band_from_wkb(), rt_raster_destroy(), RT_WKB_HDR_SZ, rtalloc(), rterror(), and rtwarn().

Referenced by RASTER_fromWKB(), and rt_raster_from_hexwkb().

Here is the call graph for this function:

Here is the caller graph for this function: