void bin2ascii(char *binFile, char *asciiFile){
GDALDataset *layer;
GDALAllRegister();
layer = (GDALDataset *)GDALOpen(binFile, GA_ReadOnly);
int bandNumber = 1;
GDALRasterBand *band = layer->GetRasterBand(bandNumber);
GDALDataType type = band->GetRasterDataType();
double ranges[6];
layer->GetGeoTransform(ranges);
ofstream outFile;
outFile.open(asciiFile);
outFile<<"ncols "<<layer->GetRasterXSize()<<"\n";
outFile<<"nrows "<<layer->GetRasterYSize()<<"\n";
outFile<<"xllcorner "<<ranges[0]<<"\n";
outFile<<"yllcorner "<<(ranges[3] + layer->GetRasterXSize() * ranges[4] + layer->GetRasterYSize() * ranges[5])<<"\n";
outFile<<"cellsize " <<ranges[1]<<"\n";
outFile<<"nodata_value "<<"-9999"<<"\n";
//getchar(); getchar();
int cols = layer->GetRasterXSize();
int rows = layer->GetRasterYSize();
double NODATA_VAL = band->GetNoDataValue();
cout<<"NODATA_VALUE= "<<NODATA_VAL<<"\n";
int size = GDALGetDataTypeSize(type) / 8;
void *data = CPLMalloc(size);
//CPLErr err = band->RasterIO(GF_Read, 0, 0, cols, rows, data, cols, rows, type, 0, 0);
//getchar(); getchar();
//for(int j=0; j<rows*cols; j++){
//int col, row;
for(int row=0; row<rows; row++){
for(int col=0; col<cols; col++){
CPLErr err = band->RasterIO(GF_Read, col, row, 1, 1, data, 1, 1, type, 0, 0);
double tempVal = readValueB2A(data, type, 0);
outFile<<( tempVal != NODATA_VAL ? tempVal : -9999)<<" ";
//if((j+1)%cols == 0){
// cout<<"\n";
//getchar(); getchar();
// }
}
outFile<<"\n";
//getchar();
}
cout<<"Bin2Ascii.. Done!\n";
outFile.close();
//getchar(); getchar();
}
SEXP
RGDAL_GetGeoTransform(SEXP sxpDataset) {
GDALDataset *pDataset = getGDALDatasetPtr(sxpDataset);
SEXP sxpGeoTrans = allocVector(REALSXP, 6);
SEXP ceFail = NEW_LOGICAL(1);
LOGICAL_POINTER(ceFail)[0] = FALSE;
installErrorHandler();
CPLErr err = pDataset->GetGeoTransform(REAL(sxpGeoTrans));
if (err == CE_Failure) {
REAL(sxpGeoTrans)[0] = 0; // x-origin ul
REAL(sxpGeoTrans)[1] = 1; // x-resolution (pixel width)
REAL(sxpGeoTrans)[2] = 0; // x-oblique
REAL(sxpGeoTrans)[3] = (double) pDataset->GetRasterYSize();
// y-origin ul; 091028
REAL(sxpGeoTrans)[4] = 0; // y-oblique
REAL(sxpGeoTrans)[5] = -1; // y-resolution (pixel height); 091028 added sign
LOGICAL_POINTER(ceFail)[0] = TRUE;
}
setAttrib(sxpGeoTrans, install("CE_Failure"), ceFail);
uninstallErrorHandlerAndTriggerError();
return(sxpGeoTrans);
}
void read_dem_header ( image<short> & dem )
{
char file[1000];
GDALDataset *df;
GDALRasterBand *bd;
double trans[6];
int rows, cols;
strcpy ( file, p.value("dem_file").c_str());
if ( strlen(file) == 0 ) {
fprintf(stderr,"Need to specify a dem file\n");
exit(1);
}
df = (GDALDataset *) GDALOpen( file, GA_ReadOnly );
if( df == NULL ) {
fprintf(stderr,"Could not open dem file: %s\n", file );
exit(1);
}
rows = df->GetRasterYSize();
cols = df->GetRasterXSize();
dem.create(rows,cols);
if( df->GetGeoTransform( trans ) == CE_None ) {
dem_east = trans[0];
dem_north = trans[3];
dem_wid = trans[1];
} else {
fprintf(stderr,"Dem file: %s has no geographic metadata\n", file );
exit(1);
}
delete df;
}
void SmallpatchSieveFilter::SieveFilter(const char* Src_path, const char* Dst_Path, int SizeThresthod, int Connectedness)
{
GDALAllRegister();
CPLSetConfigOption("GDAL_FILENAME_IS_UTF8","NO");
GDALDriver* poDriver = GetGDALDriverManager()->GetDriverByName("GTIFF");
if (poDriver == NULL)
{
cout << "不能创建指定类型的文件：" << endl;
}
GDALDataset* poSrc = (GDALDataset*)GDALOpen(Src_path,GA_ReadOnly);
int NewBandXsize = poSrc->GetRasterXSize();
int NewBandYsize = poSrc->GetRasterYSize();
GDALDataType Type = poSrc->GetRasterBand(1)->GetRasterDataType();
GDALDataset* poDstDS = poDriver->Create(Dst_Path, NewBandXsize, NewBandYsize, 1, Type, NULL);
double GeoTrans[6] = { 0 };
poSrc->GetGeoTransform(GeoTrans);
poDstDS->SetGeoTransform(GeoTrans);
poDstDS->SetProjection(poSrc->GetProjectionRef());
GDALRasterBandH HImgBand = (GDALRasterBandH)poSrc->GetRasterBand(1);
GDALRasterBandH HPDstDSBand = (GDALRasterBandH)poDstDS->GetRasterBand(1);
GDALSetRasterColorTable(HPDstDSBand, GDALGetRasterColorTable(HImgBand));
GDALSieveFilter(HImgBand, NULL, HPDstDSBand, SizeThresthod, Connectedness, NULL, NULL, NULL);
GDALClose((GDALDatasetH)poDstDS);
};
CPLErr GDALOverviewDataset::GetGeoTransform( double * padfTransform )
{
double adfGeoTransform[6];
if( poMainDS->GetGeoTransform(adfGeoTransform) == CE_None )
{
if( adfGeoTransform[2] == 0.0 && adfGeoTransform[4] == 0.0 )
{
adfGeoTransform[1] *= (double)poMainDS->GetRasterXSize() / nRasterXSize;
adfGeoTransform[5] *= (double)poMainDS->GetRasterYSize() / nRasterYSize;
}
else
{
/* If the x and y ratios are not equal, then we cannot really */
/* compute a geotransform */
double dfRatio = (double)poMainDS->GetRasterXSize() / nRasterXSize;
adfGeoTransform[1] *= dfRatio;
adfGeoTransform[2] *= dfRatio;
adfGeoTransform[4] *= dfRatio;
adfGeoTransform[5] *= dfRatio;
}
memcpy( padfTransform, adfGeoTransform, sizeof(double)*6 );
return CE_None;
}
else
return CE_Failure;
}
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;
}
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;
}
/*! \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;
}
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_GetRasterYSize(SEXP sDataset) {
GDALDataset *pDataset = getGDALDatasetPtr(sDataset);
return(ScalarInteger(pDataset->GetRasterYSize()));
}
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;
}
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;
}
}
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_GetRasterYSize(SEXP sDataset) {
GDALDataset *pDataset = getGDALDatasetPtr(sDataset);
int res;
installErrorHandler();
res = pDataset->GetRasterYSize();
uninstallErrorHandlerAndTriggerError();
return(ScalarInteger(res));
}
/**
* Set location of the station based on latitude and longitude. Datum
* transformation info may need to occur
* @param Lat latitude of the station
* @param Lon longitude of the station
* @param demFile file name of the input dem, for coord tranformation
* @param datum datum to convert to.
*/
void wxStation::set_location_LatLong( double Lat, double Lon,
const std::string demFile,
const char *datum )
{
lon = Lon;
lat = Lat;
if( demFile.empty() || demFile == "" )
return;
GDALDataset *poDS = (GDALDataset*)GDALOpen( demFile.c_str(), GA_ReadOnly );
if( poDS == NULL )
return;
double projX = lon;
double projY = lat;
GDALPointFromLatLon( projX, projY, poDS, datum );
projXord = projX;
projYord = projY;
//still assume dem is projected.
double llx = 0.0;
double lly = 0.0;
double adfGeoTransform[6];
if( poDS->GetGeoTransform( adfGeoTransform ) != CE_None )
{
xord = projXord;
yord = projYord;
return;
}
llx = adfGeoTransform[0];
lly = adfGeoTransform[3] + ( adfGeoTransform[5] * poDS->GetRasterYSize() );
xord = projXord - llx;
yord = projYord - lly;
if( EQUAL( datum, "WGS84" ) )
datumType = WGS84;
else if( EQUAL( datum, "NAD83" ) )
datumType = NAD83;
else if ( EQUAL( datum, "NAD27" ) )
datumType = NAD27;
coordType = GEOGCS;
GDALClose( (GDALDatasetH)poDS );
}
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;
}
gdal_datasource::gdal_datasource(parameters const& params)
: datasource(params),
desc_(*params.get<std::string>("type"),"utf-8")
{
#ifdef MAPNIK_DEBUG
std::clog << "\nGDAL Plugin: Initializing...\n";
#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>("shared",false);
band_ = *params_.get<int>("band", -1);
GDALDataset *dataset = open_dataset();
// TODO: Make more class attributes from geotransform...
width_ = dataset->GetRasterXSize();
height_ = dataset->GetRasterYSize();
double tr[6];
dataset->GetGeoTransform(tr);
double dx = tr[1];
double dy = tr[5];
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;
extent_.init(x0,y0,x1,y1);
GDALClose(dataset);
#ifdef MAPNIK_DEBUG
std::clog << "GDAL Plugin: Raster Size=" << width_ << "," << height_ << "\n";
std::clog << "GDAL Plugin: Raster Extent=" << extent_ << "\n";
#endif
}
/**
* Set the location of the station in lat/lon based on projected coordinates
* @param Xord x coordinate in system
* @param Yord y coordinate in system
* @param demFile name of the dem file to create the coordinate transformation
* from
*/
void wxStation::set_location_projected( double Xord, double Yord,
std::string demFile )
{
projXord = Xord;
projYord = Yord;
if( demFile.empty() || demFile == "" )
return;
//get llcorner to subtract
GDALDataset *poDS = (GDALDataset*) GDALOpen( demFile.c_str(), GA_ReadOnly );
if( poDS == NULL ){
xord = Xord;
yord = Yord;
return;
}
double adfGeoTransform[6];
if( poDS->GetGeoTransform( adfGeoTransform ) != CE_None ) {
xord = Xord;
yord = Yord;
return;
}
double llx = 0.0;
double lly = 0.0;
llx = adfGeoTransform[0];
lly = adfGeoTransform[3] + ( adfGeoTransform[5] * poDS->GetRasterYSize() );
xord = Xord - llx;
yord = Yord - lly;
double lonx = projXord;
double laty = projYord;
GDALPointToLatLon( lonx, laty, poDS, "WGS84" );
datumType = WGS84;
coordType = PROJCS;
lon = lonx;
lat = laty;
GDALClose( (GDALDatasetH)poDS );
}
const GDAL_GCP *GDALOverviewDataset::GetGCPs()
{
if( pasGCPList != NULL )
return pasGCPList;
const GDAL_GCP* pasGCPsMain = poMainDS->GetGCPs();
if( pasGCPsMain == NULL )
return NULL;
nGCPCount = poMainDS->GetGCPCount();
pasGCPList = GDALDuplicateGCPs( nGCPCount, pasGCPsMain );
for(int i = 0; i < nGCPCount; i++)
{
pasGCPList[i].dfGCPPixel *= (double)nRasterXSize / poMainDS->GetRasterXSize();
pasGCPList[i].dfGCPLine *= (double)nRasterYSize / poMainDS->GetRasterYSize();
}
return pasGCPList;
}
bool ImageTIF::OpenImage(std::string filename)
{
GDALDataset *poDataset;
GDALAllRegister();
poDataset = (GDALDataset *) GDALOpen( filename.c_str(), GA_ReadOnly );
///On initialise toutes les caractèristiques à l'aide des données de l'image Geotif.
_ySize = poDataset->GetRasterYSize();
_xSize = poDataset->GetRasterXSize();
_bandCount = 12;
GDALRasterBand *bands;
_data.resize(_ySize*_xSize*(_bandCount));
if( poDataset != NULL )
{
/// Pour chaque bande on lit une ligne, puis on parcourt les colonnes
for (unsigned int b = 1; b <= _bandCount+1; ++b )
{
bands = poDataset->GetRasterBand(b);
// iterate over image row by row
for (unsigned int row = 0; row < _ySize; ++row )
{
float *scanline;
scanline = (float *) CPLMalloc( sizeof( float ) * _xSize );
bands->RasterIO( GF_Read, 0, row, _xSize, 1, scanline, _xSize,
1, GDT_Float32, 0, 0 );
for (unsigned int col = 0; col < _xSize; ++col)
{
// get value in (row, col) from band r
if(b<11)
{
_data[b-1+_bandCount*row+col*_bandCount*_ySize] = scanline[col];
}
else if(b>11)
{
_data[b-2+_bandCount*row+col*_bandCount*_ySize] = scanline[col];
}
}
}
}
GDALClose(poDataset);
return true;
}
return false;
}
const QString OmgGdal::getAsciiHeader(const QString theFileName)
{
GDALAllRegister();
GDALDataset *gdalDataset = (GDALDataset *) GDALOpen( theFileName.local8Bit(), GA_ReadOnly );
if ( gdalDataset == NULL )
{
return QString("");
}
//get dimensions and no data value
int myColsInt = gdalDataset->GetRasterXSize();
int myRowsInt = gdalDataset->GetRasterYSize();
double myNullValue=gdalDataset->GetRasterBand(1)->GetNoDataValue();
//get the geotransform stuff from gdal
double myTransform[6];
if (gdalDataset->GetGeoTransform(myTransform) != CE_None)
{
std::cout << "Failed to get geo transform from GDAL, aborting" << std::endl;
GDALClose(gdalDataset);
return QString("");
}
else
{
GDALClose(gdalDataset);
}
QString myHeader;
myHeader = "NCOLS " + QString::number(myColsInt) + "\r\n";
myHeader += "NROWS " + QString::number(myRowsInt) + "\r\n";
myHeader += "XLLCORNER " + QString::number(myTransform[0]) + "\r\n";;
//negative y is bodged for now
myHeader += "YLLCORNER -" + QString::number(myTransform[3]) + "\r\n";
myHeader += "CELLSIZE " + QString::number(myTransform[1]) + "\r\n";
myHeader += "NODATA_VALUE " + QString::number(myNullValue) + "\r\n";
return myHeader;
}
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;
}
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;
}
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 );
}
}
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_;
}
//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;
}
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;
}
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;
}