rt_band_load_offline_data()

rt_errorstate rt_band_load_offline_data

(

rt_band

band

)

Load offline band's data.

Loaded data is internally owned and should not be released by the caller. Data will be released when band is destroyed with rt_band_destroy().

Parameters

band	: the band who's data to get

Returns

ES_NONE if success, ES_ERROR if failure

Definition at line 331 of file rt_band.c.

References rt_band_t::data, enable_outdb_rasters, ES_ERROR, ES_NONE, window::gt, rt_band_t::hasnodata, rt_band_t::height, rt_band_t::mem, pixval::nband, rt_band_t::nodataval, rt_band_t::offline, rt_band_t::pixtype, rt_band_t::raster, RASTER_DEBUG, RASTER_DEBUGF, rt_raster_destroy(), rt_raster_from_gdal_dataset(), rt_raster_geopoint_to_cell(), rt_raster_get_band(), rt_raster_get_geotransform_matrix(), rt_raster_new(), rt_raster_same_alignment(), rt_raster_set_geotransform_matrix(), rt_raster_set_srid(), rt_util_gdal_open(), rt_util_gdal_register_all(), rt_util_pixtype_to_gdal_datatype(), rtdealloc(), rterror(), rtwarn(), rt_raster_t::srid, and rt_band_t::width.

Referenced by rt_band_get_data(), and test_band_metadata().

                                        {
        GDALDatasetH hdsSrc = NULL;
        int nband = 0;
        VRTDatasetH hdsDst = NULL;
        VRTSourcedRasterBandH hbandDst = NULL;
        double gt[6] = {0.};
        double ogt[6] = {0};
        double offset[2] = {0};

        rt_raster _rast = NULL;
        rt_band _band = NULL;
        int aligned = 0;
        int err = ES_NONE;

        assert(band != NULL);
        assert(band->raster != NULL);

        if (!band->offline) {
                rterror("rt_band_load_offline_data: Band is not offline");
                return ES_ERROR;
        }
        else if (!strlen(band->data.offline.path)) {
                rterror("rt_band_load_offline_data: Offline band does not a have a specified file");
                return ES_ERROR;
        }

        /* offline_data is disabled */
        if (!enable_outdb_rasters) {
                rterror("rt_band_load_offline_data: Access to offline bands disabled");
                return ES_ERROR;
        }

        rt_util_gdal_register_all(0);
        /*
        hdsSrc = rt_util_gdal_open(band->data.offline.path, GA_ReadOnly, 1);
        */
        hdsSrc = rt_util_gdal_open(band->data.offline.path, GA_ReadOnly, 0);
        if (hdsSrc == NULL) {
                rterror("rt_band_load_offline_data: Cannot open offline raster: %s", band->data.offline.path);
                return ES_ERROR;
        }

        /* # of bands */
        nband = GDALGetRasterCount(hdsSrc);
        if (!nband) {
                rterror("rt_band_load_offline_data: No bands found in offline raster: %s", band->data.offline.path);
                GDALClose(hdsSrc);
                return ES_ERROR;
        }
        /* bandNum is 0-based */
        else if (band->data.offline.bandNum + 1 > nband) {
                rterror("rt_band_load_offline_data: Specified band %d not found in offline raster: %s", band->data.offline.bandNum, band->data.offline.path);
                GDALClose(hdsSrc);
                return ES_ERROR;
        }

        /* get raster's geotransform */
        rt_raster_get_geotransform_matrix(band->raster, gt);
        RASTER_DEBUGF(3, "Raster geotransform (%f, %f, %f, %f, %f, %f)",
                gt[0], gt[1], gt[2], gt[3], gt[4], gt[5]);

        /* get offline raster's geotransform */
        if (GDALGetGeoTransform(hdsSrc, ogt) != CE_None) {
                RASTER_DEBUG(4, "Using default geotransform matrix (0, 1, 0, 0, 0, -1)");
                ogt[0] = 0;
                ogt[1] = 1;
                ogt[2] = 0;
                ogt[3] = 0;
                ogt[4] = 0;
                ogt[5] = -1;
        }
        RASTER_DEBUGF(3, "Offline geotransform (%f, %f, %f, %f, %f, %f)",
                ogt[0], ogt[1], ogt[2], ogt[3], ogt[4], ogt[5]);

        /* are rasters aligned? */
        _rast = rt_raster_new(1, 1);
        rt_raster_set_geotransform_matrix(_rast, ogt);
        rt_raster_set_srid(_rast, band->raster->srid);
        err = rt_raster_same_alignment(band->raster, _rast, &aligned, NULL);
        rt_raster_destroy(_rast);

        if (err != ES_NONE) {
                rterror("rt_band_load_offline_data: Could not test alignment of in-db representation of out-db raster");
                GDALClose(hdsSrc);
                return ES_ERROR;
        }
        else if (!aligned) {
                rtwarn("The in-db representation of the out-db raster is not aligned. Band data may be incorrect");
        }

        /* get offsets */
        rt_raster_geopoint_to_cell(
                band->raster,
                ogt[0], ogt[3],
                &(offset[0]), &(offset[1]),
                NULL
        );

        RASTER_DEBUGF(4, "offsets: (%f, %f)", offset[0], offset[1]);

        /* create VRT dataset */
        hdsDst = VRTCreate(band->width, band->height);
        GDALSetGeoTransform(hdsDst, gt);
        /*
        GDALSetDescription(hdsDst, "/tmp/offline.vrt");
        */

        /* add band as simple sources */
        GDALAddBand(hdsDst, rt_util_pixtype_to_gdal_datatype(band->pixtype), NULL);
        hbandDst = (VRTSourcedRasterBandH) GDALGetRasterBand(hdsDst, 1);

        if (band->hasnodata)
                GDALSetRasterNoDataValue(hbandDst, band->nodataval);

        VRTAddSimpleSource(
                hbandDst, GDALGetRasterBand(hdsSrc, band->data.offline.bandNum + 1),
                fabs(offset[0]), fabs(offset[1]),
                band->width, band->height,
                0, 0,
                band->width, band->height,
                "near", VRT_NODATA_UNSET
        );

        /* make sure VRT reflects all changes */
        VRTFlushCache(hdsDst);

        /* convert VRT dataset to rt_raster */
        _rast = rt_raster_from_gdal_dataset(hdsDst);

        GDALClose(hdsDst);
        GDALClose(hdsSrc);
        /*
        {
                FILE *fp;
                fp = fopen("/tmp/gdal_open_files.log", "w");
                GDALDumpOpenDatasets(fp);
                fclose(fp);
        }
        */

        if (_rast == NULL) {
                rterror("rt_band_load_offline_data: Cannot load data from offline raster: %s", band->data.offline.path);
                return ES_ERROR;
        }

        _band = rt_raster_get_band(_rast, 0);
        if (_band == NULL) {
                rterror("rt_band_load_offline_data: Cannot load data from offline raster: %s", band->data.offline.path);
                rt_raster_destroy(_rast);
                return ES_ERROR;
        }

        /* band->data.offline.mem not NULL, free first */
        if (band->data.offline.mem != NULL) {
                rtdealloc(band->data.offline.mem);
                band->data.offline.mem = NULL;
        }

        band->data.offline.mem = _band->data.mem;

        rtdealloc(_band); /* cannot use rt_band_destroy */
        rt_raster_destroy(_rast);

        return ES_NONE;
}

Here is the call graph for this function:

Here is the caller graph for this function: