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 494 of file rt_wkb.c.

References ovdump::band, rt_raster_t::bands, BANDTYPE_FLAG_HASNODATA, BANDTYPE_FLAG_ISNODATA, BANDTYPE_FLAG_OFFDB, rt_band_t::data, rt_band_t::hasnodata, rt_raster_t::height, isMachineLittleEndian(), rt_band_t::isnodata, rt_band_t::nodataval, rt_raster_t::numBands, rt_band_t::offline, rt_band_t::pixtype, 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(), rtalloc(), rtdealloc(), rterror(), rt_raster_t::width, and write_uint16().

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

                                                                   {

#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 %d (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 %d (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 %d",
                        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 %d",
                        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 = v;
                                ptr += 1;
                                break;
                        }
                        case PT_16BSI:
                        case PT_16BUI: {
                                uint16_t v = band->nodataval;
                                memcpy(ptr, &v, 2);
                                ptr += 2;
                                break;
                        }
                        case PT_32BSI:
                        case PT_32BUI: {
                                uint32_t v = band->nodataval;
                                memcpy(ptr, &v, 4);
                                ptr += 4;
                                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(); /* shoudn'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;
}

Here is the call graph for this function:

Here is the caller graph for this function: