GDALDataset* openGDALDataSet()
{
cout << "Opening " << inDataFile->c_str() << "...\n";
GDALDataset* ds = (GDALDataset *)GDALOpen(inDataFile->c_str(), GA_ReadOnly);
if (ds != NULL) {
GDALDriver* drv = ds->GetDriver();
if (drv == NULL) {
cout << " -- Unable to find GDAL driver for " << (char *)inDataFile->c_str() << " -- ";
ds = NULL;
} else {
cout << "GDAL FILE TYPE: " << drv->GetDescription() << "\n";
cout << "CONTAINS " << ds->GetRasterCount() << " dataset(s); size " << ds->GetRasterXSize() << "x" << ds->GetRasterYSize() << "\n";
if (ds->GetRasterCount() == 0) {
ds = NULL;
cout << " -- FILE " << (char *)inDataFile->c_str() << " contains zero raster bands -- ";
}
}
} else
cout << " -- Unable to open " << (char *)inDataFile->c_str() << " -- ";
cout << "...Done.\n";
return ds;
}
int PDSDataset::ParseCompressedImage()
{
CPLString osFileName = GetKeyword( "COMPRESSED_FILE.FILE_NAME", "" );
CleanString( osFileName );
CPLString osPath = CPLGetPath(GetDescription());
CPLString osFullFileName = CPLFormFilename( osPath, osFileName, NULL );
int iBand;
poCompressedDS = (GDALDataset*) GDALOpen( osFullFileName, GA_ReadOnly );
if( poCompressedDS == NULL )
return FALSE;
nRasterXSize = poCompressedDS->GetRasterXSize();
nRasterYSize = poCompressedDS->GetRasterYSize();
for( iBand = 0; iBand < poCompressedDS->GetRasterCount(); iBand++ )
{
SetBand( iBand+1, new PDSWrapperRasterBand( poCompressedDS->GetRasterBand( iBand+1 ) ) );
}
return TRUE;
}
/*! \file io.cpp
With a little bit of a elaboration, should you feel it necessary.
*/
int printRasterInfo(const char* pszFilename)
{
/** An enum type.
* The documentation block cannot be put after the enum!
*/
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
{
std::cout << "Dataset: " << pszFilename << std::endl;
double adfGeoTransform[6];
std::cout << " Driver: " << poDataset->GetDriver()->GetDescription() << "/" <<
poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) << std::endl;
std::cout << " Size: " << poDataset->GetRasterXSize() << "x" << poDataset->GetRasterYSize() << "x" <<
poDataset->GetRasterCount() << std::endl;
if( poDataset->GetProjectionRef() != NULL )
std::cout << " Projection: " << poDataset->GetProjectionRef() << std::endl;
if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None )
{
std::cout << " Origin: (" << adfGeoTransform[0] << ", " << adfGeoTransform[3] << ")" << std::endl;
std::cout << " Pixel Size: (" << adfGeoTransform[1] << ", " << adfGeoTransform[5] << std::endl;
}
}
return 0;
}
/**
*@brief tif图片投影转换
*@param tifPath [in] tif图片路径
*@param toWkt [in] 目标点的wkt字符串
*@param outPath [in] 转换后文件路径
*@return
*/
void GdalProjection::TifProjectionTransformation(const char *tifPath, const char *toWkt,const char *outPath)
{
GDALDataset *poDataset = gbase.OpenDatasetR(tifPath);
const char *fromWkt = poDataset->GetProjectionRef();
//double *adfGeoTransform = (double *)CPLMalloc(sizeof(double) * 6);
//int x = poDataset->GetRasterXSize();
//int y = poDataset->GetRasterYSize();
int bands = poDataset->GetRasterCount();
double adfGeoTransform[6];
GDALDataType gdt = poDataset->GetRasterBand(1)->GetRasterDataType();
void *hTransformArg;
//cout<<fromWkt;
hTransformArg = GDALCreateGenImgProjTransformer(poDataset,fromWkt,NULL,toWkt,FALSE,0,1);
//cout<<toWkt<<endl;
int nPixels = 0,nLines = 0;
CPLErr eErr;
eErr = GDALSuggestedWarpOutput(poDataset,GDALGenImgProjTransform,hTransformArg,
adfGeoTransform,&nPixels,&nLines);
//cout<<nPixels<<" : "<<nLines<<endl;
//创建转换后的投影和坐标系的空图像
CreateTiff(outPath,gdt,toWkt,adfGeoTransform,nPixels,nLines,bands);
////重投影
TifReProjection(tifPath,outPath);
}
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;
}
}
SEXP
RGDAL_GetRasterCount(SEXP sDataset) {
GDALDataset *pDataset = getGDALDatasetPtr(sDataset);
return(ScalarInteger(pDataset->GetRasterCount()));
}
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;
}
bool rgb_image::read_image()
{
int fd;
int i;
unsigned char header[16];
unsigned char jfif[] = {
0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46,
0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01
};
GDALDataset *df;
GDALRasterBand *bd;
int bands;
fd = open ( pathname.c_str(), O_RDWR );
if ( fd < 0 ) {
fprintf(stderr,"Could not open %s to patch jpeg header\n",
pathname.c_str() );
return false;
}
read ( fd, header, 16 );
if ( bcmp(header,jfif,4) != 0 ) {
fprintf(stderr,"Apparently %s is not a jpeg file\n",
pathname.c_str() );
return false;
}
if ( bcmp(header,jfif,16) != 0 ) {
lseek ( fd, (off_t)0, SEEK_SET );
write ( fd, jfif, 16 );
}
close ( fd );
df = (GDALDataset *) GDALOpen( pathname.c_str(), GA_ReadOnly );
if( df == NULL ) {
fprintf(stderr,"Could not open %s\n", pathname.c_str() );
exit(1);
}
rows = df->GetRasterYSize();
cols = df->GetRasterXSize();
bands = df->GetRasterCount();
//create_image(rows,cols);
if ( bands < 3 ) {
fprintf(stderr,"%s does not have 3 bands\n",
pathname.c_str() );
delete df;
return false;
}
for ( i = 0; i < 3; i++ ) {
bd = df->GetRasterBand(i+1);
bd->RasterIO ( GF_Read, 0,0, cols, rows, img[i].data, cols, rows,
GDT_Byte, 0,0);
}
delete df;
}
Handle<Value> DatasetBands::create(const Arguments& args)
{
HandleScope scope;
Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject();
Dataset *ds = ObjectWrap::Unwrap<Dataset>(parent);
if (ds->uses_ogr){
return NODE_THROW("Dataset does not support getting creating bands");
}
GDALDataset* raw = ds->getDataset();
if (!raw) {
return NODE_THROW("Dataset object has already been destroyed");
}
GDALDataType type;
Handle<Array> band_options = Array::New(0);
char **options = NULL;
std::string *options_str = NULL;
//NODE_ARG_ENUM(0, "data type", GDALDataType, type);
if(args.Length() < 1) {
return NODE_THROW("data type argument needed");
}
if(args[0]->IsString()){
std::string type_name = TOSTR(args[0]);
type = GDALGetDataTypeByName(type_name.c_str());
} else if (args[0]->IsNull() || args[0]->IsUndefined()) {
type = GDT_Unknown;
} else {
return NODE_THROW("data type must be string or undefined");
}
NODE_ARG_ARRAY_OPT(1, "band creation options", band_options);
if (band_options->Length() > 0) {
options = new char* [band_options->Length()];
options_str = new std::string [band_options->Length()];
for (unsigned int i = 0; i < band_options->Length(); ++i) {
options_str[i] = TOSTR(band_options->Get(i));
options[i] = (char*) options_str[i].c_str();
}
}
CPLErr err = raw->AddBand(type, options);
if(options) delete [] options;
if(options_str) delete [] options_str;
if (err) {
return NODE_THROW_CPLERR(err);
}
return scope.Close(RasterBand::New(raw->GetRasterBand(raw->GetRasterCount()), raw));
}
bool gstIconManager::Validate(const std::string& path) {
// ignore any non-png file
if (!khHasExtension(path, "png") && !khHasExtension(path, "PNG"))
return false;
bool valid = false;
GDALDataset* image = static_cast<GDALDataset*>(
GDALOpen(path.c_str(), GA_ReadOnly));
if (image != NULL && (image->GetRasterCount() == 4 ||
(image->GetRasterCount() == 1 &&
image->GetRasterBand(1)->GetColorInterpretation() == GCI_PaletteIndex))) {
valid = true;
}
delete image;
return valid;
}
bool ncepHrrrSurfInitialization::identify( std::string fileName )
{
bool identified = true;
if( fileName.find("nam") != fileName.npos ) {
identified = false;
return identified;
}
//ID based on 10u band
GDALDataset *srcDS;
srcDS = (GDALDataset*)GDALOpenShared( fileName.c_str(), GA_ReadOnly );
if( srcDS == NULL ) {
CPLDebug( "ncepHRRRSurfaceInitialization::identify()",
"Bad forecast file" );
return false;
}
if( srcDS->GetRasterCount() < 8 )
{
/* Short circuit */
GDALClose( (GDALDatasetH)srcDS );
identified = false;
return identified;
}
GDALRasterBand *poBand = srcDS->GetRasterBand( 33 ); //2010 structure
const char *gc;
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){
poBand = srcDS->GetRasterBand( 49 ); //files after 2010 have different structure
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
bandName = gc;
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){
poBand = srcDS->GetRasterBand( 50 ); //2012 files have different structure
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
bandName = gc;
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){
poBand = srcDS->GetRasterBand( 53 ); //2013 files have different structure
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
bandName = gc;
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){
identified = false;
}
}
}
}
GDALClose( (GDALDatasetH)srcDS );
return identified;
}
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_GetRasterCount(SEXP sDataset) {
GDALDataset *pDataset = getGDALDatasetPtr(sDataset);
int res;
installErrorHandler();
res = pDataset->GetRasterCount();
uninstallErrorHandlerAndTriggerError();
return(ScalarInteger(res));
}
bool vtImageInfo(const char *filename, int &width, int &height, int &depth)
{
g_GDALWrapper.RequestGDALFormats();
// open the input image and find out the image depth using gdal
GDALDataset *poDataset;
poDataset = (GDALDataset *) GDALOpen(filename, GA_ReadOnly);
if (!poDataset)
return false;
width = poDataset->GetRasterXSize();
height = poDataset->GetRasterYSize();
depth = poDataset->GetRasterCount()*8;
GDALClose(poDataset);
return true;
}
Handle<Value> DatasetBands::count(const Arguments& args)
{
HandleScope scope;
Handle<Object> parent = args.This()->GetHiddenValue(String::NewSymbol("parent_"))->ToObject();
Dataset *ds = ObjectWrap::Unwrap<Dataset>(parent);
if (ds->uses_ogr){
OGRDataSource* raw = ds->getDatasource();
if (!raw) {
return NODE_THROW("Dataset object has already been destroyed");
}
return scope.Close(Integer::New(0));
} else {
GDALDataset* raw = ds->getDataset();
if (!raw) {
return NODE_THROW("Dataset object has already been destroyed");
}
return scope.Close(Integer::New(raw->GetRasterCount()));
}
}
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 main( int nArgc, char ** papszArgv )
{
// register drivers
GDALAllRegister();
if( nArgc < 2 )
return EXIT_FAILURE;
double dfaCornersX[5] = {0};
double dfaCornersY[5] = {0};
CPLString sFileName;
// parse input values
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg],"-nw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[1] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[1] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-ne"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[2] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[2] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-se"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[3] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[3] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-sw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[4] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[4] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-c"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[0] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[0] = CPLAtofM(pszCoord);
}
else if(sFileName.empty())
sFileName = papszArgv[iArg];
}
OGRSpatialReference oOGRSpatialReference(SRS_WKT_WGS84);
int nZoneNo = ceil( (180.0 + dfaCornersX[0]) / 6.0 );
OGRSpatialReference oDstSpatialReference(SRS_WKT_WGS84);
oDstSpatialReference.SetUTM(nZoneNo, dfaCornersY[0] > 0);
// transform coordinates from WGS84 to UTM
OGRCoordinateTransformation *poCT = OGRCreateCoordinateTransformation( &oOGRSpatialReference, &oDstSpatialReference);
if(!poCT)
{
Usage("get coordinate transformation failed");
return EXIT_FAILURE;
}
int nResult = poCT->Transform(5, dfaCornersX, dfaCornersY, NULL);
if(!nResult)
{
Usage("transformation failed");
return EXIT_FAILURE;
}
// open input dataset
GDALDataset *poSrcDataset = (GDALDataset *) GDALOpen( sFileName, GA_ReadOnly ); // GA_Update
char* pszSpaRefDef = NULL;
if( oDstSpatialReference.exportToWkt(&pszSpaRefDef) != OGRERR_NONE)
{
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
return EXIT_FAILURE;
}
// search point along image
// add GCP to opened raster
OGRPoint ptCenter(dfaCornersX[0], dfaCornersY[0]);
OGRPoint pt1(dfaCornersX[1], dfaCornersY[1]); // NW Cormer
OGRPoint pt2(dfaCornersX[2], dfaCornersY[2]); // NE Corner
OGRPoint pt3(dfaCornersX[3], dfaCornersY[3]); // SE Corner
OGRPoint pt4(dfaCornersX[4], dfaCornersY[4]); // SW Corner
int nGCPCount = 0;
OGREnvelope DstEnv;
GDAL_GCP *paGSPs = PrepareGCP(sFileName, &pt1, &pt2, &pt3, &pt4, &ptCenter, oDstSpatialReference, poSrcDataset->GetRasterXSize(), poSrcDataset->GetRasterYSize(), nGCPCount, DstEnv);
if(poSrcDataset->SetGCPs(nGCPCount, paGSPs, pszSpaRefDef) != CE_None)
{
Usage( "Set GCPs failed" );
return EXIT_FAILURE;
}
// create warper
char **papszTO = NULL;
papszTO = CSLSetNameValue( papszTO, "METHOD", "GCP_TPS" );
papszTO = CSLSetNameValue( papszTO, "NUM_THREADS", "4" );
papszTO = CSLSetNameValue( papszTO, "DST_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "SRC_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "INSERT_CENTER_LONG", "FALSE" );
GDALDriver *poOutputDriver = (GDALDriver *) GDALGetDriverByName( "GTiff" );
CPLSetConfigOption( "CHECK_WITH_INVERT_PROJ", "TRUE" );
void* hTransformArg = GDALCreateGenImgProjTransformer2( poSrcDataset, NULL, papszTO );
GDALTransformerInfo* psInfo = (GDALTransformerInfo*)hTransformArg;
double adfThisGeoTransform[6];
double adfExtent[4];
int nThisPixels, nThisLines;
// suggest the raster output size
if( GDALSuggestedWarpOutput2( poSrcDataset, psInfo->pfnTransform, hTransformArg, adfThisGeoTransform, &nThisPixels, &nThisLines, adfExtent, 0 ) != CE_None )
{
Usage( "Suggest Output failed" );
return EXIT_FAILURE;
}
adfThisGeoTransform[0] = DstEnv.MinX;
adfThisGeoTransform[3] = DstEnv.MaxY;
int nPixels = (int) ((DstEnv.MaxX - DstEnv.MinX) / adfThisGeoTransform[1] + 0.5);
int nLines = (int) ((DstEnv.MaxY - DstEnv.MinY) / -adfThisGeoTransform[5] + 0.5);
GDALSetGenImgProjTransformerDstGeoTransform( hTransformArg, adfThisGeoTransform);
// create new raster
CPLString sOutputRasterPath = CPLResetExtension(sFileName, "tif");
GDALDataset *poDstDataset = poOutputDriver->Create(sOutputRasterPath, nPixels, nLines, poSrcDataset->GetRasterCount(), GDT_Byte, NULL );
if( NULL == poDstDataset )
{
Usage( "Create Output failed" );
return EXIT_FAILURE;
}
poDstDataset->SetProjection( pszSpaRefDef );
poDstDataset->SetGeoTransform( adfThisGeoTransform );
#ifdef APRROX_MAXERROR
hTransformArg = GDALCreateApproxTransformer( GDALGenImgProjTransform, hTransformArg, APRROX_MAXERROR);
GDALTransformerFunc pfnTransformer = GDALApproxTransform;
GDALApproxTransformerOwnsSubtransformer(hTransformArg, TRUE);
#else
GDALTransformerFunc pfnTransformer = GDALGenImgProjTransform;
#endif // APRROX_MAXERROR
// warp
GDALWarpOptions *psWO = GDALCreateWarpOptions();
psWO->eWorkingDataType = GDT_Byte;
psWO->eResampleAlg = GRA_NearestNeighbour;
psWO->hSrcDS = poSrcDataset;
psWO->hDstDS = poDstDataset;
psWO->pfnTransformer = pfnTransformer;
psWO->pTransformerArg = hTransformArg;
psWO->pfnProgress = GDALTermProgress;
psWO->nBandCount = poSrcDataset->GetRasterCount();
psWO->panSrcBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
psWO->panDstBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
for(int i = 0; i < psWO->nBandCount; ++i )
{
psWO->panSrcBands[i] = i+1;
psWO->panDstBands[i] = i+1;
}
GDALWarpOperation oWO;
if( oWO.Initialize( psWO ) == CE_None )
{
#ifdef MULTI
if( oWO.ChunkAndWarpMulti( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#else //MULTI
if( oWO.ChunkAndWarpImage( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#endif //MULTI
{
const char* err = CPLGetLastErrorMsg();
Usage( CPLSPrintf("Warp failed.%s", err) );
return EXIT_FAILURE;
}
}
// cleanup
GDALDestroyWarpOptions( psWO );
CSLDestroy( papszTO );
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
GDALClose( (GDALDatasetH) poDstDataset );
GDALDestroyDriverManager();
return EXIT_SUCCESS;
}
int32_t RadiationUniform(char* filepath1, char* logfilepath, vector<double>& striperesult) {
GDALDataset *poDataset;
GDALAllRegister();
poDataset=(GDALDataset *)GDALOpen(filepath1,GA_ReadOnly);
if( poDataset == NULL ) {
cerr << "RadiationUniform filepath " << filepath1 << endl;
WriteMsg(logfilepath,-1,"Image file open error!");
return -1;
} else {
WriteMsg(logfilepath,0,"Striperesidual algorithm is executing!");
}
int32_t n,i,j;
int32_t bandnum,width,height;
bandnum=poDataset->GetRasterCount();
width=poDataset->GetRasterXSize();
height=poDataset->GetRasterYSize();
GDALRasterBand *pband;
uint16_t *banddata=(uint16_t *)CPLMalloc(sizeof(uint16_t)*width*height);
for(n=0;n<bandnum;n++) {
pband=poDataset->GetRasterBand(n+1);
pband->RasterIO(GF_Read,0,0,width,height,banddata,width,height,GDT_UInt16,0,0);
double *colmeans=(double *)CPLMalloc(sizeof(double)*width);
double imgmean=0.0;
for(j=0;j<width;j++) {
colmeans[j]=0.0;
}
for(i=0;i<height;i++) {
for(j=0;j<width;j++) {
colmeans[j]=colmeans[j]+banddata[i*width+j]/(double)height;
}
}
for(j=0;j<width;j++) {
imgmean = imgmean+colmeans[j]/(double)width;
}
double sum=0.0;
for(j=1;j<width;j++) {
sum = sum + (colmeans[j]-imgmean)*(colmeans[j]-imgmean)/width;
}
striperesult.push_back(100.0*(1-sqrt(sum)/imgmean));
CPLFree(colmeans);
colmeans=NULL;
GDALClose(pband);
pband=NULL;
//Writing the process and status of this Algorithm.
int32_t temp = (int)(100.0*(n+1)/bandnum);
temp = (temp>99) ? 99:temp;
WriteMsg(logfilepath,temp,"Striperesidual algorithm is executing!");
}
CPLFree(banddata);
banddata=NULL;
GDALClose(poDataset);
poDataset=NULL;
return 1;
}
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;
}
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));
}
gdal_datasource::gdal_datasource(parameters const& params)
: datasource(params),
desc_(gdal_datasource::name(), "utf-8"),
nodata_value_(params.get<double>("nodata")),
nodata_tolerance_(*params.get<double>("nodata_tolerance",1e-12))
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Initializing...";
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "gdal_datasource::init");
#endif
GDALAllRegister();
boost::optional<std::string> file = params.get<std::string>("file");
if (! file) throw datasource_exception("missing <file> parameter");
boost::optional<std::string> base = params.get<std::string>("base");
if (base)
{
dataset_name_ = *base + "/" + *file;
}
else
{
dataset_name_ = *file;
}
shared_dataset_ = *params.get<mapnik::boolean_type>("shared", false);
band_ = *params.get<mapnik::value_integer>("band", -1);
GDALDataset *dataset = open_dataset();
nbands_ = dataset->GetRasterCount();
width_ = dataset->GetRasterXSize();
height_ = dataset->GetRasterYSize();
desc_.add_descriptor(mapnik::attribute_descriptor("nodata", mapnik::Double));
double tr[6];
bool bbox_override = false;
boost::optional<std::string> bbox_s = params.get<std::string>("extent");
if (bbox_s)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: BBox Parameter=" << *bbox_s;
bbox_override = extent_.from_string(*bbox_s);
if (! bbox_override)
{
throw datasource_exception("GDAL Plugin: bbox parameter '" + *bbox_s + "' invalid");
}
}
if (bbox_override)
{
tr[0] = extent_.minx();
tr[1] = extent_.width() / (double)width_;
tr[2] = 0;
tr[3] = extent_.maxy();
tr[4] = 0;
tr[5] = -extent_.height() / (double)height_;
MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource extent override gives Geotransform="
<< tr[0] << "," << tr[1] << ","
<< tr[2] << "," << tr[3] << ","
<< tr[4] << "," << tr[5];
}
else
{
if (dataset->GetGeoTransform(tr) != CPLE_None)
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource GetGeotransform failure gives="
<< tr[0] << "," << tr[1] << ","
<< tr[2] << "," << tr[3] << ","
<< tr[4] << "," << tr[5];
}
else
{
MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource Geotransform="
<< tr[0] << "," << tr[1] << ","
<< tr[2] << "," << tr[3] << ","
<< tr[4] << "," << tr[5];
}
}
// TODO - We should throw for true non-north up images, but the check
// below is clearly too restrictive.
// https://github.com/mapnik/mapnik/issues/970
/*
if (tr[2] != 0 || tr[4] != 0)
{
throw datasource_exception("GDAL Plugin: only 'north up' images are supported");
}
*/
dx_ = tr[1];
dy_ = tr[5];
if (! bbox_override)
{
double x0 = tr[0];
double y0 = tr[3];
double x1 = tr[0] + width_ * dx_ + height_ *tr[2];
double y1 = tr[3] + width_ *tr[4] + height_ * dy_;
/*
double x0 = tr[0] + (height_) * tr[2]; // minx
double y0 = tr[3] + (height_) * tr[5]; // miny
double x1 = tr[0] + (width_) * tr[1]; // maxx
double y1 = tr[3] + (width_) * tr[4]; // maxy
*/
extent_.init(x0, y0, x1, y1);
}
GDALClose(dataset);
MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Raster Size=" << width_ << "," << height_;
MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Raster Extent=" << extent_;
}
void gdal_datasource::bind() const
{
if (is_bound_) return;
shared_dataset_ = *params_.get<mapnik::boolean>("shared", false);
band_ = *params_.get<int>("band", -1);
GDALDataset *dataset = open_dataset();
nbands_ = dataset->GetRasterCount();
width_ = dataset->GetRasterXSize();
height_ = dataset->GetRasterYSize();
double tr[6];
bool bbox_override = false;
boost::optional<std::string> bbox_s = params_.get<std::string>("bbox");
if (bbox_s)
{
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: bbox parameter=" << *bbox_s << std::endl;
#endif
bbox_override = extent_.from_string(*bbox_s);
if (! bbox_override)
{
throw datasource_exception("GDAL Plugin: bbox parameter '" + *bbox_s + "' invalid");
}
}
if (bbox_override)
{
tr[0] = extent_.minx();
tr[1] = extent_.width() / (double)width_;
tr[2] = 0;
tr[3] = extent_.maxy();
tr[4] = 0;
tr[5] = -extent_.height() / (double)height_;
}
else
{
dataset->GetGeoTransform(tr);
}
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: geotransform=" << tr[0] << "," << tr[1] << ","
<< tr[2] << "," << tr[3] << ","
<< tr[4] << "," << tr[5] << std::endl;
#endif
// TODO - We should throw for true non-north up images, but the check
// below is clearly too restrictive.
// https://github.com/mapnik/mapnik/issues/970
/*
if (tr[2] != 0 || tr[4] != 0)
{
throw datasource_exception("GDAL Plugin: only 'north up' images are supported");
}
*/
dx_ = tr[1];
dy_ = tr[5];
if (! bbox_override)
{
double x0 = tr[0];
double y0 = tr[3];
double x1 = tr[0] + width_ * dx_ + height_ *tr[2];
double y1 = tr[3] + width_ *tr[4] + height_ * dy_;
/*
double x0 = tr[0] + (height_) * tr[2]; // minx
double y0 = tr[3] + (height_) * tr[5]; // miny
double x1 = tr[0] + (width_) * tr[1]; // maxx
double y1 = tr[3] + (width_) * tr[4]; // maxy
*/
extent_.init(x0, y0, x1, y1);
}
GDALClose(dataset);
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Raster Size=" << width_ << "," << height_ << std::endl;
std::clog << "GDAL Plugin: Raster Extent=" << extent_ << std::endl;
#endif
is_bound_ = true;
}
//Clarity-影像清晰度（点锐度算法）
int32_t Clarity(char* filepath,char* logfilepath, vector<double>& result) {
GDALDataset *poDataset = NULL;
GDALAllRegister();
poDataset=(GDALDataset *)GDALOpen(filepath,GA_ReadOnly);
if(poDataset == NULL) {
printf("Image file open error!\n");
WriteMsg(logfilepath,-1,"Image file open error!");
return -1;
} else {
printf("Clarity algorithm is executing!\n");
WriteMsg(logfilepath,0,"Clarity algorithm is executing!");
}
//开始解析图像数据集
int32_t n,i,j;
int32_t bandnum,width,height;
bandnum=poDataset->GetRasterCount();
width=poDataset->GetRasterXSize();
height=poDataset->GetRasterYSize();
GDALRasterBand *pband = NULL;
uint16_t *banddata=(uint16_t *)CPLMalloc(sizeof(uint16_t)*width*height);
for(n=0;n<bandnum;n++) {
pband=poDataset->GetRasterBand(n+1);
pband->RasterIO(GF_Read,0,0,width,height,banddata,width,height,GDT_UInt16,0,0);
double clarity=0.0;
int32_t blkcount=0;
for(i=1;i<height-1;i++) {
for(j=1;j<width-1;j++) {
if(banddata[i*width+j]==0)
continue;
double colmean=0.0;
colmean += fabs(1.0*banddata[(i-1)*width+(j-1)]-banddata[i*width+j])/sqrt(2.0);
colmean += fabs(1.0*banddata[(i-1)*width+j]-banddata[i*width+j]);
colmean += fabs(1.0*banddata[(i-1)*width+(j+1)]-banddata[i*width+j])/sqrt(2.0);
colmean += fabs(1.0*banddata[i*width+(j-1)]-banddata[i*width+j]);
colmean += fabs(1.0*banddata[i*width+(j+1)]-banddata[i*width+j]);
colmean += fabs(1.0*banddata[(i+1)*width+(j-1)]-banddata[i*width+j])/sqrt(2.0);
colmean += fabs(1.0*banddata[(i+1)*width+j]-banddata[i*width+j]);
colmean += fabs(1.0*banddata[(i+1)*width+(j+1)]-banddata[i*width+j])/sqrt(2.0);
colmean = colmean/8.0;
clarity +=colmean;
blkcount++;
}
}
result.push_back(clarity/blkcount);
GDALClose(pband);
pband=NULL;
//Writing the process and status of this Algorithm.
int32_t temp = (int)(100.0*(n+1)/bandnum);
temp = (temp>99) ? 99:temp;
printf("Clarity algorithm is executing %d%%!\n",temp);
WriteMsg(logfilepath,temp,"Clarity algorithm is executing!");
}
CPLFree(banddata);
banddata=NULL;
GDALClose(poDataset);
poDataset=NULL;
return 1;
}
int main(int argc, char *argv[]){
GDALDataset *poDataset;
GDALAllRegister();
if(argc != 3){
std::cout << "usage:\n" << argv[0] << " src_file dest_file\n";
exit(0);
}
const std::string name = argv[1];
const std::string destName = argv[2];
poDataset = (GDALDataset *) GDALOpen(name.c_str(), GA_ReadOnly );
if( poDataset == NULL ){
std::cout << "Failed to open " << name << "\n";
}else{
const char *pszFormat = "GTiff";
GDALDriver *poDriver;
char **papszMetadata;
poDriver = GetGDALDriverManager()->GetDriverByName(pszFormat);
if( poDriver == NULL ){
std::cout << "Cant open driver\n";
exit(1);
}
papszMetadata = GDALGetMetadata( poDriver, NULL );
if( !CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATE, FALSE ) ){
std::cout << "Create Method not suported!\n";
}
if( !CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATECOPY, FALSE ) ){
std::cout << "CreateCopy() method not suported.\n";
}
char **papszOptions = NULL;
GDALDataset *dest = poDriver->Create(destName.c_str() , poDataset->GetRasterXSize(),
poDataset->GetRasterYSize(), 3, GDT_Byte, papszOptions );
std::cout << "Reading file " << name << "\n";
std::cout <<
"x= " << poDataset->GetRasterXSize() <<
", h=" << poDataset->GetRasterYSize() <<
", bands= " << poDataset->GetRasterCount() << "\n";
GDALRasterBand *data;
data = poDataset->GetRasterBand(1);
GDALDataType type = data->GetRasterDataType();
printDataType(type);
int size = data->GetXSize()*data->GetYSize();
std::cout << "size=" << size << " , w*h = " << poDataset->GetRasterXSize()*poDataset->GetRasterYSize() << "\n";
float *buffer;
buffer = (float *) CPLMalloc(sizeof(float)*size);
data->RasterIO(GF_Read, 0, 0, data->GetXSize(), data->GetYSize(), buffer, data->GetXSize(), data->GetYSize(), GDT_Float32, 0, 0 );
GDALRasterBand *destBand1 = dest->GetRasterBand(1);
GDALRasterBand *destBand2 = dest->GetRasterBand(2);
GDALRasterBand *destBand3 = dest->GetRasterBand(3);
// GDALRasterBand *destBand4 = dest->GetRasterBand(4);
// Metadata,
double geot[6];
poDataset->GetGeoTransform(geot);
dest->SetGeoTransform(geot);// adfGeoTransform );
dest->SetProjection( poDataset->GetProjectionRef() );
GByte destWrite1[size]; // = (GUInt32 *) CPLMalloc(sizeof(GUInt32)*size);
GByte destWrite2[size];
GByte destWrite3[size];
// GByte destWrite4[size];
unsigned int i;
float max=0, min=0;
for(i=0; i<size; i++){
if(max < buffer[i]){
max = buffer[i];
}
if(min > buffer[i]){
min = buffer[i];
}
}
float range = max - min;
std::cout << "range=" << range << ", max=" << max << ", min=" << min << "\n";
std::map<float, unsigned int> counter;
for(i=0; i<size; i++){
counter[buffer[i]]++;
unsigned int v = buffer[i] * 100;
destWrite1[i] = (v & (0xff << 0)) >> 0;
destWrite2[i] = (v & (0xff << 8)) >> 8;
destWrite3[i] = (v & (0xff << 16)) >> 16;
// destWrite4[i] = 0x00; // (v & (0xff << 24)) >> 24;
}
destBand1->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(),
destWrite1, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 );
destBand2->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(),
destWrite2, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 );
destBand3->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(),
destWrite3, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 );
// destBand4->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(),
// destWrite4, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 );
/*std::map<float, unsigned int>::iterator it;
std::cout << "Counter: \n";
for(it=counter.begin(); it!=counter.end(); it++){
std::cout << (it->first*1000) << " = " << it->second << "\n";
}*/
/* Once we're done, close properly the dataset */
if( dest != NULL ){
GDALClose(dest );
GDALClose(poDataset );
}
/*
unsigned int *buffer;
buffer = (unsigned int *) CPLMalloc(sizeof(unsigned int)*size);
data->RasterIO(GF_Read, 0, 0, size, 1, buffer, size, 1, GDT_UInt32, 0, 0 );
unsigned int i;
std::map<unsigned int, unsigned int> counter;
for(i=0; i<size; i++){
counter[buffer[i]]++;
}
std::map<unsigned int, unsigned int>::iterator it;
std::cout << "Counter: \n";
for(it=counter.begin(); it!=counter.end(); it++){
std::cout << it->first << " = " << it->second << "\n";
}*/
}
exit(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 );
}
}
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;
}
int Image::scatterImageFileGDAL(const char * filename, int xOffset, int yOffset,
PV::Communicator * comm, const PVLayerLoc * loc, float * buf, bool autoResizeFlag)
{
int status = 0;
#ifdef PV_USE_GDAL
// const int maxBands = 3;
const int nxProcs = comm->numCommColumns();
const int nyProcs = comm->numCommRows();
const int icRank = comm->commRank();
const int nx = loc->nx;
const int ny = loc->ny;
const int numBands = loc->nf;
int numTotal; // will be nx*ny*bandsInFile;
const MPI_Comm mpi_comm = comm->communicator();
GDALDataType dataType;
char** metadata;
char isBinary = true;
if (icRank > 0) {
#ifdef PV_USE_MPI
const int src = 0;
const int tag = 13;
MPI_Bcast(&dataType, 1, MPI_INT, 0, mpi_comm);
MPI_Bcast(&isBinary, 1, MPI_CHAR, 0, mpi_comm);
MPI_Bcast(&numTotal, 1, MPI_INT, 0, mpi_comm);
#ifdef DEBUG_OUTPUT
fprintf(stderr, "[%2d]: scatterImageFileGDAL: received from 0, total number of bytes in buffer is %d\n", numTotal);
#endif // DEBUG_OUTPUT
MPI_Recv(buf, numTotal, MPI_FLOAT, src, tag, mpi_comm, MPI_STATUS_IGNORE);
#ifdef DEBUG_OUTPUT
int nf=numTotal/(nx*ny);
assert( nf*nx*ny == numTotal );
fprintf(stderr, "[%2d]: scatterImageFileGDAL: received from 0, nx==%d ny==%d nf==%d size==%d\n",
comm->commRank(), nx, ny, nf, numTotal);
#endif // DEBUG_OUTPUT
#endif // PV_USE_MPI
}
else {
GDALAllRegister();
GDALDataset * dataset = PV_GDALOpen(filename); // (GDALDataset *) GDALOpen(filename, GA_ReadOnly);
GDALRasterBand * poBand = dataset->GetRasterBand(1);
dataType = poBand->GetRasterDataType();
#ifdef PV_USE_MPI
MPI_Bcast(&dataType, 1, MPI_INT, 0, mpi_comm);
#endif // PV_USE_MPI
// GDAL defines whether a band is binary, not whether the image as a whole is binary.
// Set isBinary to false if any band is not binary (metadata doesn't have NBITS=1)
for(int iBand = 0; iBand < GDALGetRasterCount(dataset); iBand++){
GDALRasterBandH hBand = GDALGetRasterBand(dataset, iBand+1);
metadata = GDALGetMetadata(hBand, "Image_Structure");
if(CSLCount(metadata) > 0){
bool found = false;
for(int i = 0; metadata[i] != NULL; i++){
if(strcmp(metadata[i], "NBITS=1") == 0){
found = true;
break;
}
}
if(!found){
isBinary = false;
}
}
else{
isBinary = false;
}
}
#ifdef PV_USE_MPI
MPI_Bcast(&isBinary, 1, MPI_CHAR, 0, mpi_comm);
#endif // PV_USE_MPI
if (dataset==NULL) return 1; // PV_GDALOpen prints an error message.
int xImageSize = dataset->GetRasterXSize();
int yImageSize = dataset->GetRasterYSize();
const int bandsInFile = dataset->GetRasterCount();
numTotal = nx * ny * bandsInFile;
#ifdef PV_USE_MPI
#ifdef DEBUG_OUTPUT
fprintf(stderr, "[%2d]: scatterImageFileGDAL: broadcast from 0, total number of bytes in buffer is %d\n", numTotal);
#endif // DEBUG_OUTPUT
MPI_Bcast(&numTotal, 1, MPI_INT, 0, mpi_comm);
#endif // PV_USE_MPI
int xTotalSize = nx * nxProcs;
int yTotalSize = ny * nyProcs;
// if nf > bands of image, it will copy the gray image to each
//band of layer
assert(numBands == 1 || numBands == bandsInFile || (numBands > 1 && bandsInFile == 1));
int dest = -1;
const int tag = 13;
float padValue_conv;
if(dataType == GDT_Byte){
padValue_conv = padValue * 255.0f;
}
else if(dataType == GDT_UInt16){
padValue_conv = padValue * 65535.0f;
}
else{
std::cout << "Image data type " << GDALGetDataTypeName(dataType) << " not implemented for image rescaling\n";
exit(-1);
}
using std::min;
using std::max;
for( dest = nyProcs*nxProcs-1; dest >= 0; dest-- ) {
//Need to clear buffer before reading, since we're skipping some of the buffer
#ifdef PV_USE_OPENMP_THREADS
#pragma omp parallel for
#endif
for(int i = 0; i < nx * ny * bandsInFile; i++){
//Fill with padValue
buf[i] = padValue_conv;
}
int col = columnFromRank(dest,nyProcs,nxProcs);
int row = rowFromRank(dest,nyProcs,nxProcs);
int kx = nx * col;
int ky = ny * row;
//? For the auto resize flag, PV checks which side (x or y) is the shortest, relative to the
//? hypercolumn size specified. Then it determines the largest chunk it can possibly take
//? from the image with the correct aspect ratio determined by hypercolumn. It then
//? determines the offset needed in the long dimension to center the cropped image,
//? and reads in that portion of the image. The offset can optionally be translated by
//? offset{X,Y} specified in the params file (values can be positive or negative).
//? If the specified offset takes the cropped image outside the image file, it uses the
//? largest-magnitude offset that stays within the image file's borders.
if (autoResizeFlag){
if (xImageSize/(double)xTotalSize < yImageSize/(double)yTotalSize){
int new_y = int(round(ny*xImageSize/(double)xTotalSize));
int y_off = int(round((yImageSize - new_y*nyProcs)/2.0));
int jitter_y = max(min(y_off,yOffset),-y_off);
kx = xImageSize/nxProcs * col;
ky = new_y * row;
//fprintf(stderr, "kx = %d, ky = %d, nx = %d, new_y = %d", kx, ky, xImageSize/nxProcs, new_y);
dataset->RasterIO(GF_Read, kx, ky + y_off + jitter_y, xImageSize/nxProcs, new_y, buf, nx, ny,
GDT_Float32, bandsInFile, NULL, bandsInFile*sizeof(float),
bandsInFile*nx*sizeof(float), sizeof(float));
}
else{
int new_x = int(round(nx*yImageSize/(double)yTotalSize));
int x_off = int(round((xImageSize - new_x*nxProcs)/2.0));
int jitter_x = max(min(x_off,xOffset),-x_off);
kx = new_x * col;
ky = yImageSize/nyProcs * row;
//fprintf(stderr, "kx = %d, ky = %d, new_x = %d, ny = %d, x_off = %d", kx, ky, new_x, yImageSize/nyProcs, x_off);
dataset->RasterIO(GF_Read, kx + x_off + jitter_x, ky, new_x, yImageSize/nyProcs, buf, nx, ny,
GDT_Float32, bandsInFile, NULL, bandsInFile*sizeof(float),
bandsInFile*nx*sizeof(float),sizeof(float));
}
}//End autoResizeFlag
else {
//Need to calculate corner image pixels in globalres space
//offset is in Image space
int img_left = -xOffset;
int img_top = -yOffset;
int img_right = img_left + xImageSize;
int img_bot = img_top + yImageSize;
//Check if in bounds
if(img_left >= kx+nx || img_right <= kx || img_top >= ky+ny || img_bot <= ky){
//Do mpi_send to keep number of sends correct
if(dest > 0){
MPI_Send(buf, numTotal, MPI_FLOAT, dest, tag, mpi_comm);
}
continue;
}
//start of the buffer on the left/top side
int buf_left = img_left > kx ? img_left-kx : 0;
int buf_top = img_top > ky ? img_top-ky : 0;
int buf_right = img_right < kx+nx ? img_right-kx : nx;
int buf_bot = img_bot < ky+ny ? img_bot-ky : ny;
int buf_xSize = buf_right - buf_left;
int buf_ySize = buf_bot - buf_top;
assert(buf_xSize > 0 && buf_ySize > 0);
int buf_offset = buf_top * nx * bandsInFile + buf_left * bandsInFile;
int img_offset_x = kx+xOffset;
int img_offset_y = ky+yOffset;
if(img_offset_x < 0){
img_offset_x = 0;
}
if(img_offset_y < 0){
img_offset_y = 0;
}
float* buf_start = buf + buf_offset;
dataset->RasterIO(GF_Read, img_offset_x, img_offset_y, buf_xSize, buf_ySize, buf_start,
buf_xSize,
buf_ySize, GDT_Float32, bandsInFile, NULL,
bandsInFile*sizeof(float), bandsInFile*nx*sizeof(float), sizeof(float));
}
#ifdef DEBUG_OUTPUT
fprintf(stderr, "[%2d]: scatterImageFileGDAL: sending to %d xSize==%d"
" ySize==%d bandsInFile==%d size==%d total(over all procs)==%d\n",
comm->commRank(), dest, nx, ny, bandsInFile, numTotal,
nx*ny*comm->commSize());
#endif // DEBUG_OUTPUT
#ifdef PV_USE_MPI
if(dest > 0){
MPI_Send(buf, numTotal, MPI_FLOAT, dest, tag, mpi_comm);
}
#endif // PV_USE_MPI
}
GDALClose(dataset);
//Moved to above for loop
// get local image portion
//? same logic as before, except this time we know that the row and column are 0
//if (autoResizeFlag){
// if (xImageSize/(double)xTotalSize < yImageSize/(double)yTotalSize){
// int new_y = int(round(ny*xImageSize/(double)xTotalSize));
// int y_off = int(round((yImageSize - new_y*nyProcs)/2.0));
// int offset_y = max(min(y_off,yOffset),-y_off);
// //fprintf(stderr, "kx = %d, ky = %d, nx = %d, new_y = %d", 0, 0, xImageSize/nxProcs, new_y);
// dataset->RasterIO(GF_Read, 0, y_off + offset_y, xImageSize/nxProcs, new_y, buf, nx, ny,
// GDT_Float32, bandsInFile, NULL, bandsInFile*sizeof(float),
// bandsInFile*nx*sizeof(float), sizeof(float));
// }
// else{
// int new_x = int(round(nx*yImageSize/(double)yTotalSize));
// int x_off = int(round((xImageSize - new_x*nxProcs)/2.0));
// int offset_x = max(min(x_off,xOffset),-x_off);
// //fprintf(stderr, "xImageSize = %d, xTotalSize = %d, yImageSize = %d, yTotalSize = %d", xImageSize, xTotalSize, yImageSize, yTotalSize);
// //fprintf(stderr, "kx = %d, ky = %d, new_x = %d, ny = %d",
// //0, 0, new_x, yImageSize/nyProcs);
// dataset->RasterIO(GF_Read, x_off + offset_x, 0, new_x, yImageSize/nyProcs, buf, nx, ny,
// GDT_Float32, bandsInFile, NULL, bandsInFile*sizeof(float),
// bandsInFile*nx*sizeof(float),sizeof(float));
// }
//}
//else {
// //fprintf(stderr,"just checking");
// dataset->RasterIO(GF_Read, xOffset, yOffset, nx, ny, buf, nx, ny,
// GDT_Float32, bandsInFile, NULL, bandsInFile*sizeof(float), bandsInFile*nx*sizeof(float), sizeof(float));
//}
//GDALClose(dataset);
}
#else
fprintf(stderr, GDAL_CONFIG_ERR_STR);
exit(1);
#endif // PV_USE_GDAL
if (status == 0) {
if(!isBinary){
float fac;
if(dataType == GDT_Byte){
fac = 1.0f / 255.0f; // normalize to 1.0
}
else if(dataType == GDT_UInt16){
fac = 1.0f / 65535.0f; // normalize to 1.0
}
else{
std::cout << "Image data type " << GDALGetDataTypeName(dataType) << " not implemented for image rescaling\n";
exit(-1);
}
for( int n=0; n<numTotal; n++ ) {
buf[n] *= fac;
}
}
}
return status;
}
// Read image
bool readImageGDAL(unsigned char **pImageData, int &width, int &height, int &nChannels, const char *filePath, double trans[6])
{
GDALAllRegister();
GDALDataset *poDataset = NULL;
poDataset = (GDALDataset *) GDALOpen(filePath, GA_ReadOnly);
if(poDataset == NULL)
{
GDALClose(poDataset);
return false;
}
width = poDataset->GetRasterXSize();
height = poDataset->GetRasterYSize();
printf("width=%d\n", width);
printf("height=%d\n", height);
CPLErr aaa = poDataset->GetGeoTransform(trans);
int k = 0;
GDALRasterBand *pBand;
int i = 0;
int nRastercount = poDataset->GetRasterCount();
// one channel, the gray image
if (nRastercount == 1)
{
nChannels = 1;
pBand = poDataset->GetRasterBand(1);
*pImageData = new unsigned char[width * height];
pBand->RasterIO(GF_Read,
0, 0,
width, height,
*pImageData,
width, height,
GDT_Byte,
0,
0);
GDALClose(poDataset);
return true;
}
// three channels, and the output is RGB image
else if ( nRastercount == 3 && (nChannels == 3 || nChannels < 0) )
{
nChannels = 3;
*pImageData = new unsigned char[nRastercount * width * height];
for (i = 1; i <= nRastercount; ++ i)
{
//Band GDAL RGB is stored in order, we usually need to be converted to BGR storage, namely low address to high address: B G R
unsigned char *pImageOffset = *pImageData + i - 1;
GDALRasterBand *pBand = poDataset->GetRasterBand(nRastercount - i + 1);
pBand->RasterIO(
GF_Read,
0, 0,
width, height,
pImageOffset,
width, height,
GDT_Byte,
3,
0);
}
GDALClose(poDataset);
return true;
}
//3 channels, but the required output grayscale images
else if ( nRastercount == 3 && nChannels == 1 )
{
unsigned char **img = new unsigned char *[nRastercount];
for (i = 0; i < nRastercount; i++)
{
img[i] = new unsigned char[width * height];
}
for (i = 1; i <= nRastercount; ++ i)
{
//Band GDAL RGB is stored in order, we usually need to be converted to BGR storage, namely low address to high address: B G R
pBand = poDataset->GetRasterBand(nRastercount - i + 1);
pBand->RasterIO(GF_Read,
0, 0,
width, height,
img[i - 1],
width, height,
GDT_Byte,
0,
0);
}
GDALClose(poDataset);
*pImageData = new unsigned char[width * height];
for (int r = 0; r < height; ++ r)
{
for (int c = 0; c < width; ++ c)
{
int t = (r * width + c);
//r g b components are accounted for in turn:0.299 0.587 0.144,can be simplified as 3:6:1
//img[1.2.3]Correspond to BGR
(*pImageData)[t] = (img[2][t] * 3 + img[1][t] * 6 + img[0][t] + 5) / 10;
}
}
for (i = 0; i < nRastercount; ++ i)
{
delete [] img[i];
}
delete []img;
img = NULL;
return true;
}
else
{
return false;
}
}
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;
}
static int ProxyMain( int argc, char ** argv )
{
// GDALDatasetH hDataset, hOutDS;
// int i;
// int nRasterXSize, nRasterYSize;
// const char *pszSource=NULL, *pszDest=NULL, *pszFormat = "GTiff";
// GDALDriverH hDriver;
// int *panBandList = NULL; /* negative value of panBandList[i] means mask band of ABS(panBandList[i]) */
// int nBandCount = 0, bDefBands = TRUE;
// double adfGeoTransform[6];
// GDALDataType eOutputType = GDT_Unknown;
// int nOXSize = 0, nOYSize = 0;
// char *pszOXSize=NULL, *pszOYSize=NULL;
// char **papszCreateOptions = NULL;
// int anSrcWin[4], bStrict = FALSE;
// const char *pszProjection;
// int bScale = FALSE, bHaveScaleSrc = FALSE, bUnscale=FALSE;
// double dfScaleSrcMin=0.0, dfScaleSrcMax=255.0;
// double dfScaleDstMin=0.0, dfScaleDstMax=255.0;
// double dfULX, dfULY, dfLRX, dfLRY;
// char **papszMetadataOptions = NULL;
// char *pszOutputSRS = NULL;
// int bQuiet = FALSE, bGotBounds = FALSE;
// GDALProgressFunc pfnProgress = GDALTermProgress;
// int nGCPCount = 0;
// GDAL_GCP *pasGCPs = NULL;
// int iSrcFileArg = -1, iDstFileArg = -1;
// int bCopySubDatasets = FALSE;
// double adfULLR[4] = { 0,0,0,0 };
// int bSetNoData = FALSE;
// int bUnsetNoData = FALSE;
// double dfNoDataReal = 0.0;
// int nRGBExpand = 0;
// int bParsedMaskArgument = FALSE;
// int eMaskMode = MASK_AUTO;
// int nMaskBand = 0; /* negative value means mask band of ABS(nMaskBand) */
// int bStats = FALSE, bApproxStats = FALSE;
// GDALDatasetH hDataset, hOutDS;
GDALDataset *hDataset = NULL;
GDALDataset *hOutDS = NULL;
int i;
int nRasterXSize, nRasterYSize;
const char *pszSource=NULL, *pszDest=NULL, *pszFormat = "GTiff";
// GDALDriverH hDriver;
GDALDriver *hDriver;
GDALDataType eOutputType = GDT_Unknown;
char **papszCreateOptions = NULL;
int bStrict = FALSE;
int bQuiet = FALSE;
GDALProgressFunc pfnProgress = GDALTermProgress;
int iSrcFileArg = -1, iDstFileArg = -1;
int bSetNoData = FALSE;
int bUnsetNoData = FALSE;
double dfNoDataReal = 0.0;
GDALRasterBand *inBand = NULL;
GDALRasterBand *outBand = NULL;
GByte *srcBuffer;
double adfGeoTransform[6];
int nRasterCount;
int bReplaceIds = FALSE;
const char *pszReplaceFilename = NULL;
const char *pszReplaceFieldFrom = NULL;
const char *pszReplaceFieldTo = NULL;
std::map<GByte,GByte> mReplaceTable;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
/* Must process GDAL_SKIP before GDALAllRegister(), but we can't call */
/* GDALGeneralCmdLineProcessor before it needs the drivers to be registered */
/* for the --format or --formats options */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i],"--config") && i + 2 < argc && EQUAL(argv[i + 1], "GDAL_SKIP") )
{
CPLSetConfigOption( argv[i+1], argv[i+2] );
i += 2;
}
}
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Handle command line arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i],"-of") && i < argc-1 )
pszFormat = argv[++i];
else if( EQUAL(argv[i],"-q") || EQUAL(argv[i],"-quiet") )
{
bQuiet = TRUE;
pfnProgress = GDALDummyProgress;
}
else if( EQUAL(argv[i],"-ot") && i < argc-1 )
{
int iType;
for( iType = 1; iType < GDT_TypeCount; iType++ )
{
if( GDALGetDataTypeName((GDALDataType)iType) != NULL
&& EQUAL(GDALGetDataTypeName((GDALDataType)iType),
argv[i+1]) )
{
eOutputType = (GDALDataType) iType;
}
}
if( eOutputType == GDT_Unknown )
{
printf( "Unknown output pixel type: %s\n", argv[i+1] );
Usage();
GDALDestroyDriverManager();
exit( 2 );
}
i++;
}
else if( EQUAL(argv[i],"-not_strict") )
bStrict = FALSE;
else if( EQUAL(argv[i],"-strict") )
bStrict = TRUE;
else if( EQUAL(argv[i],"-a_nodata") && i < argc - 1 )
{
if (EQUAL(argv[i+1], "none"))
{
bUnsetNoData = TRUE;
}
else
{
bSetNoData = TRUE;
dfNoDataReal = CPLAtofM(argv[i+1]);
}
i += 1;
}
else if( EQUAL(argv[i],"-co") && i < argc-1 )
{
papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] );
}
else if( EQUAL(argv[i],"-replace_ids") && i < argc-3 )
{
bReplaceIds = TRUE;
pszReplaceFilename = (argv[++i]);
pszReplaceFieldFrom = (argv[++i]);
pszReplaceFieldTo = (argv[++i]);
}
else if( argv[i][0] == '-' )
{
printf( "Option %s incomplete, or not recognised.\n\n",
argv[i] );
Usage();
GDALDestroyDriverManager();
exit( 2 );
}
else if( pszSource == NULL )
{
iSrcFileArg = i;
pszSource = argv[i];
}
else if( pszDest == NULL )
{
pszDest = argv[i];
iDstFileArg = i;
}
else
{
printf( "Too many command options.\n\n" );
Usage();
GDALDestroyDriverManager();
exit( 2 );
}
}
if( pszDest == NULL )
{
Usage();
GDALDestroyDriverManager();
exit( 10 );
}
if ( strcmp(pszSource, pszDest) == 0)
{
fprintf(stderr, "Source and destination datasets must be different.\n");
GDALDestroyDriverManager();
exit( 1 );
}
if( bReplaceIds )
{
if ( ! pszReplaceFilename | ! pszReplaceFieldFrom | ! pszReplaceFieldTo )
Usage();
// FILE * ifile;
// if ( (ifile = fopen(pszReplaceFilename, "r")) == NULL )
// {
// fprintf( stderr, "Replace file %s cannot be read!\n\n", pszReplaceFilename );
// Usage();
// }
// else
// fclose( ifile );
mReplaceTable = InitReplaceTable(pszReplaceFilename,
pszReplaceFieldFrom,
pszReplaceFieldTo);
printf("TMP ET size: %d\n",(int)mReplaceTable.size());
}
/* -------------------------------------------------------------------- */
/* Attempt to open source file. */
/* -------------------------------------------------------------------- */
// hDataset = GDALOpenShared( pszSource, GA_ReadOnly );
hDataset = (GDALDataset *) GDALOpen(pszSource, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"GDALOpen failed - %d\n%s\n",
CPLGetLastErrorNo(), CPLGetLastErrorMsg() );
GDALDestroyDriverManager();
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Collect some information from the source file. */
/* -------------------------------------------------------------------- */
// nRasterXSize = GDALGetRasterXSize( hDataset );
// nRasterYSize = GDALGetRasterYSize( hDataset );
nRasterXSize = hDataset->GetRasterXSize();
nRasterYSize = hDataset->GetRasterYSize();
if( !bQuiet )
printf( "Input file size is %d, %d\n", nRasterXSize, nRasterYSize );
/* -------------------------------------------------------------------- */
/* Find the output driver. */
/* -------------------------------------------------------------------- */
hDriver = GetGDALDriverManager()->GetDriverByName( pszFormat );
if( hDriver == NULL )
{
int iDr;
printf( "Output driver `%s' not recognised.\n", pszFormat );
printf( "The following format drivers are configured and support output:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
GDALDriverH hDriver = GDALGetDriver(iDr);
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) != NULL
|| GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY,
NULL ) != NULL )
{
printf( " %s: %s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
}
}
printf( "\n" );
Usage();
GDALClose( (GDALDatasetH) hDataset );
GDALDestroyDriverManager();
CSLDestroy( argv );
CSLDestroy( papszCreateOptions );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Create Dataset and copy info */
/* -------------------------------------------------------------------- */
nRasterCount = hDataset->GetRasterCount();
printf("creating\n");
hOutDS = hDriver->Create( pszDest, nRasterXSize, nRasterYSize,
nRasterCount, GDT_Byte, papszCreateOptions);
printf("created\n");
if( hOutDS != NULL )
{
hDataset->GetGeoTransform( adfGeoTransform);
hOutDS->SetGeoTransform( adfGeoTransform );
hOutDS->SetProjection( hDataset->GetProjectionRef() );
/* ==================================================================== */
/* Process all bands. */
/* ==================================================================== */
// if (0)
for( i = 1; i < nRasterCount+1; i++ )
{
inBand = hDataset->GetRasterBand( i );
// hOutDS->AddBand(GDT_Byte);
outBand = hOutDS->GetRasterBand( i );
CopyBandInfo( inBand, outBand, 0, 1, 1 );
nRasterXSize = inBand->GetXSize( );
nRasterYSize = inBand->GetYSize( );
GByte old_value, new_value;
// char tmp_value[255];
// const char *tmp_value2;
std::map<GByte,GByte>::iterator it;
//tmp
int nXBlocks, nYBlocks, nXBlockSize, nYBlockSize;
int iXBlock, iYBlock;
inBand->GetBlockSize( &nXBlockSize, &nYBlockSize );
// nXBlockSize = nXBlockSize / 4;
// nYBlockSize = nYBlockSize / 4;
nXBlocks = (inBand->GetXSize() + nXBlockSize - 1) / nXBlockSize;
nYBlocks = (inBand->GetYSize() + nYBlockSize - 1) / nYBlockSize;
printf("blocks: %d %d %d %d\n",nXBlockSize,nYBlockSize,nXBlocks,nYBlocks);
printf("TMP ET creating raster %d x %d\n",nRasterXSize, nRasterYSize);
// srcBuffer = new GByte[nRasterXSize * nRasterYSize];
// printf("reading\n");
// inBand->RasterIO( GF_Read, 0, 0, nRasterXSize, nRasterYSize,
// srcBuffer, nRasterXSize, nRasterYSize, GDT_Byte,
// 0, 0 );
// srcBuffer = (GByte *) CPLMalloc(sizeof(GByte)*nRasterXSize * nRasterYSize);
srcBuffer = (GByte *) CPLMalloc(nXBlockSize * nYBlockSize);
for( iYBlock = 0; iYBlock < nYBlocks; iYBlock++ )
{
// if(iYBlock%1000 == 0)
// printf("iXBlock: %d iYBlock: %d\n",iXBlock,iYBlock);
if(iYBlock%1000 == 0)
printf("iYBlock: %d / %d\n",iYBlock,nYBlocks);
for( iXBlock = 0; iXBlock < nXBlocks; iXBlock++ )
{
int nXValid, nYValid;
// inBand->ReadBlock( iXBlock, iYBlock, srcBuffer );
inBand->RasterIO( GF_Read, iXBlock, iYBlock, nXBlockSize, nYBlockSize,
srcBuffer, nXBlockSize, nYBlockSize, GDT_Byte,
0, 0 );
// Compute the portion of the block that is valid
// for partial edge blocks.
if( (iXBlock+1) * nXBlockSize > inBand->GetXSize() )
nXValid = inBand->GetXSize() - iXBlock * nXBlockSize;
else
nXValid = nXBlockSize;
if( (iYBlock+1) * nYBlockSize > inBand->GetYSize() )
nYValid = inBand->GetYSize() - iYBlock * nYBlockSize;
else
nYValid = nYBlockSize;
// printf("iXBlock: %d iYBlock: %d read, nXValid: %d nYValid: %d\n",iXBlock,iYBlock,nXValid, nYValid);
// if(0)
if ( pszReplaceFilename )
{
for( int iY = 0; iY < nYValid; iY++ )
{
for( int iX = 0; iX < nXValid; iX++ )
{
// panHistogram[pabyData[iX + iY * nXBlockSize]] += 1;
old_value = new_value = srcBuffer[iX + iY * nXBlockSize];
// sprintf(tmp_value,"%d",old_value);
it = mReplaceTable.find(old_value);
if ( it != mReplaceTable.end() ) new_value = it->second;
if ( old_value != new_value )
{
srcBuffer[iX + iY * nXBlockSize] = new_value;
// printf("old_value %d new_value %d final %d\n",old_value,new_value, srcBuffer[iX + iY * nXBlockSize]);
}
// tmp_value2 = CSVGetField( pszReplaceFilename,pszReplaceFieldFrom,
// tmp_value, CC_Integer, pszReplaceFieldTo);
// if( tmp_value2 != NULL )
// {
// new_value = atoi(tmp_value2);
// }
// new_value = old_value +1;
//
}
}
}
// printf("writing\n");
// outBand->WriteBlock( iXBlock, iYBlock, srcBuffer );
outBand->RasterIO( GF_Write, iXBlock, iYBlock, nXBlockSize, nYBlockSize,
srcBuffer, nXBlockSize, nYBlockSize, GDT_Byte,
0, 0 );
// printf("wrote\n");
}
}
CPLFree(srcBuffer);
printf("read\n");
printf("mod\n");
// if ( pszReplaceFilename )
// {
// GByte old_value, new_value;
// // char tmp_value[255];
// // const char *tmp_value2;
// std::map<GByte,GByte>::iterator it;
// for ( int j=0; j<nRasterXSize*nRasterYSize; j++ )
// {
// old_value = new_value = srcBuffer[j];
// // sprintf(tmp_value,"%d",old_value);
// it = mReplaceTable.find(old_value);
// if ( it != mReplaceTable.end() ) new_value = it->second;
// // tmp_value2 = CSVGetField( pszReplaceFilename,pszReplaceFieldFrom,
// // tmp_value, CC_Integer, pszReplaceFieldTo);
// // if( tmp_value2 != NULL )
// // {
// // new_value = atoi(tmp_value2);
// // }
// // new_value = old_value +1;
// if ( old_value != new_value ) srcBuffer[j] = new_value;
// // printf("old_value %d new_value %d final %d\n",old_value,new_value, srcBuffer[j]);
// }
// printf("writing\n");
// outBand->RasterIO( GF_Write, 0, 0, nRasterXSize, nRasterYSize,
// srcBuffer, nRasterXSize, nRasterYSize, GDT_Byte,
// 0, 0 );
// printf("wrote\n");
// delete [] srcBuffer;
// }
}
}
if( hOutDS != NULL )
GDALClose( (GDALDatasetH) hOutDS );
if( hDataset != NULL )
GDALClose( (GDALDatasetH) hDataset );
GDALDumpOpenDatasets( stderr );
// GDALDestroyDriverManager();
CSLDestroy( argv );
CSLDestroy( papszCreateOptions );
return hOutDS == NULL;
}
