rt_raster_to_wkb()

uint8_t * rt_raster_to_wkb	(	rt_raster	raster,
		int	outasin,
		uint32_t *	wkbsize
	)

Return this raster in WKB form.

Parameters

raster	: the raster
outasin	: if TRUE, out-db bands are treated as in-db
wkbsize	: will be set to the size of returned wkb form

Returns

WKB of raster or NULL on error

Definition at line 502 of file rt_wkb.c.

                                                                   {
 
#if POSTGIS_DEBUG_LEVEL > 0
        const uint8_t *wkbend = NULL;
#endif
 
        uint8_t *wkb = NULL;
        uint8_t *ptr = NULL;
        uint16_t i = 0;
        uint8_t littleEndian = isMachineLittleEndian();
 
        assert(NULL != raster);
        assert(NULL != wkbsize);
 
        RASTER_DEBUG(2, "rt_raster_to_wkb: about to call rt_raster_wkb_size");
 
        *wkbsize = rt_raster_wkb_size(raster, outasin);
        RASTER_DEBUGF(3, "rt_raster_to_wkb: found size: %d", *wkbsize);
 
        wkb = (uint8_t*) rtalloc(*wkbsize);
        if (!wkb) {
                rterror("rt_raster_to_wkb: Out of memory allocating WKB for raster");
                return NULL;
        }
 
        ptr = wkb;
 
#if POSTGIS_DEBUG_LEVEL > 2
        wkbend = ptr + (*wkbsize);
#endif
        RASTER_DEBUGF(3, "Writing raster header to wkb on position %zu (expected 0)",
                d_binptr_to_pos(ptr, wkbend, *wkbsize));
 
        /* Write endianness */
        *ptr = littleEndian;
        ptr += 1;
 
        /* Write version(size - (end - ptr)) */
        write_uint16(&ptr, littleEndian, 0);
 
        /* Copy header (from numBands up) */
        memcpy(ptr, &(raster->numBands), sizeof (struct rt_raster_serialized_t) - 6);
        ptr += sizeof (struct rt_raster_serialized_t) - 6;
 
        RASTER_DEBUGF(3, "Writing bands header to wkb position %zu (expected 61)",
                d_binptr_to_pos(ptr, wkbend, *wkbsize));
 
        /* Serialize bands now */
        for (i = 0; i < raster->numBands; ++i) {
                rt_band band = raster->bands[i];
                rt_pixtype pixtype = band->pixtype;
                int pixbytes = rt_pixtype_size(pixtype);
 
                RASTER_DEBUGF(3, "Writing WKB for band %d", i);
                RASTER_DEBUGF(3, "Writing band pixel type to wkb position %zu",
                        d_binptr_to_pos(ptr, wkbend, *wkbsize));
 
                if (pixbytes < 1) {
                        rterror("rt_raster_to_wkb: Corrupted band: unknown pixtype");
                        rtdealloc(wkb);
                        return NULL;
                }
 
                /* Add band type */
                *ptr = band->pixtype;
                if (!outasin && band->offline) *ptr |= BANDTYPE_FLAG_OFFDB;
                if (band->hasnodata) *ptr |= BANDTYPE_FLAG_HASNODATA;
                if (band->isnodata) *ptr |= BANDTYPE_FLAG_ISNODATA;
                ptr += 1;
 
#if 0
                /* no padding required for WKB */
                /* Add padding (if needed) */
                if (pixbytes > 1) {
                        memset(ptr, '\0', pixbytes - 1);
                        ptr += pixbytes - 1;
                }
                /* Consistency checking (ptr is pixbytes-aligned) */
                assert(!(((uint64_t) ptr) % pixbytes));
#endif
 
                RASTER_DEBUGF(3, "Writing band nodata to wkb position %zu",
                        d_binptr_to_pos(ptr, wkbend, *wkbsize));
 
                /* Add nodata value */
                switch (pixtype) {
                        case PT_1BB:
                        case PT_2BUI:
                        case PT_4BUI:
                        case PT_8BUI: {
                                uint8_t v = band->nodataval;
                                *ptr = v;
                                ptr += 1;
                                break;
                        }
                        case PT_8BSI: {
                                int8_t v = band->nodataval;
                                *ptr = (uint8_t)v;
                                ptr += 1;
                                break;
                        }
                        case PT_16BSI: {
                                int16_t v = band->nodataval;
                                memcpy(ptr, &v, 2);
                                ptr += 2;
                                break;
                        }
                        case PT_16BUI: {
                                uint16_t v = band->nodataval;
                                memcpy(ptr, &v, 2);
                                ptr += 2;
                                break;
                        }
                        case PT_32BSI: {
                                int32_t v = band->nodataval;
                                memcpy(ptr, &v, 4);
                                ptr += 4;
                                break;
                        }
                        case PT_32BUI: {
                                uint32_t v = band->nodataval;
                                memcpy(ptr, &v, 4);
                                ptr += 4;
                                break;
                        }
                        case PT_16BF: {
                                uint16_t v = rt_util_float_to_float16((float)band->nodataval);
                                memcpy(ptr, &v, 2);
                                ptr += 2;
                                break;
                        }
                        case PT_32BF: {
                                float v = band->nodataval;
                                memcpy(ptr, &v, 4);
                                ptr += 4;
                                break;
                        }
                        case PT_64BF: {
                                memcpy(ptr, &band->nodataval, 8);
                                ptr += 8;
                                break;
                        }
                        default:
                                rterror("rt_raster_to_wkb: Fatal error caused by unknown pixel type. Aborting.");
                                rtdealloc(wkb);
                                abort(); /* shouldn't happen */
                                return 0;
                }
 
#if 0
                /* no padding for WKB */
                /* Consistency checking (ptr is pixbytes-aligned) */
                assert(!((uint64_t) ptr % pixbytes));
#endif
 
                if (!outasin && band->offline) {
                        /* Write band number */
                        *ptr = band->data.offline.bandNum;
                        ptr += 1;
 
                        /* Write path */
                        strcpy((char*) ptr, band->data.offline.path);
                        ptr += strlen(band->data.offline.path) + 1;
                }
                else {
                        /* Write data */
                        uint32_t datasize = raster->width * raster->height * pixbytes;
                        RASTER_DEBUGF(4, "rt_raster_to_wkb: Copying %d bytes", datasize);
 
                        memcpy(ptr, rt_band_get_data(band), datasize);
 
                        ptr += datasize;
                }
 
#if 0
                /* no padding for WKB */
                /* Pad up to 8-bytes boundary */
                while ((uint64_t) ptr % 8) {
                        *ptr = 0;
                        ++ptr;
                }
 
                /* Consistency checking (ptr is pixbytes-aligned) */
                assert(!((uint64_t) ptr % pixbytes));
#endif
        }
 
        return wkb;
}

References BANDTYPE_FLAG_HASNODATA, BANDTYPE_FLAG_ISNODATA, BANDTYPE_FLAG_OFFDB, isMachineLittleEndian(), PT_16BF, PT_16BSI, PT_16BUI, PT_1BB, PT_2BUI, PT_32BF, PT_32BSI, PT_32BUI, PT_4BUI, PT_64BF, PT_8BSI, PT_8BUI, RASTER_DEBUG, RASTER_DEBUGF, rt_band_get_data(), rt_pixtype_size(), rt_raster_wkb_size(), rt_util_float_to_float16(), rtalloc(), rtdealloc(), rterror(), and write_uint16().

Referenced by RASTER_asWKB(), RASTER_to_bytea(), and rt_raster_to_hexwkb().

Here is the call graph for this function:

Here is the caller graph for this function: