void RasterImageLayer::loadFile()
{
GDALDataset *ds = static_cast<GDALDataset*>(GDALOpen(m_filename.toLocal8Bit(), GA_ReadOnly));
if (ds == nullptr)
{
qWarning() << "Error opening file:" << m_filename;
}
else
{
projection().setGeogCS(new OGRSpatialReference(ds->GetProjectionRef()));
projection().setProjCS(new OGRSpatialReference(ds->GetProjectionRef()));
projection().setDomain({-180., -90., 360., 180.});
std::vector<double> geoTransform(6);
int xsize = ds->GetRasterXSize();
int ysize = ds->GetRasterYSize();
ds->GetGeoTransform(geoTransform.data());
vertData.resize(4);
vertData[0] = QVector2D(geoTransform[0], geoTransform[3]);
vertData[1] = QVector2D(geoTransform[0] + geoTransform[2] * ysize,
geoTransform[3] + geoTransform[5] * ysize);
vertData[2] = QVector2D(geoTransform[0] + geoTransform[1] * xsize + geoTransform[2] * ysize,
geoTransform[3] + geoTransform[4] * xsize + geoTransform[5] * ysize);
vertData[3] = QVector2D(geoTransform[0] + geoTransform[1] * xsize,
geoTransform[3] + geoTransform[4] * xsize);
texData = {{0., 0.}, {0., 1.}, {1., 1.}, {1., 0.}};
int numBands = ds->GetRasterCount();
qDebug() << "Bands:" << numBands;
imData = QImage(xsize, ysize, QImage::QImage::Format_RGBA8888);
imData.fill(QColor(255, 255, 255, 255));
// Bands start at 1
for (int i = 1; i <= numBands; ++i)
{
GDALRasterBand *band = ds->GetRasterBand(i);
switch(band->GetColorInterpretation())
{
case GCI_RedBand:
band->RasterIO(GF_Read, 0, 0, xsize, ysize, imData.bits(),
xsize, ysize, GDT_Byte, 4, 0);
break;
case GCI_GreenBand:
band->RasterIO(GF_Read, 0, 0, xsize, ysize, imData.bits() + 1,
xsize, ysize, GDT_Byte, 4, 0);
break;
case GCI_BlueBand:
band->RasterIO(GF_Read, 0, 0, xsize, ysize, imData.bits() + 2,
xsize, ysize, GDT_Byte, 4, 0);
break;
default:
qWarning() << "Unhandled color interpretation:" << band->GetColorInterpretation();
}
}
GDALClose(ds);
newFile = true;
}
}
Raster* import_raster(string raster_filename, int band_number) {
GDALAllRegister();
GDALDataset* poDataset = (GDALDataset *) GDALOpen( raster_filename.c_str(), GA_ReadOnly );
if( poDataset == NULL ) {
cerr << "Error: Could not open raster data file" << endl;
exit(1);
}
fprintf(stderr, "Driver: %s/%s\n", poDataset->GetDriver()->GetDescription(), poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) );
fprintf(stderr, "Size is %dx%dx%d\n", poDataset->GetRasterXSize(), poDataset->GetRasterYSize(), poDataset->GetRasterCount() );
if( poDataset->GetProjectionRef() != NULL ) cerr << "Projection is `" << poDataset->GetProjectionRef() << "'" << endl;;
GDALRasterBand* poBand = poDataset->GetRasterBand( band_number );
int nBlockXSize, nBlockYSize;
poBand->GetBlockSize( &nBlockXSize, &nBlockYSize );
fprintf(stderr, "Block=%dx%d Type=%s, ColorInterp=%s\n",
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(poBand->GetRasterDataType()),
GDALGetColorInterpretationName( poBand->GetColorInterpretation()) );
Raster* raster = extract_raster_attributes( poDataset );
raster->band = poBand;
return raster;
}
PLCLine *PLCContext::getOutputLine(int line)
{
CPLAssert( outputDS != NULL );
int i, width = outputDS->GetRasterXSize();
PLCLine *lineObj = new PLCLine(width);
for( i=0; i < outputDS->GetRasterCount(); i++ )
{
CPLErr eErr;
GDALRasterBand *band = outputDS->GetRasterBand(i+1);
if( band->GetColorInterpretation() == GCI_AlphaBand )
eErr = band->RasterIO(GF_Read, 0, line, width, 1,
lineObj->getAlpha(), width, 1, GDT_Byte,
0, 0);
else
eErr = band->RasterIO(GF_Read, 0, line, width, 1,
lineObj->getBand(i), width, 1, GDT_Int16,
0, 0);
if( eErr != CE_None )
exit(1);
}
return lineObj;
}
void DemReader::MetaDataInfo(GDALDataset* gdalDataset, MapControllerPtr mapController)
{
FileMetaData* header = mapController->GetMapModel()->GetMetaData();
header->driverDesc = gdalDataset->GetDriver()->GetDescription();
header->driverMetaData = gdalDataset->GetDriver()->GetMetadataItem(GDAL_DMD_LONGNAME);
Log::Inst().Write("Driver: " + header->driverDesc + " \\ " + header->driverMetaData);
header->xSize = gdalDataset->GetRasterXSize();
header->ySize = gdalDataset->GetRasterYSize();
header->bands = gdalDataset->GetRasterCount();
Log::Inst().Write("Size (x,y): " +
StringTools::ToString(header->xSize) + ", " +
StringTools::ToString(header->ySize));
Log::Inst().Write("Bands: " + StringTools::ToString(header->bands));
header->projection = std::string(gdalDataset->GetProjectionRef());
Log::Inst().Write("Projection: " + header->projection);
double adfGeoTransform[6];
gdalDataset->GetGeoTransform( adfGeoTransform );
header->originX = adfGeoTransform[0];
header->originY = adfGeoTransform[3];
Log::Inst().Write("Origin: " +
StringTools::ToString(adfGeoTransform[0]) + ", " +
StringTools::ToString(adfGeoTransform[3]));
header->pixelSizeX = adfGeoTransform[1];
header->pixelSizeY = adfGeoTransform[5];
Log::Inst().Write("Pixel Size: " +
StringTools::ToString(adfGeoTransform[1]) + ", " +
StringTools::ToString(adfGeoTransform[5]));
GDALRasterBand* gdalBand = gdalDataset->GetRasterBand(1);
int nBlockXSize, nBlockYSize;
gdalBand->GetBlockSize(&nBlockXSize, &nBlockYSize);
header->dataType = std::string(GDALGetDataTypeName(gdalBand->GetRasterDataType()));
Log::Inst().Write("Block, Type: " + StringTools::ToString(nBlockXSize) + ", " +
StringTools::ToString(nBlockYSize) + ", " +
std::string(header->dataType));
header->colourInterpretation = std::string(GDALGetColorInterpretationName(gdalBand->GetColorInterpretation()));
Log::Inst().Write("Color Interpretation: " + header->colourInterpretation);
header->extents.x = adfGeoTransform[0];
header->extents.y = adfGeoTransform[3] + gdalBand->GetYSize()*adfGeoTransform[5];
Log::Inst().Write("Lower, Left (x,y): " +
StringTools::ToString(header->extents.x) + ", " +
StringTools::ToString(header->extents.y));
header->extents.dx = adfGeoTransform[0]+gdalBand->GetXSize()*adfGeoTransform[1];
header->extents.dy = adfGeoTransform[3];
Log::Inst().Write("Upper, Right (x,y): " +
StringTools::ToString(header->extents.dx) + ", " +
StringTools::ToString(header->extents.dy));
Log::Inst().Write("");
}
bool getRawValuesFromFile(string fname,vector<vector<float>>& vecs)
{
//vector<float> temp = vector<float>()
GDALDataset *poDataset;
GDALAllRegister();
poDataset= (GDALDataset*) GDALOpen(fname.c_str(),GA_ReadOnly);
if(poDataset == NULL)
{
cout << "OUCH!" << endl;
return false;
}
cout << "Data size: " << GDALGetRasterXSize(poDataset) << " " << GDALGetRasterYSize(poDataset) << endl;
GDALRasterBand *poBand;
int nBlockXSize, nBlockYSize;
int bGotMin, bGotMax;
double adfMinMax[2];
poBand = poDataset->GetRasterBand( 1 );
poBand->GetBlockSize( &nBlockXSize, &nBlockYSize );
printf( "Block=%dx%d Type=%s, ColorInterp=%s\n",
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(poBand->GetRasterDataType()),
GDALGetColorInterpretationName(
poBand->GetColorInterpretation()) );
adfMinMax[0] = poBand->GetMinimum( &bGotMin );
adfMinMax[1] = poBand->GetMaximum( &bGotMax );
if( ! (bGotMin && bGotMax) )
GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax);
int width = poBand->GetXSize();
int height = poBand->GetYSize();
int bands = poDataset->GetRasterCount();
float *pafScanline;
std::cout << "Before allocation" << adfMinMax[0] << " " << adfMinMax[1] << endl;
int dsize = 256;
pafScanline = (float *) CPLMalloc(sizeof(float)*width*height);
vector<vector<float>> out = vector<vector<float>>(height,vector<float> (width,0));
poBand->RasterIO(GF_Read,0,0,width,height,pafScanline,width,height,GDT_Float32,0,0);
cout << "After allocation" << endl;
for(int i = 0; i < height; i++)
{
for(int j = 0; j < width; j++)
{
//cout << i << j << endl << pafS;
out[i][j] = pafScanline[i*width+j];
}
}
CPLFree(pafScanline);
//for(auto i : out)
//for(auto j : i)
// cout << j << endl;
cout << "After allocation" << endl;
vecs = out;
return true;
}
int main()
{
GDALDataset *poDataset;
GDALAllRegister();
poDataset = (GDALDataset *) GDALOpen( "GE01.tif", GA_ReadOnly );
printf("Working! \n");
if( poDataset != NULL ){
//Get Dataset Information
double adfGeoTransform[6];
printf( "Driver: %s/%s\n", poDataset->GetDriver()->GetDescription(), poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) );
printf( "Size is %dx%dx%d\n", poDataset->GetRasterXSize(), poDataset->GetRasterYSize(), poDataset->GetRasterCount() );
if( poDataset->GetProjectionRef() != NULL )
printf( "Projection is `%s'\n", poDataset->GetProjectionRef() );
if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None ){
printf( "Origin = (%.6f,%.6f)\n",
adfGeoTransform[0], adfGeoTransform[3] );
printf( "Pixel Size = (%.6f,%.6f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
}
//Fetch Raster Band
GDALRasterBand *poBand;
int nBlockXSize, nBlockYSize;
int bGotMin, bGotMax;
double adfMinMax[2];
poBand = poDataset->GetRasterBand( 1 );
poBand->GetBlockSize( &nBlockXSize, &nBlockYSize );
printf( "Block=%dx%d Type=%s, ColorInterp=%s\n",
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(poBand->GetRasterDataType()),
GDALGetColorInterpretationName(
poBand->GetColorInterpretation()) );
adfMinMax[0] = poBand->GetMinimum( &bGotMin );
adfMinMax[1] = poBand->GetMaximum( &bGotMax );
if( ! (bGotMin && bGotMax) )
GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax);
printf( "Min=%.3fd, Max=%.3f\n", adfMinMax[0], adfMinMax[1] );
if( poBand->GetOverviewCount() > 0 )
printf( "Band has %d overviews.\n", poBand->GetOverviewCount() );
if( poBand->GetColorTable() != NULL )
printf( "Band has a color table with %d entries.\n",
poBand->GetColorTable()->GetColorEntryCount() );
//Close Dataset
GDALClose(poDataset);
//Exit
return 0;
}
}
SEXP
RGDAL_GetColorInterp(SEXP sxpRasterBand) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
GDALColorInterp eCI = pRasterBand->GetColorInterpretation();
return(mkString_safe(GDALGetColorInterpretationName(eCI)));
}
int
NBHeightMapper::loadTiff(const std::string& file) {
#ifdef HAVE_GDAL
GDALAllRegister();
GDALDataset* poDataset = (GDALDataset*)GDALOpen(file.c_str(), GA_ReadOnly);
if (poDataset == 0) {
WRITE_ERROR("Cannot load GeoTIFF file.");
return 0;
}
const int xSize = poDataset->GetRasterXSize();
const int ySize = poDataset->GetRasterYSize();
double adfGeoTransform[6];
if (poDataset->GetGeoTransform(adfGeoTransform) == CE_None) {
Position topLeft(adfGeoTransform[0], adfGeoTransform[3]);
mySizeOfPixel.set(adfGeoTransform[1], adfGeoTransform[5]);
const double horizontalSize = xSize * mySizeOfPixel.x();
const double verticalSize = ySize * mySizeOfPixel.y();
myBoundary.add(topLeft);
myBoundary.add(topLeft.x() + horizontalSize, topLeft.y() + verticalSize);
} else {
WRITE_ERROR("Could not parse geo information from " + file + ".");
return 0;
}
const int picSize = xSize * ySize;
myRaster = (int16_t*)CPLMalloc(sizeof(int16_t) * picSize);
for (int i = 1; i <= poDataset->GetRasterCount(); i++) {
GDALRasterBand* poBand = poDataset->GetRasterBand(i);
if (poBand->GetColorInterpretation() != GCI_GrayIndex) {
WRITE_ERROR("Unknown color band in " + file + ".");
clearData();
break;
}
if (poBand->GetRasterDataType() != GDT_Int16) {
WRITE_ERROR("Unknown data type in " + file + ".");
clearData();
break;
}
assert(xSize == poBand->GetXSize() && ySize == poBand->GetYSize());
if (poBand->RasterIO(GF_Read, 0, 0, xSize, ySize, myRaster, xSize, ySize, GDT_Int16, 0, 0) == CE_Failure) {
WRITE_ERROR("Failure in reading " + file + ".");
clearData();
break;
}
}
GDALClose(poDataset);
return picSize;
#else
UNUSED_PARAMETER(file);
WRITE_ERROR("Cannot load GeoTIFF file since SUMO was compiled without GDAL support.");
return 0;
#endif
}
SEXP
RGDAL_GetColorInterp(SEXP sxpRasterBand) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
installErrorHandler();
GDALColorInterp eCI = pRasterBand->GetColorInterpretation();
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
const char *desc = GDALGetColorInterpretationName(eCI);
uninstallErrorHandlerAndTriggerError();
return(mkString_safe(desc));
}
wxGISRasterLayer::wxGISRasterLayer(const wxString &sName, wxGISDataset* pwxGISDataset) : wxGISLayer(sName, pwxGISDataset)
{
wxGISRasterDataset* pwxGISRasterDataset = wxDynamicCast(pwxGISDataset, wxGISRasterDataset);
if(pwxGISRasterDataset)
{
if(m_sName.IsEmpty())
m_sName = pwxGISRasterDataset->GetName();
m_SpatialReference = pwxGISRasterDataset->GetSpatialReference();
m_FullEnvelope = pwxGISRasterDataset->GetEnvelope();
//TODO: load or get all renderers and check if i render can draw this dataset. If yes - set it as current
if(pwxGISRasterDataset->GetBandCount() >= 3)
{
m_pRenderer = new wxGISRasterRGBARenderer(pwxGISDataset);
}
else
{
GDALDataset* poGDALDataset = pwxGISRasterDataset->GetMainRaster();
if(!poGDALDataset)
poGDALDataset = pwxGISRasterDataset->GetRaster();
if(!poGDALDataset)
return;
GDALRasterBand* pBand = poGDALDataset->GetRasterBand(1);
GDALColorInterp eColorInterpretation = pBand->GetColorInterpretation();
if( eColorInterpretation == GCI_PaletteIndex )
{
m_pRenderer = new wxGISRasterRasterColormapRenderer(pwxGISDataset);
}
else if(pBand->GetRasterDataType() == GDT_Int32)
{
m_pRenderer = new wxGISRasterPackedRGBARenderer(pwxGISDataset);
}
else// if( eColorInterpretation == GCI_GrayIndex )
{
//TODO: else RasterStretchColorRampRenderer
m_pRenderer = new wxGISRasterGreyScaleRenderer(pwxGISDataset);
}
}
}
}
void PLCContext::writeOutputLine(int line, PLCLine *lineObj)
{
CPLAssert( outputDS != NULL );
int i, width = outputDS->GetRasterXSize();
for( i=0; i < outputDS->GetRasterCount(); i++ )
{
CPLErr eErr;
GDALRasterBand *band = outputDS->GetRasterBand(i+1);
if( band->GetColorInterpretation() == GCI_AlphaBand )
eErr = band->RasterIO(GF_Write, 0, line, width, 1,
lineObj->getAlpha(), width, 1, GDT_Byte,
0, 0);
else
eErr = band->RasterIO(GF_Write, 0, line, width, 1,
lineObj->getBand(i), width, 1, GDT_Int16,
0, 0);
if( eErr != CE_None )
exit(1);
if( sourceTraceDS != NULL )
{
eErr = sourceTraceDS->GetRasterBand(1)->
RasterIO(GF_Write, 0, line, width, 1,
lineObj->getSource(), width, 1, GDT_UInt16,
0, 0);
}
if( qualityDS != NULL )
{
eErr = qualityDS->GetRasterBand(1)->
RasterIO(GF_Write, 0, line, width, 1,
lineObj->getQuality(), width, 1, GDT_Float32,
0, 0);
}
}
}
void readFrames( int argc, char* argv[] )
{
pfs::DOMIO pfsio;
bool verbose = false;
// Parse command line parameters
static struct option cmdLineOptions[] = {
{ "help", no_argument, NULL, 'h' },
{ "verbose", no_argument, NULL, 'v' },
{ NULL, 0, NULL, 0 }
};
static const char optstring[] = "hv";
pfs::FrameFileIterator it( argc, argv, "rb", NULL, NULL,
optstring, cmdLineOptions );
int optionIndex = 0;
while( 1 ) {
int c = getopt_long (argc, argv, optstring, cmdLineOptions, &optionIndex);
if( c == -1 ) break;
switch( c ) {
case 'h':
printHelp();
throw QuietException();
case 'v':
verbose = true;
break;
case '?':
throw QuietException();
case ':':
throw QuietException();
}
}
GDALAllRegister();
GDALDataset *poDataset;
GDALRasterBand *poBand;
double adfGeoTransform[6];
size_t nBlockXSize, nBlockYSize, nBands;
int bGotMin, bGotMax;
double adfMinMax[2];
float *pafScanline;
while( true ) {
pfs::FrameFile ff = it.getNextFrameFile();
if( ff.fh == NULL ) break; // No more frames
it.closeFrameFile( ff );
VERBOSE_STR << "reading file '" << ff.fileName << "'" << std::endl;
if( !( poDataset = (GDALDataset *) GDALOpen( ff.fileName, GA_ReadOnly ) ) ) {
std::cerr << "input does not seem to be in a format supported by GDAL" << std::endl;
throw QuietException();
}
VERBOSE_STR << "GDAL driver: " << poDataset->GetDriver()->GetDescription()
<< " / " << poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) << std::endl;
nBlockXSize = poDataset->GetRasterXSize();
nBlockYSize = poDataset->GetRasterYSize();
nBands = poDataset->GetRasterCount();
VERBOSE_STR << "Data size " << nBlockXSize << "x" << nBlockYSize << "x" << nBands << std::endl;
if( poDataset->GetProjectionRef() ) {
VERBOSE_STR << "Projection " << poDataset->GetProjectionRef() << std::endl;
}
if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None ) {
VERBOSE_STR << "Origin = (" << adfGeoTransform[0] << ", " << adfGeoTransform[3] << ")" << std::endl;
VERBOSE_STR << "Pixel Size = (" << adfGeoTransform[1] << ", " << adfGeoTransform[5] << ")" << std::endl;
}
if( nBlockXSize==0 || nBlockYSize==0
|| ( SIZE_MAX / nBlockYSize < nBlockXSize )
|| ( SIZE_MAX / (nBlockXSize * nBlockYSize ) < 4 ) ) {
std::cerr << "input data has invalid size" << std::endl;
throw QuietException();
}
if( !(pafScanline = (float *) CPLMalloc( sizeof(float) * nBlockXSize ) ) ) {
std::cerr << "not enough memory" << std::endl;
throw QuietException();
}
pfs::Frame *frame = pfsio.createFrame( nBlockXSize, nBlockYSize );
pfs::Channel *C[nBands];
char channel_name[32];
frame->getTags()->setString( "X-GDAL_DRIVER_SHORTNAME", poDataset->GetDriver()->GetDescription() );
frame->getTags()->setString( "X-GDAL_DRIVER_LONGNAME", poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) );
frame->getTags()->setString( "X-PROJECTION", poDataset->GetProjectionRef() );
if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None ) {
frame->getTags()->setString( "X-ORIGIN_X", stringify(adfGeoTransform[0]).c_str() );
frame->getTags()->setString( "X-ORIGIN_Y", stringify(adfGeoTransform[3]).c_str() );
frame->getTags()->setString( "X-PIXEL_WIDTH", stringify(adfGeoTransform[1]).c_str() );
frame->getTags()->setString( "X-PIXEL_HEIGHT", stringify(adfGeoTransform[5]).c_str() );
}
for ( size_t band = 1; band <= nBands; band++) {
size_t nBandXSize, nBandYSize;
VERBOSE_STR << "Band " << band << ": " << std::endl;
snprintf( channel_name, 32, "X-GDAL%zu", band );
C[band - 1] = frame->createChannel( channel_name );
poBand = poDataset->GetRasterBand( band );
nBandXSize = poBand->GetXSize();
nBandYSize = poBand->GetYSize();
VERBOSE_STR << " " << nBandXSize << "x" << nBandYSize << std::endl;
if( nBandXSize != (int)nBlockXSize || nBandYSize != (int)nBlockYSize ) {
std::cerr << "data in band " << band << " has different size" << std::endl;
throw QuietException();
}
VERBOSE_STR << " Type " << GDALGetDataTypeName( poBand->GetRasterDataType() ) << ", "
<< "Color Interpretation " << GDALGetColorInterpretationName( poBand->GetColorInterpretation() ) << std::endl;
adfMinMax[0] = poBand->GetMinimum( &bGotMin );
adfMinMax[1] = poBand->GetMaximum( &bGotMax );
if( ! (bGotMin && bGotMax) ) {
GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax);
}
VERBOSE_STR << " Min " << adfMinMax[0] << ", Max " << adfMinMax[1] << std::endl;
C[band - 1]->getTags()->setString( "X-TYPE",
GDALGetDataTypeName( poBand->GetRasterDataType() ) );
C[band - 1]->getTags()->setString( "X-COLOR_INTERPRETATION",
GDALGetColorInterpretationName( poBand->GetColorInterpretation() ) );
C[band - 1]->getTags()->setString( "X-MIN", stringify(adfMinMax[0]).c_str() );
C[band - 1]->getTags()->setString( "X-MAX", stringify(adfMinMax[1]).c_str() );
for( size_t y = 0; y < nBlockYSize; y++ ) {
if( poBand->RasterIO( GF_Read, 0, y, nBlockXSize, 1, pafScanline,
nBlockXSize, 1, GDT_Float32, 0, 0) != CE_None ) {
std::cerr << "input error" << std::endl;
throw QuietException();
}
memcpy( C[band - 1]->getRawData() + y * nBlockXSize, pafScanline, nBlockXSize * sizeof(float) );
}
}
CPLFree( pafScanline );
GDALClose( poDataset );
const char *fileNameTag = strcmp( "-", ff.fileName )==0 ? "stdin" : ff.fileName;
frame->getTags()->setString( "FILE_NAME", fileNameTag );
pfsio.writeFrame( frame, stdout );
pfsio.freeFrame( frame );
}
}
bool GdalAdapter::loadImage(const QString& fn)
{
if (alreadyLoaded(fn))
return true;
QFileInfo fi(fn);
GdalImage img;
QRectF bbox;
poDataset = (GDALDataset *) GDALOpen( QDir::toNativeSeparators(fi.absoluteFilePath()).toUtf8().constData(), GA_ReadOnly );
if( poDataset == NULL )
{
qDebug() << "GDAL Open failed: " << fn;
return false;
}
bool hasGeo = false;
QDir dir(fi.absoluteDir());
QString f = fi.baseName();
QStringList wldFilter;
wldFilter << f+".tfw" << f+".tifw" << f+".tiffw" << f+".wld";
QFileInfoList fil = dir.entryInfoList(wldFilter);
if (fil.count()) {
QFile wld(fil[0].absoluteFilePath());
if (wld.open(QIODevice::ReadOnly)) {
int i;
for (i=0; i<6; ++i) {
if (wld.atEnd())
break;
QString l = wld.readLine();
bool ok;
double d = l.toDouble(&ok);
if (!ok)
break;
switch (i) {
case 0:
img.adfGeoTransform[1] = d;
break;
case 1:
img.adfGeoTransform[4] = d;
break;
case 2:
img.adfGeoTransform[2] = d;
break;
case 3:
img.adfGeoTransform[5] = d;
break;
case 4:
img.adfGeoTransform[0] = d;
break;
case 5:
img.adfGeoTransform[3] = d;
break;
}
}
if (i == 6)
hasGeo = true;
}
}
if(!hasGeo)
if ( poDataset->GetGeoTransform( img.adfGeoTransform ) != CE_None ) {
GDALClose((GDALDatasetH)poDataset);
return false;
}
qDebug( "Origin = (%.6f,%.6f)\n",
img.adfGeoTransform[0], img.adfGeoTransform[3] );
qDebug( "Pixel Size = (%.6f,%.6f)\n",
img.adfGeoTransform[1], img.adfGeoTransform[5] );
bbox.setTopLeft(QPointF(img.adfGeoTransform[0], img.adfGeoTransform[3]));
bbox.setWidth(img.adfGeoTransform[1]*poDataset->GetRasterXSize());
bbox.setHeight(img.adfGeoTransform[5]*poDataset->GetRasterYSize());
isLatLon = false;
if( strlen(poDataset->GetProjectionRef()) != 0 ) {
qDebug( "Projection is `%s'\n", poDataset->GetProjectionRef() );
OGRSpatialReference* theSrs = new OGRSpatialReference(poDataset->GetProjectionRef());
if (theSrs && theSrs->Validate() == OGRERR_NONE) {
theSrs->morphFromESRI();
char* theProj4;
if (theSrs->exportToProj4(&theProj4) == OGRERR_NONE) {
qDebug() << "GDAL: to proj4 : " << theProj4;
} else {
qDebug() << "GDAL: to proj4 error: " << CPLGetLastErrorMsg();
GDALClose((GDALDatasetH)poDataset);
return false;
}
QString srsProj = QString(theProj4);
if (!srsProj.isEmpty() && theProjection != srsProj) {
cleanup();
theProjection = srsProj;
}
isLatLon = (theSrs->IsGeographic() == TRUE);
}
}
if (theProjection.isEmpty()) {
theProjection = ProjectionChooser::getProjection(QCoreApplication::translate("ImportExportGdal", "Unable to set projection; please specify one"));
if (theProjection.isEmpty()) {
GDALClose((GDALDatasetH)poDataset);
return false;
}
}
qDebug( "Driver: %s/%s\n",
poDataset->GetDriver()->GetDescription(),
poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) );
qDebug( "Size is %dx%dx%d\n",
poDataset->GetRasterXSize(), poDataset->GetRasterYSize(),
poDataset->GetRasterCount() );
GdalAdapter::ImgType theType = GdalAdapter::Unknown;
int bandCount = poDataset->GetRasterCount();
int ixA = -1;
int ixR, ixG, ixB;
int ixH, ixS, ixL;
int ixC, ixM, ixY, ixK;
int ixYuvY, ixYuvU, ixYuvV;
double adfMinMax[2];
double UnknownUnit;
GDALColorTable* colTable = NULL;
for (int i=0; i<bandCount; ++i) {
GDALRasterBand *poBand = poDataset->GetRasterBand( i+1 );
GDALColorInterp bandtype = poBand->GetColorInterpretation();
qDebug() << "Band " << i+1 << " Color: " << GDALGetColorInterpretationName(poBand->GetColorInterpretation());
switch (bandtype)
{
case GCI_Undefined:
theType = GdalAdapter::Unknown;
int bGotMin, bGotMax;
adfMinMax[0] = poBand->GetMinimum( &bGotMin );
adfMinMax[1] = poBand->GetMaximum( &bGotMax );
if( ! (bGotMin && bGotMax) )
GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax);
UnknownUnit = (adfMinMax[1] - adfMinMax[0]) / 256;
break;
case GCI_GrayIndex:
theType = GdalAdapter::GrayScale;
break;
case GCI_RedBand:
theType = GdalAdapter::Rgb;
ixR = i;
break;
case GCI_GreenBand:
theType = GdalAdapter::Rgb;
ixG = i;
break;
case GCI_BlueBand :
theType = GdalAdapter::Rgb;
ixB = i;
break;
case GCI_HueBand:
theType = GdalAdapter::Hsl;
ixH = i;
break;
case GCI_SaturationBand:
theType = GdalAdapter::Hsl;
ixS = i;
break;
case GCI_LightnessBand:
theType = GdalAdapter::Hsl;
ixL = i;
break;
case GCI_CyanBand:
theType = GdalAdapter::Cmyk;
ixC = i;
break;
case GCI_MagentaBand:
theType = GdalAdapter::Cmyk;
ixM = i;
break;
case GCI_YellowBand:
theType = GdalAdapter::Cmyk;
ixY = i;
break;
case GCI_BlackBand:
theType = GdalAdapter::Cmyk;
ixK = i;
break;
case GCI_YCbCr_YBand:
theType = GdalAdapter::YUV;
ixYuvY = i;
break;
case GCI_YCbCr_CbBand:
theType = GdalAdapter::YUV;
ixYuvU = i;
break;
case GCI_YCbCr_CrBand:
theType = GdalAdapter::YUV;
ixYuvV = i;
break;
case GCI_AlphaBand:
ixA = i;
break;
case GCI_PaletteIndex:
colTable = poBand->GetColorTable();
switch (colTable->GetPaletteInterpretation())
{
case GPI_Gray :
theType = GdalAdapter::Palette_Gray;
break;
case GPI_RGB :
theType = GdalAdapter::Palette_RGBA;
break;
case GPI_CMYK :
theType = GdalAdapter::Palette_CMYK;
break;
case GPI_HLS :
theType = GdalAdapter::Palette_HLS;
break;
}
break;
}
}
QSize theImgSize(poDataset->GetRasterXSize(), poDataset->GetRasterYSize());
QImage theImg = QImage(theImgSize, QImage::Format_ARGB32);
// Make sure that lineBuf holds one whole line of data.
float *lineBuf;
lineBuf = (float *) CPLMalloc(theImgSize.width() * bandCount * sizeof(float));
int px, py;
//every row loop
for (int row = 0; row < theImgSize.height(); row++) {
py = row;
poDataset->RasterIO( GF_Read, 0, row, theImgSize.width(), 1, lineBuf, theImgSize.width(), 1, GDT_Float32,
bandCount, NULL, sizeof(float) * bandCount, 0, sizeof(float) );
// every pixel in row.
for (int col = 0; col < theImgSize.width(); col++){
px = col;
switch (theType)
{
case GdalAdapter::Unknown:
{
float* v = lineBuf + (col*bandCount);
float val = (*v - adfMinMax[0]) / UnknownUnit;
theImg.setPixel(px, py, qRgb(val, val, val));
break;
}
case GdalAdapter::GrayScale:
{
float* v = lineBuf + (col*bandCount);
theImg.setPixel(px, py, qRgb(*v, *v, *v));
break;
}
case GdalAdapter::Rgb:
{
float* r = lineBuf + (col*bandCount) + ixR;
float* g = lineBuf + (col*bandCount) + ixG;
float* b = lineBuf + (col*bandCount) + ixB;
int a = 255;
if (ixA != -1) {
float* fa = lineBuf + (col*bandCount) + ixA;
a = *fa;
}
theImg.setPixel(px, py, qRgba(*r, *g, *b, a));
break;
}
#if QT_VERSION >= 0x040600
case GdalAdapter::Hsl:
{
float* h = lineBuf + (col*bandCount) + ixH;
float* s = lineBuf + (col*bandCount) + ixS;
float* l = lineBuf + (col*bandCount) + ixL;
int a = 255;
if (ixA != -1) {
float* fa = lineBuf + (col*bandCount) + ixA;
a = *fa;
}
QColor C = QColor::fromHsl(*h, *s, *l, a);
theImg.setPixel(px, py, C.rgba());
break;
}
#endif
case GdalAdapter::Cmyk:
{
float* c = lineBuf + (col*bandCount) + ixC;
float* m = lineBuf + (col*bandCount) + ixM;
float* y = lineBuf + (col*bandCount) + ixY;
float* k = lineBuf + (col*bandCount) + ixK;
int a = 255;
if (ixA != -1) {
float* fa = lineBuf + (col*bandCount) + ixA;
a = *fa;
}
QColor C = QColor::fromCmyk(*c, *m, *y, *k, a);
theImg.setPixel(px, py, C.rgba());
break;
}
case GdalAdapter::YUV:
{
// From http://www.fourcc.org/fccyvrgb.php
float* y = lineBuf + (col*bandCount) + ixYuvY;
float* u = lineBuf + (col*bandCount) + ixYuvU;
float* v = lineBuf + (col*bandCount) + ixYuvV;
int a = 255;
if (ixA != -1) {
float* fa = lineBuf + (col*bandCount) + ixA;
a = *fa;
}
float R = 1.164*(*y - 16) + 1.596*(*v - 128);
float G = 1.164*(*y - 16) - 0.813*(*v - 128) - 0.391*(*u - 128);
float B = 1.164*(*y - 16) + 2.018*(*u - 128);
theImg.setPixel(px, py, qRgba(R, G, B, a));
break;
}
case GdalAdapter::Palette_Gray:
{
float* ix = (lineBuf + (col*bandCount));
const GDALColorEntry* color = colTable->GetColorEntry(*ix);
theImg.setPixel(px, py, qRgb(color->c1, color->c1, color->c1));
break;
}
case GdalAdapter::Palette_RGBA:
{
float* ix = (lineBuf + (col*bandCount));
const GDALColorEntry* color = colTable->GetColorEntry(*ix);
theImg.setPixel(px, py, qRgba(color->c1, color->c2, color->c3, color->c4));
break;
}
#if QT_VERSION >= 0x040600
case GdalAdapter::Palette_HLS:
{
float* ix = (lineBuf + (col*bandCount));
const GDALColorEntry* color = colTable->GetColorEntry(*ix);
QColor C = QColor::fromHsl(color->c1, color->c2, color->c3, color->c4);
theImg.setPixel(px, py, C.rgba());
break;
}
#endif
case GdalAdapter::Palette_CMYK:
{
float* ix = (lineBuf + (col*bandCount));
const GDALColorEntry* color = colTable->GetColorEntry(*ix);
QColor C = QColor::fromCmyk(color->c1, color->c2, color->c3, color->c4);
theImg.setPixel(px, py, C.rgba());
break;
}
}
}
QCoreApplication::processEvents();
}
img.theFilename = fn;
img.theImg = QPixmap::fromImage(theImg);
theImages.push_back(img);
theBbox = theBbox.united(bbox);
GDALClose((GDALDatasetH)poDataset);
return true;
}
void generateTexture(string fname, GLuint& tex, int bandnum)
{
if(bandnum <= 0 )
{
bandnum = 1;
}
GDALDataset *poDataset;
GDALAllRegister();
poDataset= (GDALDataset*) GDALOpen(fname.c_str(),GA_ReadOnly);
if(poDataset == NULL)
{
cout << "OUCH!" << endl;
//exit(0);
return;
}
cout << "Data size: " << GDALGetRasterXSize(poDataset) << " " << GDALGetRasterYSize(poDataset) << endl;
GDALRasterBand *poBand;
int nBlockXSize, nBlockYSize;
int bGotMin, bGotMax;
double adfMinMax[2];
int bands = poDataset->GetRasterCount();
bandnum = bandnum % bands + 1;
if(bandnum > bands)
{
bandnum = 1;
}
poBand = poDataset->GetRasterBand( bandnum );
poBand->GetBlockSize( &nBlockXSize, &nBlockYSize );
printf( "Block=%dx%d Type=%s, ColorInterp=%s\n",
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(poBand->GetRasterDataType()),
GDALGetColorInterpretationName(
poBand->GetColorInterpretation()) );
float max = adfMinMax[0] = poBand->GetMinimum( &bGotMin );
float min = adfMinMax[1] = poBand->GetMaximum( &bGotMax );
if( ! (bGotMin && bGotMax) )
GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax);
int width = poBand->GetXSize();
int height = poBand->GetYSize();
float *pafScanline;
std::cout << "Before allocation" << adfMinMax[0] << " " << adfMinMax[1] << endl;
min = adfMinMax[0];
max = adfMinMax[1];
int dsize = 256;
pafScanline = (float *) CPLMalloc(sizeof(float)*512*512);
vector<vector<float>> out = vector<vector<float>>(height,vector<float> (width,0));
//vector<vector<unsigned char>> texs = vector<vector<unsigned char>>(height,vector<unsigned char> (width,0));
unsigned char texs[512*512];
poBand->RasterIO(GF_Read,0,0,width,height,pafScanline,512,512,GDT_Float32,0,0);
float no = poBand->GetNoDataValue();
cout << "After allocation" << endl;
for(int i = 0; i < 512; i++)
{
for(int j = 0; j < 512; j++)
{
//cout << i << j << endl << pafS;
if(pafScanline[i*width+j] != no)
{
// set tex val
texs[i*512+j] = (unsigned char)(255*((pafScanline[i*512+j] - min)/(max-min)));
//if((int)texs[i*width] < 0)
//cout << (int)texs[i*512 +j] << " " << pafScanline[i*512+j] << " " << no << " " << fname << " " << min << " " << max << endl;
}
else
{
// Set zero val
texs[i*512+j] = 0;
//cout << (int)texs[i*512 +j] << fname << endl;
}
//texs[i*512+j] = 255;
//ut[i][j] = pafScanline[i*width+j];
}
}
CPLFree(pafScanline);
//exit(0);
// Create a texture
glGenTextures(1,&tex);
glBindTexture(GL_TEXTURE_2D,tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, 512,512, 0, GL_RED, GL_UNSIGNED_BYTE,texs);
GDALClose( (GDALDatasetH) poDataset);
return;
}
int readRaster(const char* pszFilename)
{
// Set config options for GDAL (needs >= 2.0). Setting GTIFF_VIRTUAL_MEM_IO to "YES" can cause things bleed to
// swap if enough RAM is not available. Use "IF_ENOUGH_RAM" for safer performance if unsure. NOTE that faster
// mem io only works with *uncompressed* GeoTIFFs.
// New in GDAL 2.0, from https://2015.foss4g-na.org/sites/default/files/slides/GDAL%202.0%20overview.pdf
// GeoTIFF driver (with i7-4700 HQ (8 vCPUs)):with i7-4700 HQ (8 vCPUs)
// - Default: time ./testblockcache -ondisk: 7.5s
// - GTIFF_DIRECT_IO=YES: short circuit the block cache&libtiff for most RasterIO() operations (restricted to
// uncompressed stripped GeoTIFF). time ./testblockcache -ondisk: 2s
// - GTIFF_VIRTUAL_MEM_IO=YES: same as above, with tiled GeoTIFF as well. Uses memory-mapped file access. Linux
// only for now, 64bit recommended (could be extended to other platforms possible).
// time ./testblockcache -ondisk: 0.3s
//
CPLSetConfigOption("GTIFF_VIRTUAL_MEM_IO", "YES" );
// Open the dataset
GDALDataset *poDataset;
GDALAllRegister();
poDataset = (GDALDataset *) GDALOpen( pszFilename, GA_ReadOnly );
if( poDataset == NULL )
{
std::cout << "Dataset " << pszFilename << " could not be opened." << std::endl;
return -1;
}
else
{
GDALRasterBand *poBand;
int nBlockXSize, nBlockYSize;
int bGotMin, bGotMax;
double adfMinMax[2];
// Get raster band and its size
poBand = poDataset->GetRasterBand(1);
poBand->GetBlockSize( &nBlockXSize, &nBlockYSize);
std::cout << "Dataset: " << pszFilename << std::endl;
std::cout << "Block=" << nBlockXSize << "x" << nBlockYSize << " Type=" <<
GDALGetDataTypeName(poBand->GetRasterDataType()) << " ColorInterp=" <<
GDALGetColorInterpretationName(poBand->GetColorInterpretation()) << std::endl;
// Calculate some stats
adfMinMax[0] = poBand->GetMinimum(&bGotMin);
adfMinMax[1] = poBand->GetMaximum(&bGotMax);
if(!(bGotMin && bGotMax)) {
GDALComputeRasterMinMax((GDALRasterBandH) poBand, TRUE, adfMinMax);
}
std::cout << "Min=" << adfMinMax[0] << " Max=" << adfMinMax[1] << std::endl;
if(poBand->GetOverviewCount() > 0) {
std::cout << "Band has " << poBand->GetOverviewCount() << " overviews." << std::endl;
}
if( poBand->GetColorTable() != NULL ) {
std::cout << "Band has a color table with " << poBand->GetColorTable()->GetColorEntryCount() <<
" entries." << std::endl;
}
// Get the actual data
float *pafScanline;
int nXSize = poBand->GetXSize();
pafScanline = (float *) CPLMalloc(sizeof(float) * nXSize);
// RasterIO has a new argument psExtraArg in GDAL > 2.0. NOTE: that GDALRasterBand::ReadBlock() probably has
// better performance for reading the whole data at one go.
#ifdef USE_GDAL_2
GDALRasterIOExtraArg* arg = NULL;
poBand->RasterIO(GF_Read, 0, 0, nXSize, 1, pafScanline, nXSize, 1, GDT_Float3GDALRasterBand::ReadBlock 2,
0, 0, arg);
#else
poBand->RasterIO(GF_Read, 0, 0, nXSize, 1, pafScanline, nXSize, 1, GDT_Float32, 0, 0);
#endif
// ... do something with the data ...
// Free resources
CPLFree(pafScanline);
GDALClose((GDALDatasetH) poDataset);
std::cout << std::endl;
}
return 0;
}
/**
* read data
*/
bool KGDAL2CV::readData(cv::Mat img){
// make sure the image is the proper size
if (img.size().height != m_height){
return false;
}
if (img.size().width != m_width){
return false;
}
// make sure the raster is alive
if (m_dataset == NULL || m_driver == NULL){
return false;
}
// set the image to zero
img = 0;
// iterate over each raster band
// note that OpenCV does bgr rather than rgb
int nChannels = m_dataset->GetRasterCount();
GDALColorTable* gdalColorTable = NULL;
if (m_dataset->GetRasterBand(1)->GetColorTable() != NULL){
gdalColorTable = m_dataset->GetRasterBand(1)->GetColorTable();
}
const GDALDataType gdalType = m_dataset->GetRasterBand(1)->GetRasterDataType();
int nRows, nCols;
//if (nChannels > img.channels()){
// nChannels = img.channels();
//}
for (int c = 0; c < img.channels(); c++){
int realBandIndex = c;
// get the GDAL Band
GDALRasterBand* band = m_dataset->GetRasterBand(c + 1);
//if (hasColorTable == false){
if (GCI_RedBand == band->GetColorInterpretation()) realBandIndex = 2;
if (GCI_GreenBand == band->GetColorInterpretation()) realBandIndex = 1;
if (GCI_BlueBand == band->GetColorInterpretation()) realBandIndex = 0;
//}
if (hasColorTable && gdalColorTable->GetPaletteInterpretation() == GPI_RGB) c = img.channels() - 1;
// make sure the image band has the same dimensions as the image
if (band->GetXSize() != m_width || band->GetYSize() != m_height){ return false; }
// grab the raster size
nRows = band->GetYSize();
nCols = band->GetXSize();
// create a temporary scanline pointer to store data
double* scanline = new double[nCols];
// iterate over each row and column
for (int y = 0; y<nRows; y++){
// get the entire row
band->RasterIO(GF_Read, 0, y, nCols, 1, scanline, nCols, 1, GDT_Float64, 0, 0);
// set inside the image
for (int x = 0; x<nCols; x++){
// set depending on image types
// given boost, I would use enable_if to speed up. Avoid for now.
if (hasColorTable == false){
write_pixel(scanline[x], gdalType, nChannels, img, y, x, realBandIndex);
}
else{
write_ctable_pixel(scanline[x], gdalType, gdalColorTable, img, y, x, c);
}
}
}
// delete our temp pointer
delete[] scanline;
}
return true;
}
cv::Mat KGDAL2CV::ImgReadByGDAL(cv::String filename, int xStart, int yStart, int xWidth, int yWidth, bool beReadFourth)
{
m_filename = filename;
if (!readHeader()) return cv::Mat();
int tempType = m_type;
if (xStart < 0 || yStart < 0 || xWidth < 1 || yWidth < 1 || xStart > m_width - 1 || yStart > m_height - 1) return cv::Mat();
if (xStart + xWidth > m_width)
{
std::cout << "The specified width is invalid, Automatic optimization is executed!" << std::endl;
xWidth = m_width - xStart;
}
if (yStart + yWidth > m_height)
{
std::cout << "The specified height is invalid, Automatic optimization is executed!" << std::endl;
yWidth = m_height - yStart;
}
if (!beReadFourth && 4 == m_nBand)
{
for (unsigned int index = CV_8S; index < CV_USRTYPE1; ++index)
{
if (CV_MAKETYPE(index, m_nBand) == m_type)
{
std::cout << "We won't read the fourth band unless it's datatype is GDT_Byte!" << std::endl;
//tempType = -1;
tempType = tempType - ((3 << CV_CN_SHIFT) - (2 << CV_CN_SHIFT));
break;
//tempType = CV_MAKETYPE(index, m_nBand);
}
}
}
cv::Mat img(yWidth, xWidth, tempType, cv::Scalar::all(0.f));
// iterate over each raster band
// note that OpenCV does bgr rather than rgb
int nChannels = m_dataset->GetRasterCount();
GDALColorTable* gdalColorTable = NULL;
if (m_dataset->GetRasterBand(1)->GetColorTable() != NULL){
gdalColorTable = m_dataset->GetRasterBand(1)->GetColorTable();
}
const GDALDataType gdalType = m_dataset->GetRasterBand(1)->GetRasterDataType();
//if (nChannels > img.channels()){
// nChannels = img.channels();
//}
for (int c = 0; c < img.channels(); c++){
int realBandIndex = c;
// get the GDAL Band
GDALRasterBand* band = m_dataset->GetRasterBand(c + 1);
//if (hasColorTable == false){
if (GCI_RedBand == band->GetColorInterpretation()) realBandIndex = 2;
if (GCI_GreenBand == band->GetColorInterpretation()) realBandIndex = 1;
if (GCI_BlueBand == band->GetColorInterpretation()) realBandIndex = 0;
//}
if (hasColorTable && gdalColorTable->GetPaletteInterpretation() == GPI_RGB) c = img.channels() - 1;
// make sure the image band has the same dimensions as the image
if (band->GetXSize() != m_width || band->GetYSize() != m_height){ return cv::Mat(); }
// create a temporary scanline pointer to store data
double* scanline = new double[xWidth];
// iterate over each row and column
for (int y = 0; y<yWidth; y++){
// get the entire row
band->RasterIO(GF_Read, xStart, y + yStart, xWidth, 1, scanline, xWidth, 1, GDT_Float64, 0, 0);
// set inside the image
for (int x = 0; x<xWidth; x++){
// set depending on image types
// given boost, I would use enable_if to speed up. Avoid for now.
if (hasColorTable == false){
write_pixel(scanline[x], gdalType, nChannels, img, y, x, realBandIndex);
}
else{
write_ctable_pixel(scanline[x], gdalType, gdalColorTable, img, y, x, c);
}
}
}
// delete our temp pointer
delete[] scanline;
}
return img;
}
/** Private method to calculate statistics for each band. Populates rasterStatsMap. */
void ImageWriter::calculateStats(RasterBandStats * theRasterBandStats,GDALDataset * gdalDataset)
{
std::cout << "Calculating statistics..." << std::endl;
GDALRasterBand *myGdalBand = gdalDataset->GetRasterBand( 1 );
QString myColorInterpretation = GDALGetColorInterpretationName(myGdalBand->GetColorInterpretation());
theRasterBandStats->bandName=myColorInterpretation;
theRasterBandStats->bandNo=1;
// get the dimensions of the raster
int myColsInt = myGdalBand->GetXSize();
int myRowsInt = myGdalBand->GetYSize();
theRasterBandStats->elementCountInt=myColsInt*myRowsInt;
theRasterBandStats->noDataDouble=myGdalBand->GetNoDataValue();
//allocate a buffer to hold one row of ints
int myAllocationSizeInt = sizeof(uint)*myColsInt;
uint * myScanlineAllocInt = (uint*) CPLMalloc(myAllocationSizeInt);
bool myFirstIterationFlag = true;
//unfortunately we need to make two passes through the data to calculate stddev
for (int myCurrentRowInt=0; myCurrentRowInt < myRowsInt;myCurrentRowInt++)
{
CPLErr myResult = myGdalBand->RasterIO(
GF_Read, 0, myCurrentRowInt, myColsInt, 1, myScanlineAllocInt, myColsInt, 1, GDT_UInt32, 0, 0 );
for (int myCurrentColInt=0; myCurrentColInt < myColsInt; myCurrentColInt++)
{
//get the nth element from the current row
double myDouble=myScanlineAllocInt[myCurrentColInt];
//only use this element if we have a non null element
if (myDouble != theRasterBandStats->noDataDouble )
{
if (myFirstIterationFlag)
{
//this is the first iteration so initialise vars
myFirstIterationFlag=false;
theRasterBandStats->minValDouble=myDouble;
theRasterBandStats->maxValDouble=myDouble;
} //end of true part for first iteration check
else
{
//this is done for all subsequent iterations
if (myDouble < theRasterBandStats->minValDouble)
{
theRasterBandStats->minValDouble=myDouble;
}
if (myDouble > theRasterBandStats->maxValDouble)
{
// printf ("Maxval updated to %f\n",myDouble);
theRasterBandStats->maxValDouble=myDouble;
}
//only increment the running total if it is not a nodata value
if (myDouble != theRasterBandStats->noDataDouble)
{
theRasterBandStats->sumDouble += myDouble;
++theRasterBandStats->elementCountInt;
}
} //end of false part for first iteration check
} //end of nodata chec
} //end of column wise loop
} //end of row wise loop
//
//end of first pass through data now calculate the range
theRasterBandStats->rangeDouble = theRasterBandStats->maxValDouble-theRasterBandStats->minValDouble;
//calculate the mean
theRasterBandStats->meanDouble = theRasterBandStats->sumDouble / theRasterBandStats->elementCountInt;
//for the second pass we will get the sum of the squares / mean
for (int myCurrentRowInt=0; myCurrentRowInt < myRowsInt;myCurrentRowInt++)
{
CPLErr myResult = myGdalBand->RasterIO(
GF_Read, 0, myCurrentRowInt, myColsInt, 1, myScanlineAllocInt, myColsInt, 1, GDT_UInt32, 0, 0 );
for (int myCurrentColInt=0; myCurrentColInt < myColsInt; myCurrentColInt++)
{
//get the nth element from the current row
double myDouble=myScanlineAllocInt[myCurrentColInt];
theRasterBandStats->sumSqrDevDouble += static_cast<double>(pow(myDouble - theRasterBandStats->meanDouble,2));
} //end of column wise loop
} //end of row wise loop
//divide result by sample size - 1 and get square root to get stdev
theRasterBandStats->stdDevDouble = static_cast<double>(sqrt(theRasterBandStats->sumSqrDevDouble /
(theRasterBandStats->elementCountInt - 1)));
CPLFree(myScanlineAllocInt);
//printf("CalculateStats::\n");
//std::cout << "Band Name : " << theRasterBandStats->bandName << std::endl;
//printf("Band No : %i\n",theRasterBandStats->bandNo);
//printf("Band min : %f\n",theRasterBandStats->minValDouble);
//printf("Band max : %f\n",theRasterBandStats->maxValDouble);
//printf("Band range: %f\n",theRasterBandStats->rangeDouble);
//printf("Band mean : %f\n",theRasterBandStats->meanDouble);
//printf("Band sum : %f\n",theRasterBandStats->sumDouble);
return ;
}
feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
{
feature_ptr feature = feature_factory::create(ctx_,1);
GDALRasterBand * red = 0;
GDALRasterBand * green = 0;
GDALRasterBand * blue = 0;
GDALRasterBand * alpha = 0;
GDALRasterBand * grey = 0;
/*
#ifdef MAPNIK_LOG
double tr[6];
dataset_.GetGeoTransform(tr);
const double dx = tr[1];
const double dy = tr[5];
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: dx_=" << dx_ << " dx=" << dx << " dy_=" << dy_ << "dy=" << dy;
#endif
*/
CoordTransform t(raster_width_, raster_height_, raster_extent_, 0, 0);
box2d<double> intersect = raster_extent_.intersect(q.get_bbox());
box2d<double> box = t.forward(intersect);
//size of resized output pixel in source image domain
double margin_x = 1.0 / (fabs(dx_) * boost::get<0>(q.resolution()));
double margin_y = 1.0 / (fabs(dy_) * boost::get<1>(q.resolution()));
if (margin_x < 1)
{
margin_x = 1.0;
}
if (margin_y < 1)
{
margin_y = 1.0;
}
//select minimum raster containing whole box
int x_off = rint(box.minx() - margin_x);
int y_off = rint(box.miny() - margin_y);
int end_x = rint(box.maxx() + margin_x);
int end_y = rint(box.maxy() + margin_y);
//clip to available data
if (x_off < 0)
{
x_off = 0;
}
if (y_off < 0)
{
y_off = 0;
}
if (end_x > (int)raster_width_)
{
end_x = raster_width_;
}
if (end_y > (int)raster_height_)
{
end_y = raster_height_;
}
int width = end_x - x_off;
int height = end_y - y_off;
// don't process almost invisible data
if (box.width() < 0.5)
{
width = 0;
}
if (box.height() < 0.5)
{
height = 0;
}
//calculate actual box2d of returned raster
box2d<double> feature_raster_extent(x_off, y_off, x_off + width, y_off + height);
intersect = t.backward(feature_raster_extent);
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Raster extent=" << raster_extent_;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: View extent=" << intersect;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Query resolution=" << boost::get<0>(q.resolution()) << "," << boost::get<1>(q.resolution());
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: StartX=" << x_off << " StartY=" << y_off << " Width=" << width << " Height=" << height;
if (width > 0 && height > 0)
{
double width_res = boost::get<0>(q.resolution());
double height_res = boost::get<1>(q.resolution());
int im_width = int(width_res * intersect.width() + 0.5);
int im_height = int(height_res * intersect.height() + 0.5);
// if layer-level filter_factor is set, apply it
if (filter_factor_)
{
im_width *= filter_factor_;
im_height *= filter_factor_;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Applying layer filter_factor=" << filter_factor_;
}
// otherwise respect symbolizer level factor applied to query, default of 1.0
else
{
double sym_downsample_factor = q.get_filter_factor();
im_width *= sym_downsample_factor;
im_height *= sym_downsample_factor;
}
// case where we need to avoid upsampling so that the
// image can be later scaled within raster_symbolizer
if (im_width >= width || im_height >= height)
{
im_width = width;
im_height = height;
}
if (im_width > 0 && im_height > 0)
{
mapnik::raster_ptr raster = boost::make_shared<mapnik::raster>(intersect, im_width, im_height);
feature->set_raster(raster);
mapnik::image_data_32 & image = raster->data_;
image.set(0xffffffff);
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Image Size=(" << im_width << "," << im_height << ")";
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Reading band=" << band_;
if (band_ > 0) // we are querying a single band
{
if (band_ > nbands_)
{
throw datasource_exception((boost::format("GDAL Plugin: '%d' is an invalid band, dataset only has '%d' bands\n") % band_ % nbands_).str());
}
float* imageData = (float*)image.getBytes();
GDALRasterBand * band = dataset_.GetRasterBand(band_);
int hasNoData(0);
double nodata(0);
if (nodata_value_)
{
hasNoData = 1;
nodata = *nodata_value_;
}
else
{
nodata = band->GetNoDataValue(&hasNoData);
}
band->RasterIO(GF_Read, x_off, y_off, width, height,
imageData, image.width(), image.height(),
GDT_Float32, 0, 0);
if (hasNoData)
{
feature->put("NODATA",nodata);
}
}
else // working with all bands
{
for (int i = 0; i < nbands_; ++i)
{
GDALRasterBand * band = dataset_.GetRasterBand(i + 1);
#ifdef MAPNIK_LOG
get_overview_meta(band);
#endif
GDALColorInterp color_interp = band->GetColorInterpretation();
switch (color_interp)
{
case GCI_RedBand:
red = band;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found red band";
break;
case GCI_GreenBand:
green = band;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found green band";
break;
case GCI_BlueBand:
blue = band;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found blue band";
break;
case GCI_AlphaBand:
alpha = band;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found alpha band";
break;
case GCI_GrayIndex:
grey = band;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found gray band";
break;
case GCI_PaletteIndex:
{
grey = band;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found gray band, and colortable...";
GDALColorTable *color_table = band->GetColorTable();
if (color_table)
{
int count = color_table->GetColorEntryCount();
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Color Table count=" << count;
for (int j = 0; j < count; j++)
{
const GDALColorEntry *ce = color_table->GetColorEntry (j);
if (! ce) continue;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Color entry RGB=" << ce->c1 << "," <<ce->c2 << "," << ce->c3;
}
}
break;
}
case GCI_Undefined:
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found undefined band (assumming gray band)";
grey = band;
break;
default:
MAPNIK_LOG_WARN(gdal) << "gdal_featureset: Band type unknown!";
break;
}
}
if (red && green && blue)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Processing rgb bands...";
int hasNoData = 0;
double nodata = 0.0;
if (nodata_value_)
{
hasNoData = 1;
nodata = *nodata_value_;
}
else
{
nodata = red->GetNoDataValue(&hasNoData);
}
if (hasNoData)
{
feature->put("NODATA",nodata);
}
GDALColorTable *color_table = red->GetColorTable();
if (! alpha && hasNoData && ! color_table)
{
// first read the data in and create an alpha channel from the nodata values
float* imageData = (float*)image.getBytes();
red->RasterIO(GF_Read, x_off, y_off, width, height,
imageData, image.width(), image.height(),
GDT_Float32, 0, 0);
int len = image.width() * image.height();
for (int i = 0; i < len; ++i)
{
if (nodata == imageData[i])
{
*reinterpret_cast<unsigned *>(&imageData[i]) = 0;
}
else
{
*reinterpret_cast<unsigned *>(&imageData[i]) = 0xFFFFFFFF;
}
}
}
red->RasterIO(GF_Read, x_off, y_off, width, height, image.getBytes() + 0,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
green->RasterIO(GF_Read, x_off, y_off, width, height, image.getBytes() + 1,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
blue->RasterIO(GF_Read, x_off, y_off, width, height, image.getBytes() + 2,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
}
else if (grey)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Processing gray band...";
int hasNoData(0);
double nodata(0);
if (nodata_value_)
{
hasNoData = 1;
nodata = *nodata_value_;
}
else
{
nodata = grey->GetNoDataValue(&hasNoData);
}
GDALColorTable* color_table = grey->GetColorTable();
if (hasNoData && ! color_table)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: No data value for layer=" << nodata;
feature->put("NODATA",nodata);
// first read the data in and create an alpha channel from the nodata values
float* imageData = (float*)image.getBytes();
grey->RasterIO(GF_Read, x_off, y_off, width, height,
imageData, image.width(), image.height(),
GDT_Float32, 0, 0);
int len = image.width() * image.height();
for (int i = 0; i < len; ++i)
{
if (nodata == imageData[i])
{
*reinterpret_cast<unsigned *>(&imageData[i]) = 0;
}
else
{
*reinterpret_cast<unsigned *> (&imageData[i]) = 0xFFFFFFFF;
}
}
}
grey->RasterIO(GF_Read, x_off, y_off, width, height, image.getBytes() + 0,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
grey->RasterIO(GF_Read,x_off, y_off, width, height, image.getBytes() + 1,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
grey->RasterIO(GF_Read,x_off, y_off, width, height, image.getBytes() + 2,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
if (color_table)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Loading colour table...";
unsigned nodata_value = static_cast<unsigned>(nodata);
if (hasNoData)
{
feature->put("NODATA",static_cast<int>(nodata_value));
}
for (unsigned y = 0; y < image.height(); ++y)
{
unsigned int* row = image.getRow(y);
for (unsigned x = 0; x < image.width(); ++x)
{
unsigned value = row[x] & 0xff;
if (hasNoData && (value == nodata_value))
{
// make no data fully alpha
row[x] = 0;
}
else
{
const GDALColorEntry *ce = color_table->GetColorEntry(value);
if (ce)
{
// TODO - big endian support
row[x] = (ce->c4 << 24)| (ce->c3 << 16) | (ce->c2 << 8) | (ce->c1) ;
}
else
{
// make lacking color entry fully alpha
// note - gdal_translate makes black
row[x] = 0;
}
}
}
}
}
}
if (alpha)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: processing alpha band...";
alpha->RasterIO(GF_Read, x_off, y_off, width, height, image.getBytes() + 3,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
}
}
return feature;
}
}
return feature_ptr();
}
std::tuple<boost::shared_ptr<Map_Matrix<DataFormat> >, std::string, GeoTransform> read_in_map(fs::path file_path, GDALDataType data_type, const bool doCategorise) throw(std::runtime_error)
{
std::string projection;
GeoTransform transformation;
GDALDriver driver;
//Check that the file name is valid
if (!(fs::is_regular_file(file_path)))
{
throw std::runtime_error("Input file is not a regular file");
}
// Get GDAL to open the file - code is based on the tutorial at http://www.gdal.org/gdal_tutorial.html
GDALDataset *poDataset;
GDALAllRegister(); //This registers all availble raster file formats for use with this utility. How neat is that. We can input any GDAL supported rater file format.
//Open the Raster by calling GDALOpen. http://www.gdal.org/gdal_8h.html#a6836f0f810396c5e45622c8ef94624d4
//char pszfilename[] = file_path.c_str(); //Set this to the file name, as GDALOpen requires the standard C char pointer as function parameter.
poDataset = (GDALDataset *) GDALOpen (file_path.string().c_str(), GA_ReadOnly);
if (poDataset == NULL)
{
throw std::runtime_error("Unable to open file");
}
// Print some general information about the raster
double adfGeoTransform[6]; //An array of doubles that will be used to save information about the raster - where the origin is, what the raster pizel size is.
printf( "Driver: %s/%s\n",
poDataset->GetDriver()->GetDescription(),
poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) );
printf( "Size is %dx%dx%d\n",
poDataset->GetRasterXSize(), poDataset->GetRasterYSize(),
poDataset->GetRasterCount() );
if( poDataset->GetProjectionRef() != NULL )
{
printf( "Projection is `%s'\n", poDataset->GetProjectionRef() );
projection = poDataset->GetProjectionRef();
}
if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None )
{
printf( "Origin = (%.6f,%.6f)\n",
adfGeoTransform[0], adfGeoTransform[3] );
printf( "Pixel Size = (%.6f,%.6f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
transformation.x_origin = adfGeoTransform[0];
transformation.pixel_width = adfGeoTransform[1];
transformation.x_line_space = adfGeoTransform[2];
transformation.y_origin = adfGeoTransform[3];
transformation.pixel_height = adfGeoTransform[4];
transformation.y_line_space = adfGeoTransform[5];
}
/// Some raster file formats allow many layers of data (called a 'band', with each having the same pixel size and origin location and spatial extent). We will get the data for the first layer into a Boost Array.
//Get the data from the first band,
// TODO implement method with input to specify what band.
GDALRasterBand *poBand;
int nBlockXSize, nBlockYSize;
int bGotMin, bGotMax;
double adfMinMax[2];
poBand = poDataset->GetRasterBand( 1 );
poBand->GetBlockSize( &nBlockXSize, &nBlockYSize );
printf( "Block=%dx%d Type=%s, ColorInterp=%s\n",
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(poBand->GetRasterDataType()),
GDALGetColorInterpretationName(
poBand->GetColorInterpretation()) );
adfMinMax[0] = poBand->GetMinimum( &bGotMin );
adfMinMax[1] = poBand->GetMaximum( &bGotMax );
if( ! (bGotMin && bGotMax) )
GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax);
printf( "Min=%.3fd, Max=%.3f\n", adfMinMax[0], adfMinMax[1] );
if( poBand->GetOverviewCount() > 0 )
printf( "Band has %d overviews.\n", poBand->GetOverviewCount() );
if( poBand->GetColorTable() != NULL )
printf( "Band has a color table with %d entries.\n",
poBand->GetColorTable()->GetColorEntryCount() );
DataFormat * pafScanline;
int nXSize = poBand->GetXSize();
int nYSize = poBand->GetYSize();
boost::shared_ptr<Map_Matrix<DataFormat> > in_map(new Map_Matrix<DataFormat>(nYSize, nXSize));
//get a c array of this size and read into this.
//pafScanline = new DataFormat[nXSize];
//for (int i = 0; i < nYSize; i++) //rows
//{
// poBand->RasterIO(GF_Read, 0, i, nXSize, 1,
// pafScanline, nXSize, 1, data_type,
// 0, 0);
// for (int j = 0; j < nXSize; j++) //cols
// {
// in_map->Get(i, j) = pafScanline[j];
// }
//}
//get a c array of this size and read into this.
pafScanline = new DataFormat[nXSize * nYSize];
//pafScanline = (float *) CPLMalloc(sizeof(float)*nXSize);
poBand->RasterIO( GF_Read, 0, 0, nXSize, nYSize,
pafScanline, nXSize, nYSize, data_type,
0, 0 );
//Copy into Map_Matrix.
int pafIterator = 0;
// Note: Map Matrixes indexes are in opposite order to C arrays. e.g. map matrix is indexed by (row, Col) which is (y, x) and c matrices are done by (x, y) which is (Col, Row)
//for (int i = 0; i < nXSize; i++)
//{
// for(int j = 0; j < nYSize; j++)
// {
// in_map->Get(j, i) = pafScanline[pafIterator];
// pafIterator++;
// }
//}
for (int i = 0; i < nYSize; i++) //rows
{
for (int j = 0; j < nXSize; j++) //cols
{
in_map->Get(i, j) = pafScanline[pafIterator];
pafIterator++;
}
}
//free the c array storage
delete pafScanline;
int pbsuccess; // can be used with get no data value
in_map->SetNoDataValue(poBand->GetNoDataValue(&pbsuccess));
//This creates a list (map?) listing all the unique values contained in the raster.
if (doCategorise) in_map->updateCategories();
//Close GDAL, freeing the memory GDAL is using
GDALClose( (GDALDatasetH)poDataset);
return (std::make_tuple(in_map, projection, transformation));
}
int main(int argc, const char * argv[]) {
boost::filesystem::path p = boost::filesystem::current_path();
fprintf(stdout,"cwp := %s\n",p.c_str());
GDALAllRegister();
// for (int i = 0; i < GDALGetDriverCount(); i++) {
// GDALDriver * d = (GDALDriver *)GDALGetDriver(i);
// const char * desc = d->GetDescription();
// fprintf(stdout, "GDAL: %s\n",desc);
// }
GDALDataset *poDataset = (GDALDataset *) GDALOpen(DataPath.c_str(), GA_ReadOnly );
std::string SupportedDriver = {"GTiff"};
if (poDataset != NULL) {
GDALDriver * drv = poDataset->GetDriver();
assert(0 == SupportedDriver.compare(drv->GetDescription()));
assert (1 == poDataset->GetRasterCount());
fprintf(stdout,"RasterXSize := %d\n",poDataset->GetRasterXSize());
fprintf(stdout,"RasterYSize := %d\n",poDataset->GetRasterYSize());
fprintf(stdout,"ProjectionRef := %s\n",poDataset->GetProjectionRef());
double adfGeoTransform[6];
if ( poDataset->GetGeoTransform(adfGeoTransform) == CE_None ) {
fprintf(stdout, "Origin = (%.6f, %.6f)\n",
adfGeoTransform[0],adfGeoTransform[3]); // upper left courner
fprintf(stdout, "Pixel Size = (%.6f, %.6f)\n",
adfGeoTransform[1],adfGeoTransform[5]); // pixel width/height
}
GDALRasterBand *poBand = poDataset->GetRasterBand(1);
int nBlockXSize, nBlockYSize;
poBand->GetBlockSize(&nBlockXSize, &nBlockYSize);
std::string SupportedDataType = {"Int16"};
assert (GDT_Int16 == poBand->GetRasterDataType());
printf( "Block=%dx%d Type=%s, ColorInterp=%s\n",
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(poBand->GetRasterDataType()),
GDALGetColorInterpretationName(
poBand->GetColorInterpretation()) );
FILE * patch = fopen("patch.txt","w");
for (int i = 0; i < poBand->GetYSize(); i++) {
int nXSize = poBand->GetXSize();
float *pafScanline = (float *) CPLMalloc(sizeof(float)*nXSize);
poBand->RasterIO( GF_Read, 0, 0, nXSize, 1, pafScanline, nXSize, 1, GDT_Float32, 0, 0);
for (int j = 0; j < nXSize; j++) {
fprintf(patch, "%f ", pafScanline[j]);
}
fprintf(patch, "\n");
CPLFree(pafScanline);
}
fclose(patch);
GDALClose(poDataset);
}
DelaunayTriangulation dt;
//std::srand(static_cast<unsigned int>(std::time(0))); // use current time as seed for random generator
/*
std::srand(static_cast<unsigned int>(3652123216145));
for (int i = 0; i < 10 ; i++) {
double x = 180.0 * static_cast <float> (rand()) / static_cast <float> (RAND_MAX);;
double y = 180.0 * static_cast <float> (rand()) / static_cast <float> (RAND_MAX);;
dt.addPt(x, y, 0.0);
}
*/
/*
dt.addPt(-0.02222276248244826, -0.4979727817680433, 0.0);
dt.addPt(-0.4285431913366012, 0.4745826469497594, 0.0);
dt.addPt( 0.3105396575392593, 0.2400179190933871, 0.0);
dt.addPt(-0.01883958887200765, 0.3630260628303755, 0.0);
dt.addPt( 0.3790312361708201, 0.3779794437605696, 0.0);
dt.addPt(-0.2994955874043476, 0.3776609263174803, 0.0);
dt.addPt( 0.3471817493878135, 0.08365533089605659, 0.0);
dt.addPt(-0.00485819764887746, 0.3482682405489201, 0.0);
dt.addPt( 0.3443122672329771, -0.1437312230875075, 0.0);
dt.addPt( 0.309330780347186, -0.07758103877080702, 0.0);
dt.compute();
*/
return 0;
}
void CMapRaster::draw()
{
if(!dataset) return;
pixBuffer.fill(Qt::white);
QPainter _p_(&pixBuffer);
QRectF viewport(x, y, size.width() * zoomfactor, size.height() * zoomfactor);
QRectF intersect = viewport.intersected(maparea);
// x/y offset [pixel] into file matrix
qint32 xoff = intersect.left();
qint32 yoff = intersect.top();
// number of x/y pixel to read
qint32 pxx = intersect.width();
qint32 pxy = intersect.height();
// the final image width and height in pixel
qint32 w = (qint32)(pxx / zoomfactor) & 0xFFFFFFFC;
qint32 h = (qint32)(pxy / zoomfactor);
if((w*h) == 0)
{
return;
}
CPLErr err = CE_Failure;
if(rasterBandCount == 1)
{
GDALRasterBand * pBand;
pBand = dataset->GetRasterBand(1);
QImage img(QSize(w,h),QImage::Format_Indexed8);
img.setColorTable(colortable);
err = pBand->RasterIO(GF_Read,(int)xoff,(int)yoff,pxx,pxy,img.bits(),w,h,GDT_Byte,0,0);
if(!err)
{
double xx = (intersect.left() - x) / zoomfactor, yy = (intersect.top() - y) / zoomfactor;
_p_.drawPixmap(xx,yy,QPixmap::fromImage(img));
}
}
else
{
QImage img(w,h, QImage::Format_ARGB32);
QVector<quint8> buffer(w*h);
img.fill(qRgba(255,255,255,255));
QRgb testPix = qRgba(GCI_RedBand, GCI_GreenBand, GCI_BlueBand, GCI_AlphaBand);
for(int b = 1; b <= rasterBandCount; ++b)
{
GDALRasterBand * pBand;
pBand = dataset->GetRasterBand(b);
err = pBand->RasterIO(GF_Read, (int)xoff, (int)yoff, pxx, pxy, buffer.data(), w, h, GDT_Byte, 0, 0);
if(!err)
{
int pbandColour = pBand->GetColorInterpretation();
unsigned int offset;
for (offset = 0; offset < sizeof(testPix) && *(((quint8 *)&testPix) + offset) != pbandColour; offset++);
if(offset < sizeof(testPix))
{
quint8 * pTar = img.bits() + offset;
quint8 * pSrc = buffer.data();
const int size = buffer.size();
for(int i = 0; i < size; ++i)
{
*pTar = *pSrc;
pTar += sizeof(testPix);
pSrc += 1;
}
}
}
}
if(!err)
{
double xx = (intersect.left() - x) / zoomfactor, yy = (intersect.top() - y) / zoomfactor;
_p_.drawPixmap(xx,yy,QPixmap::fromImage(img));
}
}
}
CC_FILE_ERROR RasterGridFilter::loadFile(QString filename, ccHObject& container, bool alwaysDisplayLoadDialog/*=true*/, bool* coordinatesShiftEnabled/*=0*/, CCVector3d* coordinatesShift/*=0*/)
{
GDALAllRegister();
ccLog::PrintDebug("(GDAL drivers: %i)", GetGDALDriverManager()->GetDriverCount());
GDALDataset* poDataset = static_cast<GDALDataset*>(GDALOpen( qPrintable(filename), GA_ReadOnly ));
if( poDataset != NULL )
{
ccLog::Print(QString("Raster file: '%1'").arg(filename));
ccLog::Print( "Driver: %s/%s",
poDataset->GetDriver()->GetDescription(),
poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) );
int rasterCount = poDataset->GetRasterCount();
int rasterX = poDataset->GetRasterXSize();
int rasterY = poDataset->GetRasterYSize();
ccLog::Print( "Size is %dx%dx%d", rasterX, rasterY, rasterCount );
ccPointCloud* pc = new ccPointCloud();
if (!pc->reserve(static_cast<unsigned>(rasterX * rasterY)))
{
delete pc;
return CC_FERR_NOT_ENOUGH_MEMORY;
}
if( poDataset->GetProjectionRef() != NULL )
ccLog::Print( "Projection is `%s'", poDataset->GetProjectionRef() );
double adfGeoTransform[6] = { 0, //top left x
1, //w-e pixel resolution (can be negative)
0, //0
0, //top left y
0, //0
1 //n-s pixel resolution (can be negative)
};
if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None )
{
ccLog::Print( "Origin = (%.6f,%.6f)", adfGeoTransform[0], adfGeoTransform[3] );
ccLog::Print( "Pixel Size = (%.6f,%.6f)", adfGeoTransform[1], adfGeoTransform[5] );
}
if (adfGeoTransform[1] == 0 || adfGeoTransform[5] == 0)
{
ccLog::Warning("Invalid pixel size! Forcing it to (1,1)");
adfGeoTransform[1] = adfGeoTransform[5] = 1;
}
CCVector3d origin( adfGeoTransform[0], adfGeoTransform[3], 0.0 );
CCVector3d Pshift(0,0,0);
//check for 'big' coordinates
{
bool shiftAlreadyEnabled = (coordinatesShiftEnabled && *coordinatesShiftEnabled && coordinatesShift);
if (shiftAlreadyEnabled)
Pshift = *coordinatesShift;
bool applyAll = false;
if ( sizeof(PointCoordinateType) < 8
&& ccCoordinatesShiftManager::Handle(origin,0,alwaysDisplayLoadDialog,shiftAlreadyEnabled,Pshift,0,&applyAll))
{
pc->setGlobalShift(Pshift);
ccLog::Warning("[RasterFilter::loadFile] Raster has been recentered! Translation: (%.2f,%.2f,%.2f)",Pshift.x,Pshift.y,Pshift.z);
//we save coordinates shift information
if (applyAll && coordinatesShiftEnabled && coordinatesShift)
{
*coordinatesShiftEnabled = true;
*coordinatesShift = Pshift;
}
}
}
//create blank raster 'grid'
{
double z = 0.0 /*+ Pshift.z*/;
for (int j=0; j<rasterY; ++j)
{
double y = adfGeoTransform[3] + static_cast<double>(j) * adfGeoTransform[5] + Pshift.y;
CCVector3 P( 0,
static_cast<PointCoordinateType>(y),
static_cast<PointCoordinateType>(z));
for (int i=0; i<rasterX; ++i)
{
double x = adfGeoTransform[0] + static_cast<double>(i) * adfGeoTransform[1] + Pshift.x;
P.x = static_cast<PointCoordinateType>(x);
pc->addPoint(P);
}
}
QVariant xVar = QVariant::fromValue<int>(rasterX);
QVariant yVar = QVariant::fromValue<int>(rasterY);
pc->setMetaData("raster_width",xVar);
pc->setMetaData("raster_height",yVar);
}
//fetch raster bands
bool zRasterProcessed = false;
unsigned zInvalid = 0;
double zMinMax[2] = {0, 0};
for (int i=1; i<=rasterCount; ++i)
{
ccLog::Print( "Reading band #%i", i);
GDALRasterBand* poBand = poDataset->GetRasterBand(i);
GDALColorInterp colorInterp = poBand->GetColorInterpretation();
GDALDataType bandType = poBand->GetRasterDataType();
int nBlockXSize, nBlockYSize;
poBand->GetBlockSize( &nBlockXSize, &nBlockYSize );
ccLog::Print( "Block=%dx%d Type=%s, ColorInterp=%s", nBlockXSize, nBlockYSize, GDALGetDataTypeName(poBand->GetRasterDataType()), GDALGetColorInterpretationName(colorInterp) );
//fetching raster scan-line
int nXSize = poBand->GetXSize();
int nYSize = poBand->GetYSize();
assert(nXSize == rasterX);
assert(nYSize == rasterY);
int bGotMin, bGotMax;
double adfMinMax[2] = {0, 0};
adfMinMax[0] = poBand->GetMinimum( &bGotMin );
adfMinMax[1] = poBand->GetMaximum( &bGotMax );
if (!bGotMin || !bGotMax )
//DGM FIXME: if the file is corrupted (e.g. ASCII ArcGrid with missing rows) this method will enter in a infinite loop!
GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax);
ccLog::Print( "Min=%.3fd, Max=%.3f", adfMinMax[0], adfMinMax[1] );
GDALColorTable* colTable = poBand->GetColorTable();
if( colTable != NULL )
printf( "Band has a color table with %d entries", colTable->GetColorEntryCount() );
if( poBand->GetOverviewCount() > 0 )
printf( "Band has %d overviews", poBand->GetOverviewCount() );
if (colorInterp == GCI_Undefined && !zRasterProcessed/*&& !colTable*/) //probably heights?
{
zRasterProcessed = true;
zMinMax[0] = adfMinMax[0];
zMinMax[1] = adfMinMax[1];
double* scanline = (double*) CPLMalloc(sizeof(double)*nXSize);
//double* scanline = new double[nXSize];
memset(scanline,0,sizeof(double)*nXSize);
for (int j=0; j<nYSize; ++j)
{
if (poBand->RasterIO( GF_Read, /*xOffset=*/0, /*yOffset=*/j, /*xSize=*/nXSize, /*ySize=*/1, /*buffer=*/scanline, /*bufferSizeX=*/nXSize, /*bufferSizeY=*/1, /*bufferType=*/GDT_Float64, /*x_offset=*/0, /*y_offset=*/0 ) != CE_None)
{
delete pc;
CPLFree(scanline);
GDALClose(poDataset);
return CC_FERR_READING;
}
for (int k=0; k<nXSize; ++k)
{
double z = static_cast<double>(scanline[k]) + Pshift[2];
unsigned pointIndex = static_cast<unsigned>(k + j * rasterX);
if (pointIndex <= pc->size())
{
if (z < zMinMax[0] || z > zMinMax[1])
{
z = zMinMax[0] - 1.0;
++zInvalid;
}
const_cast<CCVector3*>(pc->getPoint(pointIndex))->z = static_cast<PointCoordinateType>(z);
}
}
}
//update bounding-box
pc->invalidateBoundingBox();
if (scanline)
CPLFree(scanline);
scanline = 0;
}
else //colors
{
bool isRGB = false;
bool isScalar = false;
bool isPalette = false;
switch(colorInterp)
{
case GCI_Undefined:
isScalar = true;
break;
case GCI_PaletteIndex:
isPalette = true;
break;
case GCI_RedBand:
case GCI_GreenBand:
case GCI_BlueBand:
isRGB = true;
break;
case GCI_AlphaBand:
if (adfMinMax[0] != adfMinMax[1])
isScalar = true;
else
ccLog::Warning(QString("Alpha band ignored as it has a unique value (%1)").arg(adfMinMax[0]));
break;
default:
isScalar = true;
break;
}
if (isRGB || isPalette)
{
//first check that a palette exists if the band is a palette index
if (isPalette && !colTable)
{
ccLog::Warning(QString("Band is declared as a '%1' but no palette is associated!").arg(GDALGetColorInterpretationName(colorInterp)));
isPalette = false;
}
else
{
//instantiate memory for RBG colors if necessary
if (!pc->hasColors() && !pc->setRGBColor(MAX_COLOR_COMP,MAX_COLOR_COMP,MAX_COLOR_COMP))
{
ccLog::Warning(QString("Failed to instantiate memory for storing color band '%1'!").arg(GDALGetColorInterpretationName(colorInterp)));
}
else
{
assert(bandType <= GDT_Int32);
int* colIndexes = (int*) CPLMalloc(sizeof(int)*nXSize);
//double* scanline = new double[nXSize];
memset(colIndexes,0,sizeof(int)*nXSize);
for (int j=0; j<nYSize; ++j)
{
if (poBand->RasterIO( GF_Read, /*xOffset=*/0, /*yOffset=*/j, /*xSize=*/nXSize, /*ySize=*/1, /*buffer=*/colIndexes, /*bufferSizeX=*/nXSize, /*bufferSizeY=*/1, /*bufferType=*/GDT_Int32, /*x_offset=*/0, /*y_offset=*/0 ) != CE_None)
{
CPLFree(colIndexes);
delete pc;
return CC_FERR_READING;
}
for (int k=0; k<nXSize; ++k)
{
unsigned pointIndex = static_cast<unsigned>(k + j * rasterX);
if (pointIndex <= pc->size())
{
colorType* C = const_cast<colorType*>(pc->getPointColor(pointIndex));
switch(colorInterp)
{
case GCI_PaletteIndex:
assert(colTable);
{
GDALColorEntry col;
colTable->GetColorEntryAsRGB(colIndexes[k],&col);
C[0] = static_cast<colorType>(col.c1 & MAX_COLOR_COMP);
C[1] = static_cast<colorType>(col.c2 & MAX_COLOR_COMP);
C[2] = static_cast<colorType>(col.c3 & MAX_COLOR_COMP);
}
break;
case GCI_RedBand:
C[0] = static_cast<colorType>(colIndexes[k] & MAX_COLOR_COMP);
break;
case GCI_GreenBand:
C[1] = static_cast<colorType>(colIndexes[k] & MAX_COLOR_COMP);
break;
case GCI_BlueBand:
C[2] = static_cast<colorType>(colIndexes[k] & MAX_COLOR_COMP);
break;
default:
assert(false);
break;
}
}
}
}
if (colIndexes)
CPLFree(colIndexes);
colIndexes = 0;
pc->showColors(true);
}
}
}
else if (isScalar)
{
ccScalarField* sf = new ccScalarField(GDALGetColorInterpretationName(colorInterp));
if (!sf->resize(pc->size(),true,NAN_VALUE))
{
ccLog::Warning(QString("Failed to instantiate memory for storing '%1' as a scalar field!").arg(sf->getName()));
sf->release();
sf = 0;
}
else
{
double* colValues = (double*) CPLMalloc(sizeof(double)*nXSize);
//double* scanline = new double[nXSize];
memset(colValues,0,sizeof(double)*nXSize);
for (int j=0; j<nYSize; ++j)
{
if (poBand->RasterIO( GF_Read, /*xOffset=*/0, /*yOffset=*/j, /*xSize=*/nXSize, /*ySize=*/1, /*buffer=*/colValues, /*bufferSizeX=*/nXSize, /*bufferSizeY=*/1, /*bufferType=*/GDT_Float64, /*x_offset=*/0, /*y_offset=*/0 ) != CE_None)
{
CPLFree(colValues);
delete pc;
return CC_FERR_READING;
}
for (int k=0; k<nXSize; ++k)
{
unsigned pointIndex = static_cast<unsigned>(k + j * rasterX);
if (pointIndex <= pc->size())
{
ScalarType s = static_cast<ScalarType>(colValues[k]);
sf->setValue(pointIndex,s);
}
}
}
if (colValues)
CPLFree(colValues);
colValues = 0;
sf->computeMinAndMax();
pc->addScalarField(sf);
if (pc->getNumberOfScalarFields() == 1)
pc->setCurrentDisplayedScalarField(0);
pc->showSF(true);
}
}
}
}
if (pc)
{
if (!zRasterProcessed)
{
ccLog::Warning("Raster has no height (Z) information: you can convert one of its scalar fields to Z with 'Edit > Scalar Fields > Set SF as coordinate(s)'");
}
else if (zInvalid != 0 && zInvalid < pc->size())
{
//shall we remove the points with invalid heights?
if (QMessageBox::question(0,"Remove NaN points?","This raster has pixels with invalid heights. Shall we remove them?",QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes)
{
CCLib::ReferenceCloud validPoints(pc);
unsigned count = pc->size();
bool error = true;
if (validPoints.reserve(count-zInvalid))
{
for (unsigned i=0; i<count; ++i)
{
if (pc->getPoint(i)->z >= zMinMax[0])
validPoints.addPointIndex(i);
}
if (validPoints.size() > 0)
{
validPoints.resize(validPoints.size());
ccPointCloud* newPC = pc->partialClone(&validPoints);
if (newPC)
{
delete pc;
pc = newPC;
error = false;
}
}
else
{
assert(false);
}
}
if (error)
{
ccLog::Error("Not enough memory to remove the points with invalid heights!");
}
}
}
container.addChild(pc);
}
GDALClose(poDataset);
}
else
{
return CC_FERR_UNKNOWN_FILE;
}
return CC_FERR_NO_ERROR;
}
feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
{
feature_ptr feature = feature_factory::create(ctx_,1);
int raster_has_nodata = 0;
double raster_nodata = 0;
GDALRasterBand * red = 0;
GDALRasterBand * green = 0;
GDALRasterBand * blue = 0;
GDALRasterBand * alpha = 0;
GDALRasterBand * grey = 0;
CPLErr raster_io_error = CE_None;
/*
#ifdef MAPNIK_LOG
double tr[6];
dataset_.GetGeoTransform(tr);
const double dx = tr[1];
const double dy = tr[5];
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: dx_=" << dx_ << " dx=" << dx << " dy_=" << dy_ << "dy=" << dy;
#endif
*/
view_transform t(raster_width_, raster_height_, raster_extent_, 0, 0);
box2d<double> intersect = raster_extent_.intersect(q.get_bbox());
box2d<double> box = t.forward(intersect);
//size of resized output pixel in source image domain
double margin_x = 1.0 / (std::fabs(dx_) * std::get<0>(q.resolution()));
double margin_y = 1.0 / (std::fabs(dy_) * std::get<1>(q.resolution()));
if (margin_x < 1)
{
margin_x = 1.0;
}
if (margin_y < 1)
{
margin_y = 1.0;
}
//select minimum raster containing whole box
int x_off = rint(box.minx() - margin_x);
int y_off = rint(box.miny() - margin_y);
int end_x = rint(box.maxx() + margin_x);
int end_y = rint(box.maxy() + margin_y);
//clip to available data
if (x_off < 0)
{
x_off = 0;
}
if (y_off < 0)
{
y_off = 0;
}
if (end_x > (int)raster_width_)
{
end_x = raster_width_;
}
if (end_y > (int)raster_height_)
{
end_y = raster_height_;
}
int width = end_x - x_off;
int height = end_y - y_off;
// don't process almost invisible data
if (box.width() < 0.5)
{
width = 0;
}
if (box.height() < 0.5)
{
height = 0;
}
//calculate actual box2d of returned raster
box2d<double> feature_raster_extent(x_off, y_off, x_off + width, y_off + height);
intersect = t.backward(feature_raster_extent);
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Raster extent=" << raster_extent_;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: View extent=" << intersect;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Query resolution=" << std::get<0>(q.resolution()) << "," << std::get<1>(q.resolution());
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: StartX=" << x_off << " StartY=" << y_off << " Width=" << width << " Height=" << height;
if (width > 0 && height > 0)
{
double width_res = std::get<0>(q.resolution());
double height_res = std::get<1>(q.resolution());
int im_width = int(width_res * intersect.width() + 0.5);
int im_height = int(height_res * intersect.height() + 0.5);
double filter_factor = q.get_filter_factor();
im_width = int(im_width * filter_factor + 0.5);
im_height = int(im_height * filter_factor + 0.5);
// case where we need to avoid upsampling so that the
// image can be later scaled within raster_symbolizer
if (im_width >= width || im_height >= height)
{
im_width = width;
im_height = height;
}
if (im_width > 0 && im_height > 0)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Image Size=(" << im_width << "," << im_height << ")";
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Reading band=" << band_;
if (band_ > 0) // we are querying a single band
{
GDALRasterBand * band = dataset_.GetRasterBand(band_);
if (band_ > nbands_)
{
std::ostringstream s;
s << "GDAL Plugin: " << band_ << " is an invalid band, dataset only has " << nbands_ << "bands";
throw datasource_exception(s.str());
}
GDALDataType band_type = band->GetRasterDataType();
switch (band_type)
{
case GDT_Byte:
{
mapnik::image_gray8 image(im_width, im_height);
image.set(std::numeric_limits<std::uint8_t>::max());
raster_nodata = band->GetNoDataValue(&raster_has_nodata);
raster_io_error = band->RasterIO(GF_Read, x_off, y_off, width, height,
image.data(), image.width(), image.height(),
GDT_Byte, 0, 0);
if (raster_io_error == CE_Failure)
{
throw datasource_exception(CPLGetLastErrorMsg());
}
mapnik::raster_ptr raster = std::make_shared<mapnik::raster>(intersect, image, filter_factor);
// set nodata value to be used in raster colorizer
if (nodata_value_) raster->set_nodata(*nodata_value_);
else raster->set_nodata(raster_nodata);
feature->set_raster(raster);
break;
}
case GDT_Float64:
case GDT_Float32:
{
mapnik::image_gray32f image(im_width, im_height);
image.set(std::numeric_limits<float>::max());
raster_nodata = band->GetNoDataValue(&raster_has_nodata);
raster_io_error = band->RasterIO(GF_Read, x_off, y_off, width, height,
image.data(), image.width(), image.height(),
GDT_Float32, 0, 0);
if (raster_io_error == CE_Failure)
{
throw datasource_exception(CPLGetLastErrorMsg());
}
mapnik::raster_ptr raster = std::make_shared<mapnik::raster>(intersect, image, filter_factor);
// set nodata value to be used in raster colorizer
if (nodata_value_) raster->set_nodata(*nodata_value_);
else raster->set_nodata(raster_nodata);
feature->set_raster(raster);
break;
}
case GDT_UInt16:
{
mapnik::image_gray16 image(im_width, im_height);
image.set(std::numeric_limits<std::uint16_t>::max());
raster_nodata = band->GetNoDataValue(&raster_has_nodata);
raster_io_error = band->RasterIO(GF_Read, x_off, y_off, width, height,
image.data(), image.width(), image.height(),
GDT_UInt16, 0, 0);
if (raster_io_error == CE_Failure)
{
throw datasource_exception(CPLGetLastErrorMsg());
}
mapnik::raster_ptr raster = std::make_shared<mapnik::raster>(intersect, image, filter_factor);
// set nodata value to be used in raster colorizer
if (nodata_value_) raster->set_nodata(*nodata_value_);
else raster->set_nodata(raster_nodata);
feature->set_raster(raster);
break;
}
default:
case GDT_Int16:
{
mapnik::image_gray16s image(im_width, im_height);
image.set(std::numeric_limits<std::int16_t>::max());
raster_nodata = band->GetNoDataValue(&raster_has_nodata);
raster_io_error = band->RasterIO(GF_Read, x_off, y_off, width, height,
image.data(), image.width(), image.height(),
GDT_Int16, 0, 0);
if (raster_io_error == CE_Failure)
{
throw datasource_exception(CPLGetLastErrorMsg());
}
mapnik::raster_ptr raster = std::make_shared<mapnik::raster>(intersect, image, filter_factor);
// set nodata value to be used in raster colorizer
if (nodata_value_) raster->set_nodata(*nodata_value_);
else raster->set_nodata(raster_nodata);
feature->set_raster(raster);
break;
}
}
}
else // working with all bands
{
mapnik::image_rgba8 image(im_width, im_height);
image.set(std::numeric_limits<std::uint32_t>::max());
for (int i = 0; i < nbands_; ++i)
{
GDALRasterBand * band = dataset_.GetRasterBand(i + 1);
#ifdef MAPNIK_LOG
get_overview_meta(band);
#endif
GDALColorInterp color_interp = band->GetColorInterpretation();
switch (color_interp)
{
case GCI_RedBand:
red = band;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found red band";
break;
case GCI_GreenBand:
green = band;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found green band";
break;
case GCI_BlueBand:
blue = band;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found blue band";
break;
case GCI_AlphaBand:
alpha = band;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found alpha band";
break;
case GCI_GrayIndex:
grey = band;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found gray band";
break;
case GCI_PaletteIndex:
{
grey = band;
#ifdef MAPNIK_LOG
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found gray band, and colortable...";
GDALColorTable *color_table = band->GetColorTable();
if (color_table)
{
int count = color_table->GetColorEntryCount();
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Color Table count=" << count;
for (int j = 0; j < count; j++)
{
const GDALColorEntry *ce = color_table->GetColorEntry (j);
if (! ce) continue;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Color entry RGB=" << ce->c1 << "," <<ce->c2 << "," << ce->c3;
}
}
#endif
break;
}
case GCI_Undefined:
#if GDAL_VERSION_NUM <= 1730
if (nbands_ == 4)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found undefined band (assumming alpha band)";
alpha = band;
}
else
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found undefined band (assumming gray band)";
grey = band;
}
#else
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found undefined band (assumming gray band)";
grey = band;
#endif
break;
default:
MAPNIK_LOG_WARN(gdal) << "gdal_featureset: Band type unknown!";
break;
}
}
if (red && green && blue)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Processing rgb bands...";
raster_nodata = red->GetNoDataValue(&raster_has_nodata);
GDALColorTable *color_table = red->GetColorTable();
bool has_nodata = nodata_value_ || raster_has_nodata;
// we can deduce the alpha channel from nodata in the Byte case
// by reusing the reading of R,G,B bands directly
if (has_nodata && !color_table && red->GetRasterDataType() == GDT_Byte)
{
double apply_nodata = nodata_value_ ? *nodata_value_ : raster_nodata;
// read the data in and create an alpha channel from the nodata values
// TODO - we assume here the nodata value for the red band applies to all bands
// more details about this at http://trac.osgeo.org/gdal/ticket/2734
float* imageData = (float*)image.bytes();
raster_io_error = red->RasterIO(GF_Read, x_off, y_off, width, height,
imageData, image.width(), image.height(),
GDT_Float32, 0, 0);
if (raster_io_error == CE_Failure) {
throw datasource_exception(CPLGetLastErrorMsg());
}
int len = image.width() * image.height();
for (int i = 0; i < len; ++i)
{
if (std::fabs(apply_nodata - imageData[i]) < nodata_tolerance_)
{
*reinterpret_cast<unsigned *>(&imageData[i]) = 0;
}
else
{
*reinterpret_cast<unsigned *>(&imageData[i]) = 0xFFFFFFFF;
}
}
}
/* Use dataset RasterIO in priority in 99.9% of the cases */
if( red->GetBand() == 1 && green->GetBand() == 2 && blue->GetBand() == 3 )
{
int nBandsToRead = 3;
if( alpha != NULL && alpha->GetBand() == 4 && !raster_has_nodata )
{
nBandsToRead = 4;
alpha = NULL; // to avoid reading it again afterwards
}
raster_io_error = dataset_.RasterIO(GF_Read, x_off, y_off, width, height,
image.bytes(),
image.width(), image.height(), GDT_Byte,
nBandsToRead, NULL,
4, 4 * image.width(), 1);
if (raster_io_error == CE_Failure) {
throw datasource_exception(CPLGetLastErrorMsg());
}
}
else
{
raster_io_error = red->RasterIO(GF_Read, x_off, y_off, width, height, image.bytes() + 0,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
if (raster_io_error == CE_Failure) {
throw datasource_exception(CPLGetLastErrorMsg());
}
raster_io_error = green->RasterIO(GF_Read, x_off, y_off, width, height, image.bytes() + 1,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
if (raster_io_error == CE_Failure) {
throw datasource_exception(CPLGetLastErrorMsg());
}
raster_io_error = blue->RasterIO(GF_Read, x_off, y_off, width, height, image.bytes() + 2,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
if (raster_io_error == CE_Failure) {
throw datasource_exception(CPLGetLastErrorMsg());
}
}
// In the case we skipped initializing the alpha channel
if (has_nodata && !color_table && red->GetRasterDataType() == GDT_Byte)
{
double apply_nodata = nodata_value_ ? *nodata_value_ : raster_nodata;
if( apply_nodata >= 0 && apply_nodata <= 255 )
{
int len = image.width() * image.height();
GByte* pabyBytes = (GByte*) image.bytes();
for (int i = 0; i < len; ++i)
{
// TODO - we assume here the nodata value for the red band applies to all bands
// more details about this at http://trac.osgeo.org/gdal/ticket/2734
if (std::fabs(apply_nodata - pabyBytes[4*i]) < nodata_tolerance_)
pabyBytes[4*i + 3] = 0;
else
pabyBytes[4*i + 3] = 255;
}
}
}
}
else if (grey)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Processing gray band...";
raster_nodata = grey->GetNoDataValue(&raster_has_nodata);
GDALColorTable* color_table = grey->GetColorTable();
bool has_nodata = nodata_value_ || raster_has_nodata;
if (!color_table && has_nodata)
{
double apply_nodata = nodata_value_ ? *nodata_value_ : raster_nodata;
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: applying nodata value for layer=" << apply_nodata;
// first read the data in and create an alpha channel from the nodata values
float* imageData = (float*)image.bytes();
raster_io_error = grey->RasterIO(GF_Read, x_off, y_off, width, height,
imageData, image.width(), image.height(),
GDT_Float32, 0, 0);
if (raster_io_error == CE_Failure)
{
throw datasource_exception(CPLGetLastErrorMsg());
}
int len = image.width() * image.height();
for (int i = 0; i < len; ++i)
{
if (std::fabs(apply_nodata - imageData[i]) < nodata_tolerance_)
{
*reinterpret_cast<unsigned *>(&imageData[i]) = 0;
}
else
{
*reinterpret_cast<unsigned *>(&imageData[i]) = 0xFFFFFFFF;
}
}
}
raster_io_error = grey->RasterIO(GF_Read, x_off, y_off, width, height, image.bytes() + 0,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
if (raster_io_error == CE_Failure)
{
throw datasource_exception(CPLGetLastErrorMsg());
}
raster_io_error = grey->RasterIO(GF_Read,x_off, y_off, width, height, image.bytes() + 1,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
if (raster_io_error == CE_Failure)
{
throw datasource_exception(CPLGetLastErrorMsg());
}
raster_io_error = grey->RasterIO(GF_Read,x_off, y_off, width, height, image.bytes() + 2,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
if (raster_io_error == CE_Failure)
{
throw datasource_exception(CPLGetLastErrorMsg());
}
if (color_table)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Loading color table...";
for (unsigned y = 0; y < image.height(); ++y)
{
unsigned int* row = image.get_row(y);
for (unsigned x = 0; x < image.width(); ++x)
{
unsigned value = row[x] & 0xff;
const GDALColorEntry *ce = color_table->GetColorEntry(value);
if (ce)
{
row[x] = (ce->c4 << 24)| (ce->c3 << 16) | (ce->c2 << 8) | (ce->c1) ;
}
else
{
// make lacking color entry fully alpha
// note - gdal_translate makes black
row[x] = 0;
}
}
}
}
}
if (alpha)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: processing alpha band...";
if (!raster_has_nodata)
{
raster_io_error = alpha->RasterIO(GF_Read, x_off, y_off, width, height, image.bytes() + 3,
image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
if (raster_io_error == CE_Failure) {
throw datasource_exception(CPLGetLastErrorMsg());
}
}
else
{
MAPNIK_LOG_WARN(gdal) << "warning: nodata value (" << raster_nodata << ") used to set transparency instead of alpha band";
}
}
mapnik::raster_ptr raster = std::make_shared<mapnik::raster>(intersect, image, filter_factor);
// set nodata value to be used in raster colorizer
if (nodata_value_) raster->set_nodata(*nodata_value_);
else raster->set_nodata(raster_nodata);
feature->set_raster(raster);
}
// report actual/original source nodata in feature attributes
if (raster_has_nodata)
{
feature->put("nodata",raster_nodata);
}
return feature;
}
}
return feature_ptr();
}
bool vtImageGeo::ReadTIF(const char *filename, bool progress_callback(int))
{
// Use GDAL to read a TIF file (or any other format that GDAL is
// configured to read) into this OSG image.
bool bRet = true;
vtString message;
setFileName(filename);
g_GDALWrapper.RequestGDALFormats();
GDALDataset *pDataset = NULL;
GDALRasterBand *pBand;
GDALRasterBand *pRed = NULL;
GDALRasterBand *pGreen = NULL;
GDALRasterBand *pBlue = NULL;
GDALRasterBand *pAlpha = NULL;
GDALColorTable *pTable;
uchar *pScanline = NULL;
uchar *pRedline = NULL;
uchar *pGreenline = NULL;
uchar *pBlueline = NULL;
uchar *pAlphaline = NULL;
CPLErr Err;
bool bColorPalette = false;
int iXSize, iYSize;
int nxBlocks, nyBlocks;
int xBlockSize, yBlockSize;
try
{
pDataset = (GDALDataset *) GDALOpen(filename, GA_ReadOnly);
if(pDataset == NULL )
throw "Couldn't open that file.";
// Get size
iXSize = pDataset->GetRasterXSize();
iYSize = pDataset->GetRasterYSize();
// Try getting CRS
vtProjection temp;
bool bHaveProj = false;
const char *pProjectionString = pDataset->GetProjectionRef();
if (pProjectionString)
{
OGRErr err = temp.importFromWkt((char**)&pProjectionString);
if (err == OGRERR_NONE)
{
m_proj = temp;
bHaveProj = true;
}
}
if (!bHaveProj)
{
// check for existence of .prj file
bool bSuccess = temp.ReadProjFile(filename);
if (bSuccess)
{
m_proj = temp;
bHaveProj = true;
}
}
// Try getting extents
double affineTransform[6];
if (pDataset->GetGeoTransform(affineTransform) == CE_None)
{
m_extents.left = affineTransform[0];
m_extents.right = m_extents.left + affineTransform[1] * iXSize;
m_extents.top = affineTransform[3];
m_extents.bottom = m_extents.top + affineTransform[5] * iYSize;
}
// Raster count should be 3 for colour images (assume RGB)
int iRasterCount = pDataset->GetRasterCount();
if (iRasterCount != 1 && iRasterCount != 3 && iRasterCount != 4)
{
message.Format("Image has %d bands (not 1, 3, or 4).", iRasterCount);
throw (const char *)message;
}
if (iRasterCount == 1)
{
pBand = pDataset->GetRasterBand(1);
// Check the band's data type
GDALDataType dtype = pBand->GetRasterDataType();
if (dtype != GDT_Byte)
{
message.Format("Band is of type %s, but we support type Byte.", GDALGetDataTypeName(dtype));
throw (const char *)message;
}
GDALColorInterp ci = pBand->GetColorInterpretation();
if (ci == GCI_PaletteIndex)
{
if (NULL == (pTable = pBand->GetColorTable()))
throw "Couldn't get color table.";
bColorPalette = true;
}
else if (ci == GCI_GrayIndex)
{
// we will assume 0-255 is black to white
}
else
throw "Unsupported color interpretation.";
pBand->GetBlockSize(&xBlockSize, &yBlockSize);
nxBlocks = (iXSize + xBlockSize - 1) / xBlockSize;
nyBlocks = (iYSize + yBlockSize - 1) / yBlockSize;
if (NULL == (pScanline = new uchar[xBlockSize * yBlockSize]))
throw "Couldnt allocate scan line.";
}
if (iRasterCount == 3)
{
for (int i = 1; i <= 3; i++)
{
pBand = pDataset->GetRasterBand(i);
// Check the band's data type
GDALDataType dtype = pBand->GetRasterDataType();
if (dtype != GDT_Byte)
{
message.Format("Band is of type %s, but we support type Byte.", GDALGetDataTypeName(dtype));
throw (const char *)message;
}
switch (pBand->GetColorInterpretation())
{
case GCI_RedBand:
pRed = pBand;
break;
case GCI_GreenBand:
pGreen = pBand;
break;
case GCI_BlueBand:
pBlue = pBand;
break;
}
}
if ((NULL == pRed) || (NULL == pGreen) || (NULL == pBlue))
throw "Couldn't find bands for Red, Green, Blue.";
pRed->GetBlockSize(&xBlockSize, &yBlockSize);
nxBlocks = (iXSize + xBlockSize - 1) / xBlockSize;
nyBlocks = (iYSize + yBlockSize - 1) / yBlockSize;
pRedline = new uchar[xBlockSize * yBlockSize];
pGreenline = new uchar[xBlockSize * yBlockSize];
pBlueline = new uchar[xBlockSize * yBlockSize];
}
if (iRasterCount == 4)
{
#if VTDEBUG
VTLOG1("Band interpretations:");
#endif
for (int i = 1; i <= 4; i++)
{
pBand = pDataset->GetRasterBand(i);
// Check the band's data type
GDALDataType dtype = pBand->GetRasterDataType();
if (dtype != GDT_Byte)
{
message.Format("Band is of type %s, but we support type Byte.", GDALGetDataTypeName(dtype));
throw (const char *)message;
}
GDALColorInterp ci = pBand->GetColorInterpretation();
#if VTDEBUG
VTLOG(" %d", ci);
#endif
switch (ci)
{
case GCI_RedBand:
pRed = pBand;
break;
case GCI_GreenBand:
pGreen = pBand;
break;
case GCI_BlueBand:
pBlue = pBand;
break;
case GCI_AlphaBand:
pAlpha = pBand;
break;
case GCI_Undefined:
// If we have four bands: R,G,B,undefined, then assume that
// the undefined one is actually alpha
if (pRed && pGreen && pBlue && !pAlpha)
pAlpha = pBand;
break;
}
}
#if VTDEBUG
VTLOG1("\n");
#endif
if ((NULL == pRed) || (NULL == pGreen) || (NULL == pBlue) || (NULL == pAlpha))
throw "Couldn't find bands for Red, Green, Blue, Alpha.";
pRed->GetBlockSize(&xBlockSize, &yBlockSize);
nxBlocks = (iXSize + xBlockSize - 1) / xBlockSize;
nyBlocks = (iYSize + yBlockSize - 1) / yBlockSize;
pRedline = new uchar[xBlockSize * yBlockSize];
pGreenline = new uchar[xBlockSize * yBlockSize];
pBlueline = new uchar[xBlockSize * yBlockSize];
pAlphaline = new uchar[xBlockSize * yBlockSize];
}
// Allocate the image buffer
if (iRasterCount == 4)
{
Create(iXSize, iYSize, 32);
}
else if (iRasterCount == 3 || bColorPalette)
{
Create(iXSize, iYSize, 24);
}
else if (iRasterCount == 1)
Create(iXSize, iYSize, 8);
// Read the data
#if LOG_IMAGE_LOAD
VTLOG("Reading the image data (%d x %d pixels)\n", iXSize, iYSize);
#endif
int x, y;
int ixBlock, iyBlock;
int nxValid, nyValid;
int iY, iX;
RGBi rgb;
RGBAi rgba;
if (iRasterCount == 1)
{
GDALColorEntry Ent;
for (iyBlock = 0; iyBlock < nyBlocks; iyBlock++)
{
if (progress_callback != NULL)
progress_callback(iyBlock * 100 / nyBlocks);
y = iyBlock * yBlockSize;
for (ixBlock = 0; ixBlock < nxBlocks; ixBlock++)
{
x = ixBlock * xBlockSize;
Err = pBand->ReadBlock(ixBlock, iyBlock, pScanline);
if (Err != CE_None)
throw "Problem reading the image data.";
// Compute the portion of the block that is valid
// for partial edge blocks.
if ((ixBlock+1) * xBlockSize > iXSize)
nxValid = iXSize - ixBlock * xBlockSize;
else
nxValid = xBlockSize;
if( (iyBlock+1) * yBlockSize > iYSize)
nyValid = iYSize - iyBlock * yBlockSize;
else
nyValid = yBlockSize;
for( iY = 0; iY < nyValid; iY++ )
{
for( iX = 0; iX < nxValid; iX++ )
{
if (bColorPalette)
{
pTable->GetColorEntryAsRGB(pScanline[iY * xBlockSize + iX], &Ent);
rgb.r = (uchar) Ent.c1;
rgb.g = (uchar) Ent.c2;
rgb.b = (uchar) Ent.c3;
SetPixel24(x + iX, y + iY, rgb);
}
else
SetPixel8(x + iX, y + iY, pScanline[iY * xBlockSize + iX]);
}
}
}
}
}
if (iRasterCount >= 3)
{
for (iyBlock = 0; iyBlock < nyBlocks; iyBlock++)
{
if (progress_callback != NULL)
progress_callback(iyBlock * 100 / nyBlocks);
y = iyBlock * yBlockSize;
for (ixBlock = 0; ixBlock < nxBlocks; ixBlock++)
{
x = ixBlock * xBlockSize;
Err = pRed->ReadBlock(ixBlock, iyBlock, pRedline);
if (Err != CE_None)
throw "Cannot read data.";
Err = pGreen->ReadBlock(ixBlock, iyBlock, pGreenline);
if (Err != CE_None)
throw "Cannot read data.";
Err = pBlue->ReadBlock(ixBlock, iyBlock, pBlueline);
if (Err != CE_None)
throw "Cannot read data.";
if (iRasterCount == 4)
{
Err = pAlpha->ReadBlock(ixBlock, iyBlock, pAlphaline);
if (Err != CE_None)
throw "Cannot read data.";
}
// Compute the portion of the block that is valid
// for partial edge blocks.
if ((ixBlock+1) * xBlockSize > iXSize)
nxValid = iXSize - ixBlock * xBlockSize;
else
nxValid = xBlockSize;
if( (iyBlock+1) * yBlockSize > iYSize)
nyValid = iYSize - iyBlock * yBlockSize;
else
nyValid = yBlockSize;
for (int iY = 0; iY < nyValid; iY++)
{
for (int iX = 0; iX < nxValid; iX++)
{
if (iRasterCount == 3)
{
rgb.r = pRedline[iY * xBlockSize + iX];
rgb.g = pGreenline[iY * xBlockSize + iX];
rgb.b = pBlueline[iY * xBlockSize + iX];
SetPixel24(x + iX, y + iY, rgb);
}
else if (iRasterCount == 4)
{
rgba.r = pRedline[iY * xBlockSize + iX];
rgba.g = pGreenline[iY * xBlockSize + iX];
rgba.b = pBlueline[iY * xBlockSize + iX];
rgba.a = pAlphaline[iY * xBlockSize + iX];
SetPixel32(x + iX, y + iY, rgba);
}
}
}
}
}
}
}
catch (const char *msg)
{
VTLOG1("Problem: ");
VTLOG1(msg);
VTLOG1("\n");
bRet = false;
}
if (NULL != pDataset)
GDALClose(pDataset);
if (NULL != pScanline)
delete pScanline;
if (NULL != pRedline)
delete pRedline;
if (NULL != pGreenline)
delete pGreenline;
if (NULL != pBlueline)
delete pBlueline;
if (NULL != pAlphaline)
delete pAlphaline;
return bRet;
}
static GDALDataset *FITCreateCopy(const char * pszFilename,
GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress,
void * pProgressData )
{
CPLDebug("FIT", "CreateCopy %s - %i", pszFilename, bStrict);
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"FIT driver does not support source dataset with zero band.\n");
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
if( !pfnProgress( 0.0, nullptr, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
return nullptr;
}
VSILFILE *fpImage = VSIFOpenL( pszFilename, "wb" );
if( fpImage == nullptr )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"FIT - unable to create file %s.\n",
pszFilename );
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Generate header. */
/* -------------------------------------------------------------------- */
// XXX - should FIT_PAGE_SIZE be based on file page size ??
const size_t size = std::max(sizeof(FIThead02), FIT_PAGE_SIZE);
FIThead02 *head = (FIThead02 *) malloc(size);
FreeGuard<FIThead02> guardHead( head );
// clean header so padding (past real header) is all zeros
memset( head, 0, size );
memcpy((char *) &head->magic, "IT", 2);
memcpy((char *) &head->version, "02", 2);
head->xSize = poSrcDS->GetRasterXSize();
gst_swapb(head->xSize);
head->ySize = poSrcDS->GetRasterYSize();
gst_swapb(head->ySize);
head->zSize = 1;
gst_swapb(head->zSize);
head->cSize = nBands;
gst_swapb(head->cSize);
GDALRasterBand *firstBand = poSrcDS->GetRasterBand(1);
if (! firstBand) {
CPL_IGNORE_RET_VAL(VSIFCloseL(fpImage));
return nullptr;
}
head->dtype = fitGetDataType(firstBand->GetRasterDataType());
if (! head->dtype) {
CPL_IGNORE_RET_VAL(VSIFCloseL(fpImage));
return nullptr;
}
gst_swapb(head->dtype);
head->order = 1; // interleaved - RGBRGB
gst_swapb(head->order);
head->space = 1; // upper left
gst_swapb(head->space);
// XXX - need to check all bands
head->cm = fitGetColorModel(firstBand->GetColorInterpretation(), nBands);
gst_swapb(head->cm);
int blockX, blockY;
firstBand->GetBlockSize(&blockX, &blockY);
blockX = std::min(blockX, poSrcDS->GetRasterXSize());
blockY = std::min(blockY, poSrcDS->GetRasterYSize());
int nDTSize = GDALGetDataTypeSizeBytes(firstBand->GetRasterDataType());
try
{
CPL_IGNORE_RET_VAL(
CPLSM(blockX) * CPLSM(blockY) * CPLSM(nDTSize) * CPLSM(nBands));
CPLDebug("FIT write", "inherited block size %ix%i", blockX, blockY);
}
catch( ... )
{
blockX = std::min(256, poSrcDS->GetRasterXSize());
blockY = std::min(256, poSrcDS->GetRasterYSize());
}
if( CSLFetchNameValue(papszOptions,"PAGESIZE") != nullptr )
{
const char *str = CSLFetchNameValue(papszOptions,"PAGESIZE");
int newBlockX, newBlockY;
sscanf(str, "%i,%i", &newBlockX, &newBlockY);
if (newBlockX && newBlockY) {
blockX = newBlockX;
blockY = newBlockY;
}
else {
CPLError(CE_Failure, CPLE_OpenFailed,
"FIT - Unable to parse option PAGESIZE values [%s]", str);
}
}
// XXX - need to do lots of checking of block size
// * provide ability to override block size with options
// * handle non-square block size (like scanline)
// - probably default from non-tiled image - have default block size
// * handle block size bigger than image size
// * undesirable block size (non power of 2, others?)
// * mismatched block sizes for different bands
// * image that isn't even pages (i.e. partially empty pages at edge)
CPLDebug("FIT write", "using block size %ix%i", blockX, blockY);
head->xPageSize = blockX;
gst_swapb(head->xPageSize);
head->yPageSize = blockY;
gst_swapb(head->yPageSize);
head->zPageSize = 1;
gst_swapb(head->zPageSize);
head->cPageSize = nBands;
gst_swapb(head->cPageSize);
// XXX - need to check all bands
head->minValue = firstBand->GetMinimum();
gst_swapb(head->minValue);
// XXX - need to check all bands
head->maxValue = firstBand->GetMaximum();
gst_swapb(head->maxValue);
head->dataOffset = static_cast<unsigned int>(size);
gst_swapb(head->dataOffset);
CPL_IGNORE_RET_VAL(VSIFWriteL(head, size, 1, fpImage));
/* -------------------------------------------------------------------- */
/* Loop over image, copying image data. */
/* -------------------------------------------------------------------- */
unsigned long bytesPerPixel = nBands * nDTSize;
size_t pageBytes = blockX * blockY * bytesPerPixel;
char *output = (char *) malloc(pageBytes);
if (! output)
{
CPLError(CE_Failure, CPLE_OutOfMemory,
"FITRasterBand couldn't allocate %lu bytes",
static_cast<unsigned long>(pageBytes));
CPL_IGNORE_RET_VAL(VSIFCloseL(fpImage));
return nullptr;
}
FreeGuard<char> guardOutput( output );
long maxx = (long) ceil(poSrcDS->GetRasterXSize() / (double) blockX);
long maxy = (long) ceil(poSrcDS->GetRasterYSize() / (double) blockY);
long maxx_full = (long) floor(poSrcDS->GetRasterXSize() / (double) blockX);
long maxy_full = (long) floor(poSrcDS->GetRasterYSize() / (double) blockY);
CPLDebug("FIT", "about to write %ld x %ld blocks", maxx, maxy);
for(long y=0; y < maxy; y++)
for(long x=0; x < maxx; x++) {
long readX = blockX;
long readY = blockY;
int do_clean = FALSE;
// handle cases where image size isn't an exact multiple
// of page size
if (x >= maxx_full) {
readX = poSrcDS->GetRasterXSize() % blockX;
do_clean = TRUE;
}
if (y >= maxy_full) {
readY = poSrcDS->GetRasterYSize() % blockY;
do_clean = TRUE;
}
// clean out image if only doing partial reads
if (do_clean)
memset( output, 0, pageBytes );
for( int iBand = 0; iBand < nBands; iBand++ ) {
GDALRasterBand * poBand = poSrcDS->GetRasterBand( iBand+1 );
CPLErr eErr =
poBand->RasterIO( GF_Read, // eRWFlag
static_cast<int>(x * blockX), // nXOff
static_cast<int>(y * blockY), // nYOff
static_cast<int>(readX), // nXSize
static_cast<int>(readY), // nYSize
output + iBand * nDTSize,
// pData
blockX, // nBufXSize
blockY, // nBufYSize
firstBand->GetRasterDataType(),
// eBufType
bytesPerPixel, // nPixelSpace
bytesPerPixel * blockX, nullptr); // nLineSpace
if (eErr != CE_None)
{
CPLError(CE_Failure, CPLE_FileIO,
"FIT write - CreateCopy got read error %i", eErr);
CPL_IGNORE_RET_VAL(VSIFCloseL( fpImage ));
VSIUnlink( pszFilename );
return nullptr;
}
} // for iBand
#ifdef swapping
char *p = output;
unsigned long i;
switch(nDTSize) {
case 1:
// do nothing
break;
case 2:
for(i=0; i < pageBytes; i+= nDTSize)
gst_swap16(p + i);
break;
case 4:
for(i=0; i < pageBytes; i+= nDTSize)
gst_swap32(p + i);
break;
case 8:
for(i=0; i < pageBytes; i+= nDTSize)
gst_swap64(p + i);
break;
default:
CPLError(CE_Failure, CPLE_NotSupported,
"FIT write - unsupported bytesPerPixel %d",
nDTSize);
} // switch
#endif // swapping
if( VSIFWriteL(output, 1, pageBytes, fpImage) != pageBytes )
{
CPLError( CE_Failure, CPLE_FileIO, "Write failed" );
CPL_IGNORE_RET_VAL(VSIFCloseL( fpImage ));
VSIUnlink( pszFilename );
return nullptr;
}
double perc = ((double) (y * maxx + x)) / (maxx * maxy);
if( !pfnProgress( perc, nullptr, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
//free(output);
CPL_IGNORE_RET_VAL(VSIFCloseL( fpImage ));
VSIUnlink( pszFilename );
return nullptr;
}
} // for x
//free(output);
CPL_IGNORE_RET_VAL(VSIFCloseL( fpImage ));
pfnProgress( 1.0, nullptr, pProgressData );
/* -------------------------------------------------------------------- */
/* Re-open dataset, and copy any auxiliary pam information. */
/* -------------------------------------------------------------------- */
GDALPamDataset *poDS = (GDALPamDataset *)
GDALOpen( pszFilename, GA_ReadOnly );
if( poDS )
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
return poDS;
}
CMapRaster::CMapRaster(const QString& fn, CCanvas * parent)
: IMap(eRaster, "",parent)
, x(0)
, y(0)
, zoomlevel(1)
, zoomfactor(1.0)
, rasterBandCount(0)
{
filename = fn;
#ifdef WIN32
dataset = (GDALDataset*)GDALOpen(filename.toLocal8Bit(),GA_ReadOnly);
#else
dataset = (GDALDataset*)GDALOpen(filename.toUtf8(),GA_ReadOnly);
#endif
if(dataset == 0)
{
QMessageBox::warning(0, tr("Error..."), tr("Failed to load file: %1").arg(filename));
return;
}
rasterBandCount = dataset->GetRasterCount();
if(rasterBandCount == 1)
{
GDALRasterBand * pBand;
pBand = dataset->GetRasterBand(1);
if(pBand == 0)
{
delete dataset; dataset = 0;
QMessageBox::warning(0, tr("Error..."), tr("Failed to load file: %1").arg(filename));
return;
}
if(pBand->GetColorInterpretation() != GCI_PaletteIndex && pBand->GetColorInterpretation() != GCI_GrayIndex)
{
delete dataset; dataset = 0;
QMessageBox::warning(0, tr("Error..."), tr("File must be 8 bit palette or gray indexed."));
return;
}
if(pBand->GetColorInterpretation() == GCI_PaletteIndex )
{
GDALColorTable * pct = pBand->GetColorTable();
for(int i=0; i < pct->GetColorEntryCount(); ++i)
{
const GDALColorEntry& e = *pct->GetColorEntry(i);
colortable << qRgba(e.c1, e.c2, e.c3, e.c4);
}
}
else if(pBand->GetColorInterpretation() == GCI_GrayIndex )
{
for(int i=0; i < 256; ++i)
{
colortable << qRgba(i, i, i, 255);
}
}
else
{
delete dataset; dataset = 0;
QMessageBox::warning(0, tr("Error..."), tr("File must be 8 bit palette or gray indexed."));
return;
}
int success = 0;
double idx = pBand->GetNoDataValue(&success);
if(success)
{
QColor tmp(colortable[idx]);
tmp.setAlpha(0);
colortable[idx] = tmp.rgba();
}
}
maparea.setWidth(dataset->GetRasterXSize());
maparea.setHeight(dataset->GetRasterYSize());
}
bool gstIconManager::CopyIcon(const std::string& src_path,
const std::string& dst_path) {
// file must not exist already
if (khExists(dst_path)) {
notify(NFY_WARN, "Icon \"%s\" already exists", dst_path.c_str());
return false;
}
GDALDataset* srcDataset = static_cast<GDALDataset*>(
GDALOpen(src_path.c_str(), GA_ReadOnly));
if (!srcDataset) {
notify(NFY_WARN, "Unable to open icon %s", src_path.c_str());
return false;
}
// determine the image type
// is it rgb or palette_index type
bool palette_type = false;
if (srcDataset->GetRasterCount() == 1 &&
srcDataset->GetRasterBand(1)->GetColorInterpretation() ==
GCI_PaletteIndex) {
palette_type = true;
} else if (srcDataset->GetRasterCount() != 4) {
notify(NFY_WARN, "%s: Image type not supported", src_path.c_str());
return false;
}
GDALDataset* oldSrcDataset = 0;
int target_size = 0;
bool need_scaling = false;
int srcXSize = srcDataset->GetRasterXSize();
int srcYSize = srcDataset->GetRasterYSize();
if ((srcXSize == 32) || (srcXSize == 64)) {
target_size = srcXSize;
if ((srcYSize != srcXSize) &&
(srcYSize != srcXSize*2) &&
(srcYSize != srcXSize*3)) {
need_scaling = true;
}
} else if (srcXSize < 32) {
target_size = 32;
need_scaling = true;
} else {
target_size = 64;
need_scaling = true;
}
if (need_scaling) {
// create a temp output dataset to scale the src
// icon to a square target_size*target_size. Later we'll make a stack.
VRTDataset* tempDataset = new VRTDataset(target_size, target_size);
int numBands = palette_type ? 1 : 4;
for (int b = 1; b <= numBands; ++b) {
tempDataset->AddBand(GDT_Byte, NULL);
VRTSourcedRasterBand* tempBand =
static_cast<VRTSourcedRasterBand*>(tempDataset->GetRasterBand(b));
GDALRasterBand* srcBand = srcDataset->GetRasterBand(b);
tempBand->AddSimpleSource(srcBand,
0, 0, srcXSize, srcYSize,
0, 0, target_size, target_size);
if (palette_type) {
tempBand->SetColorInterpretation(srcBand->GetColorInterpretation());
tempBand->SetColorTable(srcBand->GetColorTable());
}
}
oldSrcDataset = srcDataset;
srcDataset = tempDataset;
srcXSize = srcYSize = target_size;
}
assert(srcXSize == target_size);
// From here on we assume that we have a square, a stack of 2, or a stack of
// 3. It will be either 32 or 64 wide. The actual size is stored in srcXSize
// and srcYSize
bool simpleCopy = false;
if (srcYSize == srcXSize * 3)
simpleCopy = true;
// create a virtual dataset to represent the desired output image
VRTDataset* vds = new VRTDataset(target_size, target_size * 3);
// copy all the bands from the source
int numBands = palette_type ? 1 : 4;
for (int b = 1; b <= numBands; ++b) {
vds->AddBand(GDT_Byte, NULL);
VRTSourcedRasterBand* vrtBand =
static_cast<VRTSourcedRasterBand*>(vds->GetRasterBand(b));
GDALRasterBand* srcBand = srcDataset->GetRasterBand(b);
if (!simpleCopy) {
// extract the normal icon (on bottom of input image)
// and put it on the bottom of new image
// NOTE: srcYSize calculation lets us hand single, square images
// as well as two squares stacked on top of each other
vrtBand->AddSimpleSource(
srcBand,
0, srcYSize-target_size, target_size, target_size,
0, target_size*2, target_size, target_size);
// extract the highlight icon (on top of input image)
// and put it in the middle of new image
vrtBand->AddSimpleSource(srcBand,
0, 0, target_size, target_size,
0, target_size, target_size, target_size);
// extract the normal icon (on bottom of input image), scale it to 16x16
// and put it on the top of the new image
// NOTE: srcYSize calculation lets us hand single, square images
// as well as two squares stacked on top of each other
vrtBand->AddSimpleSource(
srcBand,
0, srcYSize-target_size, target_size, target_size,
0, 0, 16, 16);
} else {
vrtBand->AddSimpleSource(srcBand,
0, 0, target_size, target_size * 3,
0, 0, target_size, target_size * 3);
}
if (palette_type) {
vrtBand->SetColorInterpretation(srcBand->GetColorInterpretation());
vrtBand->SetColorTable(srcBand->GetColorTable());
}
}
// find output driver
GDALDriver* pngDriver = GetGDALDriverManager()->GetDriverByName("PNG");
if (pngDriver == NULL) {
notify(NFY_FATAL, "Unable to find png driver!");
return false;
}
// write out all bands at once
GDALDataset* dest = pngDriver->CreateCopy(
dst_path.c_str(), vds, false, NULL, NULL, NULL);
delete dest;
delete vds;
delete srcDataset;
delete oldSrcDataset;
// just in case the umask trimmed any permissions
khChmod(dst_path, 0666);
return true;
}
FXImage*
GUISUMOAbstractView::checkGDALImage(Decal& d) {
#ifdef HAVE_GDAL
GDALAllRegister();
GDALDataset* poDataset = (GDALDataset*)GDALOpen(d.filename.c_str(), GA_ReadOnly);
if (poDataset == 0) {
return 0;
}
const int xSize = poDataset->GetRasterXSize();
const int ySize = poDataset->GetRasterYSize();
// checking for geodata in the picture and try to adapt position and scale
if (d.width <= 0.) {
double adfGeoTransform[6];
if (poDataset->GetGeoTransform(adfGeoTransform) == CE_None) {
Position topLeft(adfGeoTransform[0], adfGeoTransform[3]);
const double horizontalSize = xSize * adfGeoTransform[1];
const double verticalSize = ySize * adfGeoTransform[5];
Position bottomRight(topLeft.x() + horizontalSize, topLeft.y() + verticalSize);
if (GeoConvHelper::getProcessing().x2cartesian(topLeft) && GeoConvHelper::getProcessing().x2cartesian(bottomRight)) {
d.width = bottomRight.x() - topLeft.x();
d.height = topLeft.y() - bottomRight.y();
d.centerX = (topLeft.x() + bottomRight.x()) / 2;
d.centerY = (topLeft.y() + bottomRight.y()) / 2;
//WRITE_MESSAGE("proj: " + toString(poDataset->GetProjectionRef()) + " dim: " + toString(d.width) + "," + toString(d.height) + " center: " + toString(d.centerX) + "," + toString(d.centerY));
} else {
WRITE_WARNING("Could not convert coordinates in " + d.filename + ".");
}
}
}
#endif
if (d.width <= 0.) {
d.width = getGridWidth();
d.height = getGridHeight();
}
// trying to read the picture
#ifdef HAVE_GDAL
const int picSize = xSize * ySize;
FXColor* result;
if (!FXMALLOC(&result, FXColor, picSize)) {
WRITE_WARNING("Could not allocate memory for " + d.filename + ".");
return 0;
}
for (int j = 0; j < picSize; j++) {
result[j] = FXRGB(0, 0, 0);
}
bool valid = true;
for (int i = 1; i <= poDataset->GetRasterCount(); i++) {
GDALRasterBand* poBand = poDataset->GetRasterBand(i);
int shift = -1;
if (poBand->GetColorInterpretation() == GCI_RedBand) {
shift = 0;
} else if (poBand->GetColorInterpretation() == GCI_GreenBand) {
shift = 1;
} else if (poBand->GetColorInterpretation() == GCI_BlueBand) {
shift = 2;
} else if (poBand->GetColorInterpretation() == GCI_AlphaBand) {
shift = 3;
} else {
WRITE_MESSAGE("Unknown color band in " + d.filename + ", maybe fox can parse it.");
valid = false;
break;
}
assert(xSize == poBand->GetXSize() && ySize == poBand->GetYSize());
if (poBand->RasterIO(GF_Read, 0, 0, xSize, ySize, ((unsigned char*)result) + shift, xSize, ySize, GDT_Byte, 4, 4 * xSize) == CE_Failure) {
valid = false;
break;
}
}
GDALClose(poDataset);
if (valid) {
return new FXImage(getApp(), result, IMAGE_OWNED | IMAGE_KEEP | IMAGE_SHMI | IMAGE_SHMP, xSize, ySize);
}
FXFREE(&result);
#endif
return 0;
}
GDALDataset *GSBGDataset::CreateCopy( const char *pszFilename,
GDALDataset *poSrcDS,
int bStrict, char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"GSBG driver does not support source dataset with zero band.\n");
return NULL;
}
else if (nBands > 1)
{
if( bStrict )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Unable to create copy, Golden Software Binary Grid "
"format only supports one raster band.\n" );
return NULL;
}
else
CPLError( CE_Warning, CPLE_NotSupported,
"Golden Software Binary Grid format only supports one "
"raster band, first band will be copied.\n" );
}
GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( 1 );
if( poSrcBand->GetXSize() > SHRT_MAX
|| poSrcBand->GetYSize() > SHRT_MAX )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"Unable to create grid, Golden Software Binary Grid format "
"only supports sizes up to %dx%d. %dx%d not supported.\n",
SHRT_MAX, SHRT_MAX,
poSrcBand->GetXSize(), poSrcBand->GetYSize() );
return NULL;
}
if( !pfnProgress( 0.0, NULL, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated\n" );
return NULL;
}
VSILFILE *fp = VSIFOpenL( pszFilename, "w+b" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file '%s' failed.\n",
pszFilename );
return NULL;
}
GInt16 nXSize = poSrcBand->GetXSize();
GInt16 nYSize = poSrcBand->GetYSize();
double adfGeoTransform[6];
poSrcDS->GetGeoTransform( adfGeoTransform );
double dfMinX = adfGeoTransform[0] + adfGeoTransform[1] / 2;
double dfMaxX = adfGeoTransform[1] * (nXSize - 0.5) + adfGeoTransform[0];
double dfMinY = adfGeoTransform[5] * (nYSize - 0.5) + adfGeoTransform[3];
double dfMaxY = adfGeoTransform[3] + adfGeoTransform[5] / 2;
CPLErr eErr = WriteHeader( fp, nXSize, nYSize,
dfMinX, dfMaxX, dfMinY, dfMaxY, 0.0, 0.0 );
if( eErr != CE_None )
{
VSIFCloseL( fp );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Copy band data. */
/* -------------------------------------------------------------------- */
float *pfData = (float *)VSIMalloc2( nXSize, sizeof( float ) );
if( pfData == NULL )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_OutOfMemory,
"Unable to create copy, unable to allocate line buffer.\n" );
return NULL;
}
int bSrcHasNDValue;
float fSrcNoDataValue = poSrcBand->GetNoDataValue( &bSrcHasNDValue );
double dfMinZ = DBL_MAX;
double dfMaxZ = -DBL_MAX;
for( GInt16 iRow = nYSize - 1; iRow >= 0; iRow-- )
{
eErr = poSrcBand->RasterIO( GF_Read, 0, iRow,
nXSize, 1, pfData,
nXSize, 1, GDT_Float32, 0, 0 );
if( eErr != CE_None )
{
VSIFCloseL( fp );
VSIFree( pfData );
return NULL;
}
for( int iCol=0; iCol<nXSize; iCol++ )
{
if( bSrcHasNDValue && pfData[iCol] == fSrcNoDataValue )
{
pfData[iCol] = fNODATA_VALUE;
}
else
{
if( pfData[iCol] > dfMaxZ )
dfMaxZ = pfData[iCol];
if( pfData[iCol] < dfMinZ )
dfMinZ = pfData[iCol];
}
CPL_LSBPTR32( pfData+iCol );
}
if( VSIFWriteL( (void *)pfData, 4, nXSize,
fp ) != static_cast<unsigned>(nXSize) )
{
VSIFCloseL( fp );
VSIFree( pfData );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write grid row. Disk full?\n" );
return NULL;
}
if( !pfnProgress( static_cast<double>(iRow)/nYSize,
NULL, pProgressData ) )
{
VSIFCloseL( fp );
VSIFree( pfData );
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
return NULL;
}
}
VSIFree( pfData );
/* write out the min and max values */
eErr = WriteHeader( fp, nXSize, nYSize,
dfMinX, dfMaxX, dfMinY, dfMaxY, dfMinZ, dfMaxZ );
if( eErr != CE_None )
{
VSIFCloseL( fp );
return NULL;
}
VSIFCloseL( fp );
GDALPamDataset *poDstDS = (GDALPamDataset *)GDALOpen( pszFilename,
GA_Update );
if( poDstDS == NULL )
{
VSIUnlink( pszFilename );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to open copy of dataset.\n" );
return NULL;
}
else if( dynamic_cast<GSBGDataset *>(poDstDS) == NULL )
{
VSIUnlink( pszFilename );
delete poDstDS;
CPLError( CE_Failure, CPLE_FileIO,
"Copy dataset not opened as Golden Surfer Binary Grid!?\n" );
return NULL;
}
GDALRasterBand *poDstBand = poSrcDS->GetRasterBand(1);
if( poDstBand == NULL )
{
VSIUnlink( pszFilename );
delete poDstDS;
CPLError( CE_Failure, CPLE_FileIO,
"Unable to open copy of raster band?\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Attempt to copy metadata. */
/* -------------------------------------------------------------------- */
if( !bStrict )
CPLPushErrorHandler( CPLQuietErrorHandler );
/* non-zero transform 2 or 4 or negative 1 or 5 not supported natively */
/*if( adfGeoTransform[2] != 0.0 || adfGeoTransform[4] != 0.0
|| adfGeoTransform[1] < 0.0 || adfGeoTransform[5] < 0.0 )
poDstDS->GDALPamDataset::SetGeoTransform( adfGeoTransform );*/
const char *szProjectionRef = poSrcDS->GetProjectionRef();
if( *szProjectionRef != '\0' )
poDstDS->SetProjection( szProjectionRef );
char **pszMetadata = poSrcDS->GetMetadata();
if( pszMetadata != NULL )
poDstDS->SetMetadata( pszMetadata );
/* FIXME: Should the dataset description be copied as well, or is it
* always the file name? */
poDstBand->SetDescription( poSrcBand->GetDescription() );
int bSuccess;
double dfOffset = poSrcBand->GetOffset( &bSuccess );
if( bSuccess && dfOffset != 0.0 )
poDstBand->SetOffset( dfOffset );
double dfScale = poSrcBand->GetScale( &bSuccess );
if( bSuccess && dfScale != 1.0 )
poDstBand->SetScale( dfScale );
GDALColorInterp oColorInterp = poSrcBand->GetColorInterpretation();
if( oColorInterp != GCI_Undefined )
poDstBand->SetColorInterpretation( oColorInterp );
char **pszCatNames = poSrcBand->GetCategoryNames();
if( pszCatNames != NULL)
poDstBand->SetCategoryNames( pszCatNames );
GDALColorTable *poColorTable = poSrcBand->GetColorTable();
if( poColorTable != NULL )
poDstBand->SetColorTable( poColorTable );
if( !bStrict )
CPLPopErrorHandler();
return poDstDS;
}
