GDALDatasetH QgsNineCellFilter::openOutputFile( GDALDatasetH inputDataset, GDALDriverH outputDriver )
{
if ( inputDataset == NULL )
{
return NULL;
}
int xSize = GDALGetRasterXSize( inputDataset );
int ySize = GDALGetRasterYSize( inputDataset );;
//open output file
char **papszOptions = NULL;
GDALDatasetH outputDataset = GDALCreate( outputDriver, mOutputFile.toLocal8Bit().data(), xSize, ySize, 1, GDT_Float32, papszOptions );
if ( outputDataset == NULL )
{
return outputDataset;
}
//get geotransform from inputDataset
double geotransform[6];
if ( GDALGetGeoTransform( inputDataset, geotransform ) != CE_None )
{
GDALClose( outputDataset );
return NULL;
}
GDALSetGeoTransform( outputDataset, geotransform );
//make sure mCellSizeX and mCellSizeY are always > 0
mCellSizeX = geotransform[1];
if ( mCellSizeX < 0 )
{
mCellSizeX = -mCellSizeX;
}
mCellSizeY = geotransform[5];
if ( mCellSizeY < 0 )
{
mCellSizeY = -mCellSizeY;
}
const char* projection = GDALGetProjectionRef( inputDataset );
GDALSetProjection( outputDataset, projection );
return outputDataset;
}
QgsAlignRaster::RasterInfo::RasterInfo( const QString& layerpath )
: mXSize( 0 )
, mYSize( 0 )
, mBandCnt( 0 )
{
mDataset = GDALOpen( layerpath.toLocal8Bit().constData(), GA_ReadOnly );
if ( !mDataset )
return;
mXSize = GDALGetRasterXSize( mDataset );
mYSize = GDALGetRasterYSize( mDataset );
( void ) GDALGetGeoTransform( mDataset, mGeoTransform );
// TODO: may be null or empty string
mCrsWkt = QString::fromAscii( GDALGetProjectionRef( mDataset ) );
mBandCnt = GDALGetBandNumber( mDataset );
}
static dErr JakoFileDataView(GDALDatasetH filedata,const char *name,PetscViewer viewer)
{
dErr err;
CPLErr cplerr;
double geo[6],data[8*12];
int nx=8,ny=12,snx,sny;
GDALRasterBandH band;
dFunctionBegin;
cplerr = GDALGetGeoTransform(filedata,geo);
err = dRealTableView(2,3,geo,PETSC_VIEWER_STDOUT_WORLD,"%s:geo",name);dCHK(err);
snx = GDALGetRasterXSize(filedata);
sny = GDALGetRasterYSize(filedata);
err = PetscViewerASCIIPrintf(viewer,"%s: nx=%d ny=%d\n",name,snx,sny);dCHK(err);
band = GDALGetRasterBand(filedata,1);
cplerr = GDALRasterIO(band,GF_Read,snx/2,sny/2,nx,ny,data,nx,ny,GDT_Float64,0,0);dCPLCHK(cplerr);
err = dRealTableView(ny,nx,data,PETSC_VIEWER_STDOUT_WORLD,name);dCHK(err);
dFunctionReturn(0);
}
void QgsRasterChangeCoords::setRaster( const QString &fileRaster )
{
GDALAllRegister();
GDALDatasetH hDS = GDALOpen( fileRaster.toUtf8().constData(), GA_ReadOnly );
double adfGeoTransform[6];
if ( GDALGetProjectionRef( hDS ) && GDALGetGeoTransform( hDS, adfGeoTransform ) == CE_None )
//if ( false )
{
mHasCrs = true;
mUL_X = adfGeoTransform[0];
mUL_Y = adfGeoTransform[3];
mResX = adfGeoTransform[1];
mResY = adfGeoTransform[5];
}
else
{
mHasCrs = false;
}
GDALClose( hDS );
}
int msUVRASTERLayerGetExtent(layerObj *layer, rectObj *extent)
{
char szPath[MS_MAXPATHLEN];
mapObj *map = layer->map;
double adfGeoTransform[6];
int nXSize, nYSize;
GDALDatasetH hDS;
shapefileObj *tileshpfile;
int tilelayerindex = -1;
CPLErr eErr = CE_Failure;
char *decrypted_path;
if( (!layer->data || strlen(layer->data) == 0)
&& layer->tileindex == NULL) {
/* should we be issuing a specific error about not supporting
extents for tileindexed raster layers? */
return MS_FAILURE;
}
if( map == NULL )
return MS_FAILURE;
/* If the layer use a tileindex, return the extent of the tileindex shapefile/referenced layer */
if (layer->tileindex) {
tilelayerindex = msGetLayerIndex(map, layer->tileindex);
if(tilelayerindex != -1) /* does the tileindex reference another layer */
return msLayerGetExtent(GET_LAYER(map, tilelayerindex), extent);
else {
tileshpfile = (shapefileObj *) malloc(sizeof(shapefileObj));
MS_CHECK_ALLOC(tileshpfile, sizeof(shapefileObj), MS_FAILURE);
if(msShapefileOpen(tileshpfile, "rb", msBuildPath3(szPath, map->mappath, map->shapepath, layer->tileindex), MS_TRUE) == -1)
if(msShapefileOpen(tileshpfile, "rb", msBuildPath(szPath, map->mappath, layer->tileindex), MS_TRUE) == -1)
return MS_FAILURE;
*extent = tileshpfile->bounds;
msShapefileClose(tileshpfile);
free(tileshpfile);
return MS_SUCCESS;
}
}
msTryBuildPath3(szPath, map->mappath, map->shapepath, layer->data);
decrypted_path = msDecryptStringTokens( map, szPath );
msAcquireLock( TLOCK_GDAL );
if( decrypted_path ) {
hDS = GDALOpen(decrypted_path, GA_ReadOnly );
msFree( decrypted_path );
} else
hDS = NULL;
if( hDS != NULL ) {
nXSize = GDALGetRasterXSize( hDS );
nYSize = GDALGetRasterYSize( hDS );
eErr = GDALGetGeoTransform( hDS, adfGeoTransform );
GDALClose( hDS );
}
msReleaseLock( TLOCK_GDAL );
if( hDS == NULL || eErr != CE_None ) {
return MS_FAILURE;
}
/* If this appears to be an ungeoreferenced raster than flip it for
mapservers purposes. */
if( adfGeoTransform[5] == 1.0 && adfGeoTransform[3] == 0.0 ) {
adfGeoTransform[5] = -1.0;
adfGeoTransform[3] = nYSize;
}
extent->minx = adfGeoTransform[0];
extent->maxy = adfGeoTransform[3];
extent->maxx = adfGeoTransform[0] + nXSize * adfGeoTransform[1];
extent->miny = adfGeoTransform[3] + nYSize * adfGeoTransform[5];
return MS_SUCCESS;
}
CPLErr CPL_STDCALL
GDALFPolygonize( GDALRasterBandH hSrcBand,
GDALRasterBandH hMaskBand,
OGRLayerH hOutLayer, int iPixValField,
char **papszOptions,
GDALProgressFunc pfnProgress,
void * pProgressArg )
{
#ifndef OGR_ENABLED
CPLError(CE_Failure, CPLE_NotSupported, "GDALFPolygonize() unimplemented in a non OGR build");
return CE_Failure;
#else
VALIDATE_POINTER1( hSrcBand, "GDALFPolygonize", CE_Failure );
VALIDATE_POINTER1( hOutLayer, "GDALFPolygonize", CE_Failure );
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
int nConnectedness = CSLFetchNameValue( papszOptions, "8CONNECTED" ) ? 8 : 4;
/* -------------------------------------------------------------------- */
/* Confirm our output layer will support feature creation. */
/* -------------------------------------------------------------------- */
if( !OGR_L_TestCapability( hOutLayer, OLCSequentialWrite ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Output feature layer does not appear to support creation\n"
"of features in GDALFPolygonize()." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Allocate working buffers. */
/* -------------------------------------------------------------------- */
CPLErr eErr = CE_None;
int nXSize = GDALGetRasterBandXSize( hSrcBand );
int nYSize = GDALGetRasterBandYSize( hSrcBand );
float *pafLastLineVal = (float *) VSIMalloc2(sizeof(float),nXSize + 2);
float *pafThisLineVal = (float *) VSIMalloc2(sizeof(float),nXSize + 2);
GInt32 *panLastLineId = (GInt32 *) VSIMalloc2(sizeof(GInt32),nXSize + 2);
GInt32 *panThisLineId = (GInt32 *) VSIMalloc2(sizeof(GInt32),nXSize + 2);
GByte *pabyMaskLine = (hMaskBand != NULL) ? (GByte *) VSIMalloc(nXSize) : NULL;
if (pafLastLineVal == NULL || pafThisLineVal == NULL ||
panLastLineId == NULL || panThisLineId == NULL ||
(hMaskBand != NULL && pabyMaskLine == NULL))
{
CPLError(CE_Failure, CPLE_OutOfMemory,
"Could not allocate enough memory for temporary buffers");
CPLFree( panThisLineId );
CPLFree( panLastLineId );
CPLFree( pafThisLineVal );
CPLFree( pafLastLineVal );
CPLFree( pabyMaskLine );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Get the geotransform, if there is one, so we can convert the */
/* vectors into georeferenced coordinates. */
/* -------------------------------------------------------------------- */
GDALDatasetH hSrcDS = GDALGetBandDataset( hSrcBand );
double adfGeoTransform[6] = { 0.0, 1.0, 0.0, 0.0, 0.0, 1.0 };
if( hSrcDS )
GDALGetGeoTransform( hSrcDS, adfGeoTransform );
/* -------------------------------------------------------------------- */
/* The first pass over the raster is only used to build up the */
/* polygon id map so we will know in advance what polygons are */
/* what on the second pass. */
/* -------------------------------------------------------------------- */
int iY;
GDALRasterFPolygonEnumerator oFirstEnum(nConnectedness);
for( iY = 0; eErr == CE_None && iY < nYSize; iY++ )
{
eErr = GDALRasterIO(
hSrcBand,
GF_Read, 0, iY, nXSize, 1,
pafThisLineVal, nXSize, 1, GDT_Float32, 0, 0 );
if( eErr == CE_None && hMaskBand != NULL )
eErr = GPMaskImageData( hMaskBand, pabyMaskLine, iY, nXSize,
pafThisLineVal );
if( iY == 0 )
oFirstEnum.ProcessLine(
NULL, pafThisLineVal, NULL, panThisLineId, nXSize );
else
oFirstEnum.ProcessLine(
pafLastLineVal, pafThisLineVal,
panLastLineId, panThisLineId,
nXSize );
// swap lines
float * pafTmp = pafLastLineVal;
pafLastLineVal = pafThisLineVal;
pafThisLineVal = pafTmp;
GInt32 * panTmp = panThisLineId;
panThisLineId = panLastLineId;
panLastLineId = panTmp;
/* -------------------------------------------------------------------- */
/* Report progress, and support interrupts. */
/* -------------------------------------------------------------------- */
if( eErr == CE_None
&& !pfnProgress( 0.10 * ((iY+1) / (double) nYSize),
"", pProgressArg ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
eErr = CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Make a pass through the maps, ensuring every polygon id */
/* points to the final id it should use, not an intermediate */
/* value. */
/* -------------------------------------------------------------------- */
oFirstEnum.CompleteMerges();
/* -------------------------------------------------------------------- */
/* Initialize ids to -1 to serve as a nodata value for the */
/* previous line, and past the beginning and end of the */
/* scanlines. */
/* -------------------------------------------------------------------- */
int iX;
panThisLineId[0] = -1;
panThisLineId[nXSize+1] = -1;
for( iX = 0; iX < nXSize+2; iX++ )
panLastLineId[iX] = -1;
/* -------------------------------------------------------------------- */
/* We will use a new enumerator for the second pass primariliy */
/* so we can preserve the first pass map. */
/* -------------------------------------------------------------------- */
GDALRasterFPolygonEnumerator oSecondEnum(nConnectedness);
RPolygonF **papoPoly = (RPolygonF **)
CPLCalloc(sizeof(RPolygonF*),oFirstEnum.nNextPolygonId);
/* ==================================================================== */
/* Second pass during which we will actually collect polygon */
/* edges as geometries. */
/* ==================================================================== */
for( iY = 0; eErr == CE_None && iY < nYSize+1; iY++ )
{
/* -------------------------------------------------------------------- */
/* Read the image data. */
/* -------------------------------------------------------------------- */
if( iY < nYSize )
{
eErr = GDALRasterIO( hSrcBand, GF_Read, 0, iY, nXSize, 1,
pafThisLineVal, nXSize, 1, GDT_Float32, 0, 0 );
if( eErr == CE_None && hMaskBand != NULL )
eErr = GPMaskImageData( hMaskBand, pabyMaskLine, iY, nXSize,
pafThisLineVal );
}
if( eErr != CE_None )
continue;
/* -------------------------------------------------------------------- */
/* Determine what polygon the various pixels belong to (redoing */
/* the same thing done in the first pass above). */
/* -------------------------------------------------------------------- */
if( iY == nYSize )
{
for( iX = 0; iX < nXSize+2; iX++ )
panThisLineId[iX] = -1;
}
else if( iY == 0 )
oSecondEnum.ProcessLine(
NULL, pafThisLineVal, NULL, panThisLineId+1, nXSize );
else
oSecondEnum.ProcessLine(
pafLastLineVal, pafThisLineVal,
panLastLineId+1, panThisLineId+1,
nXSize );
/* -------------------------------------------------------------------- */
/* Add polygon edges to our polygon list for the pixel */
/* boundaries within and above this line. */
/* -------------------------------------------------------------------- */
for( iX = 0; iX < nXSize+1; iX++ )
{
AddEdges( panThisLineId, panLastLineId,
oFirstEnum.panPolyIdMap, oFirstEnum.pafPolyValue,
papoPoly, iX, iY );
}
/* -------------------------------------------------------------------- */
/* Periodically we scan out polygons and write out those that */
/* haven't been added to on the last line as we can be sure */
/* they are complete. */
/* -------------------------------------------------------------------- */
if( iY % 8 == 7 )
{
for( iX = 0;
eErr == CE_None && iX < oSecondEnum.nNextPolygonId;
iX++ )
{
if( papoPoly[iX] && papoPoly[iX]->nLastLineUpdated < iY-1 )
{
if( hMaskBand == NULL
|| !GDALFloatEquals(papoPoly[iX]->fPolyValue, GP_NODATA_MARKER) )
{
eErr =
EmitPolygonToLayer( hOutLayer, iPixValField,
papoPoly[iX], adfGeoTransform );
}
delete papoPoly[iX];
papoPoly[iX] = NULL;
}
}
}
/* -------------------------------------------------------------------- */
/* Swap pixel value, and polygon id lines to be ready for the */
/* next line. */
/* -------------------------------------------------------------------- */
float *pafTmp = pafLastLineVal;
pafLastLineVal = pafThisLineVal;
pafThisLineVal = pafTmp;
GInt32 *panTmp = panThisLineId;
panThisLineId = panLastLineId;
panLastLineId = panTmp;
/* -------------------------------------------------------------------- */
/* Report progress, and support interrupts. */
/* -------------------------------------------------------------------- */
if( eErr == CE_None
&& !pfnProgress( 0.10 + 0.90 * ((iY+1) / (double) nYSize),
"", pProgressArg ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
eErr = CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Make a cleanup pass for all unflushed polygons. */
/* -------------------------------------------------------------------- */
for( iX = 0; eErr == CE_None && iX < oSecondEnum.nNextPolygonId; iX++ )
{
if( papoPoly[iX] )
{
if( hMaskBand == NULL
|| !GDALFloatEquals(papoPoly[iX]->fPolyValue, GP_NODATA_MARKER) )
{
eErr =
EmitPolygonToLayer( hOutLayer, iPixValField,
papoPoly[iX], adfGeoTransform );
}
delete papoPoly[iX];
papoPoly[iX] = NULL;
}
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
CPLFree( panThisLineId );
CPLFree( panLastLineId );
CPLFree( pafThisLineVal );
CPLFree( pafLastLineVal );
CPLFree( pabyMaskLine );
CPLFree( papoPoly );
return eErr;
#endif // OGR_ENABLED
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset;
GDALRasterBandH hBand;
int i, iBand;
double adfGeoTransform[6];
GDALDriverH hDriver;
char **papszMetadata;
int bComputeMinMax = FALSE;
if( !GDALBridgeInitialize( "..", stderr ) )
{
fprintf( stderr, "Unable to intiailize GDAL bridge.\n" );
exit( 10 );
}
if( argc > 1 && strcmp(argv[1],"-mm") == 0 )
{
bComputeMinMax = TRUE;
argv++;
}
GDALAllRegister();
hDataset = GDALOpen( argv[1], GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"GDALOpen failed - %d\n%s\n",
CPLGetLastErrorNo(), CPLGetLastErrorMsg() );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Report general info. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDatasetDriver( hDataset );
printf( "Driver: %s/%s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
printf( "Size is %d, %d\n",
GDALGetRasterXSize( hDataset ),
GDALGetRasterYSize( hDataset ) );
/* -------------------------------------------------------------------- */
/* Report projection. */
/* -------------------------------------------------------------------- */
if( GDALGetProjectionRef( hDataset ) != NULL )
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetProjectionRef( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "Coordinate System is:\n%s\n", pszPrettyWkt );
}
else
printf( "Coordinate System is `%s'\n",
GDALGetProjectionRef( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
/* -------------------------------------------------------------------- */
/* Report Geotransform. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
printf( "Origin = (%.6f,%.6f)\n",
adfGeoTransform[0], adfGeoTransform[3] );
printf( "Pixel Size = (%.6f,%.6f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
}
/* -------------------------------------------------------------------- */
/* Report GCPs. */
/* -------------------------------------------------------------------- */
if( GDALGetGCPCount( hDataset ) > 0 )
{
printf( "GCP Projection = %s\n", GDALGetGCPProjection(hDataset) );
for( i = 0; i < GDALGetGCPCount(hDataset); i++ )
{
const GDAL_GCP *psGCP;
psGCP = GDALGetGCPs( hDataset ) + i;
printf( "GCP[%3d]: Id=%s, Info=%s\n"
" (%g,%g) -> (%g,%g,%g)\n",
i, psGCP->pszId, psGCP->pszInfo,
psGCP->dfGCPPixel, psGCP->dfGCPLine,
psGCP->dfGCPX, psGCP->dfGCPY, psGCP->dfGCPZ );
}
}
/* -------------------------------------------------------------------- */
/* Report metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, NULL );
if( papszMetadata != NULL )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report subdatasets. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, "SUBDATASETS" );
if( papszMetadata != NULL )
{
printf( "Subdatasets:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report corners. */
/* -------------------------------------------------------------------- */
printf( "Corner Coordinates:\n" );
GDALInfoReportCorner( hDataset, "Upper Left",
0.0, 0.0 );
GDALInfoReportCorner( hDataset, "Lower Left",
0.0, GDALGetRasterYSize(hDataset));
GDALInfoReportCorner( hDataset, "Upper Right",
GDALGetRasterXSize(hDataset), 0.0 );
GDALInfoReportCorner( hDataset, "Lower Right",
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
GDALInfoReportCorner( hDataset, "Center",
GDALGetRasterXSize(hDataset)/2.0,
GDALGetRasterYSize(hDataset)/2.0 );
/* ==================================================================== */
/* Loop over bands. */
/* ==================================================================== */
for( iBand = 0; iBand < GDALGetRasterCount( hDataset ); iBand++ )
{
double dfMin, dfMax, adfCMinMax[2], dfNoData;
int bGotMin, bGotMax, bGotNodata;
int nBlockXSize, nBlockYSize;
hBand = GDALGetRasterBand( hDataset, iBand+1 );
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
printf( "Band %d Block=%dx%d Type=%d, ColorInterp=%d\n", iBand+1,
nBlockXSize, nBlockYSize,
GDALGetRasterDataType(hBand),
GDALGetRasterColorInterpretation(hBand) );
dfMin = GDALGetRasterMinimum( hBand, &bGotMin );
dfMax = GDALGetRasterMaximum( hBand, &bGotMax );
printf( " Min=%.3f/%d, Max=%.3f/%d", dfMin, bGotMin, dfMax, bGotMax);
if( bComputeMinMax )
{
GDALComputeRasterMinMax( hBand, TRUE, adfCMinMax );
printf( ", Computed Min/Max=%.3f,%.3f",
adfCMinMax[0], adfCMinMax[1] );
}
printf( "\n" );
dfNoData = GDALGetRasterNoDataValue( hBand, &bGotNodata );
if( bGotNodata )
{
printf( " NoData Value=%g\n", dfNoData );
}
if( GDALGetOverviewCount(hBand) > 0 )
{
int iOverview;
printf( " Overviews: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
}
printf( "\n" );
}
papszMetadata = GDALGetMetadata( hBand, NULL );
if( papszMetadata != NULL )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
if( GDALGetRasterColorInterpretation(hBand) == GCI_PaletteIndex )
{
GDALColorTableH hTable;
int i;
hTable = GDALGetRasterColorTable( hBand );
printf( " Color Table (%s with %d entries)\n",
GDALGetPaletteInterpretationName(
GDALGetPaletteInterpretation( hTable )),
GDALGetColorEntryCount( hTable ) );
for( i = 0; i < GDALGetColorEntryCount( hTable ); i++ )
{
GDALColorEntry sEntry;
GDALGetColorEntryAsRGB( hTable, i, &sEntry );
printf( " %3d: %d,%d,%d,%d\n",
i,
sEntry.c1,
sEntry.c2,
sEntry.c3,
sEntry.c4 );
}
}
}
GDALClose( hDataset );
exit( 0 );
}
int QgsZonalStatistics::calculateStatistics( QProgressDialog* p )
{
if ( !mPolygonLayer || mPolygonLayer->geometryType() != QGis::Polygon )
{
return 1;
}
QgsVectorDataProvider* vectorProvider = mPolygonLayer->dataProvider();
if ( !vectorProvider )
{
return 2;
}
//open the raster layer and the raster band
GDALAllRegister();
GDALDatasetH inputDataset = GDALOpen( mRasterFilePath.toLocal8Bit().data(), GA_ReadOnly );
if ( inputDataset == NULL )
{
return 3;
}
if ( GDALGetRasterCount( inputDataset ) < ( mRasterBand - 1 ) )
{
GDALClose( inputDataset );
return 4;
}
GDALRasterBandH rasterBand = GDALGetRasterBand( inputDataset, mRasterBand );
if ( rasterBand == NULL )
{
GDALClose( inputDataset );
return 5;
}
mInputNodataValue = GDALGetRasterNoDataValue( rasterBand, NULL );
//get geometry info about raster layer
int nCellsX = GDALGetRasterXSize( inputDataset );
int nCellsY = GDALGetRasterYSize( inputDataset );
double geoTransform[6];
if ( GDALGetGeoTransform( inputDataset, geoTransform ) != CE_None )
{
GDALClose( inputDataset );
return 6;
}
double cellsizeX = geoTransform[1];
if ( cellsizeX < 0 )
{
cellsizeX = -cellsizeX;
}
double cellsizeY = geoTransform[5];
if ( cellsizeY < 0 )
{
cellsizeY = -cellsizeY;
}
QgsRectangle rasterBBox( geoTransform[0], geoTransform[3] - ( nCellsY * cellsizeY ), geoTransform[0] + ( nCellsX * cellsizeX ), geoTransform[3] );
//add the new count, sum, mean fields to the provider
QList<QgsField> newFieldList;
QgsField countField( mAttributePrefix + "count", QVariant::Double );
QgsField sumField( mAttributePrefix + "sum", QVariant::Double );
QgsField meanField( mAttributePrefix + "mean", QVariant::Double );
newFieldList.push_back( countField );
newFieldList.push_back( sumField );
newFieldList.push_back( meanField );
if ( !vectorProvider->addAttributes( newFieldList ) )
{
return 7;
}
//index of the new fields
int countIndex = vectorProvider->fieldNameIndex( mAttributePrefix + "count" );
int sumIndex = vectorProvider->fieldNameIndex( mAttributePrefix + "sum" );
int meanIndex = vectorProvider->fieldNameIndex( mAttributePrefix + "mean" );
if ( countIndex == -1 || sumIndex == -1 || meanIndex == -1 )
{
return 8;
}
//progress dialog
long featureCount = vectorProvider->featureCount();
if ( p )
{
p->setMaximum( featureCount );
}
//iterate over each polygon
vectorProvider->select( QgsAttributeList(), QgsRectangle(), true, false );
vectorProvider->rewind();
QgsFeature f;
double count = 0;
double sum = 0;
double mean = 0;
int featureCounter = 0;
while ( vectorProvider->nextFeature( f ) )
{
qWarning( "%d", featureCounter );
if ( p )
{
p->setValue( featureCounter );
}
if ( p && p->wasCanceled() )
{
break;
}
QgsGeometry* featureGeometry = f.geometry();
if ( !featureGeometry )
{
++featureCounter;
continue;
}
int offsetX, offsetY, nCellsX, nCellsY;
if ( cellInfoForBBox( rasterBBox, featureGeometry->boundingBox(), cellsizeX, cellsizeY, offsetX, offsetY, nCellsX, nCellsY ) != 0 )
{
++featureCounter;
continue;
}
statisticsFromMiddlePointTest_improved( rasterBand, featureGeometry, offsetX, offsetY, nCellsX, nCellsY, cellsizeX, cellsizeY,
rasterBBox, sum, count );
if ( count <= 1 )
{
//the cell resolution is probably larger than the polygon area. We switch to precise pixel - polygon intersection in this case
statisticsFromPreciseIntersection( rasterBand, featureGeometry, offsetX, offsetY, nCellsX, nCellsY, cellsizeX, cellsizeY,
rasterBBox, sum, count );
}
if ( count == 0 )
{
mean = 0;
}
else
{
mean = sum / count;
}
//write the statistics value to the vector data provider
QgsChangedAttributesMap changeMap;
QgsAttributeMap changeAttributeMap;
changeAttributeMap.insert( countIndex, QVariant( count ) );
changeAttributeMap.insert( sumIndex, QVariant( sum ) );
changeAttributeMap.insert( meanIndex, QVariant( mean ) );
changeMap.insert( f.id(), changeAttributeMap );
vectorProvider->changeAttributeValues( changeMap );
++featureCounter;
}
if ( p )
{
p->setValue( featureCount );
}
GDALClose( inputDataset );
return 0;
}
double QgsCoordinateFormat::getHeightAtPos( const QgsPoint& p, const QgsCoordinateReferenceSystem& crs, QGis::UnitType unit, QString* errMsg )
{
QString layerid = QgsProject::instance()->readEntry( "Heightmap", "layer" );
QgsMapLayer* layer = QgsMapLayerRegistry::instance()->mapLayer( layerid );
if ( !layer || layer->type() != QgsMapLayer::RasterLayer )
{
if ( errMsg )
*errMsg = tr( "No heightmap is defined in the project." ), tr( "Right-click a raster layer in the layer tree and select it to be used as heightmap." );
return 0;
}
QString rasterFile = layer->source();
GDALDatasetH raster = GDALOpen( rasterFile.toLocal8Bit().data(), GA_ReadOnly );
if ( !raster )
{
if ( errMsg )
*errMsg = tr( "Failed to open raster file: %1" ).arg( rasterFile );
return 0;
}
double gtrans[6] = {};
if ( GDALGetGeoTransform( raster, >rans[0] ) != CE_None )
{
if ( errMsg )
*errMsg = tr( "Failed to get raster geotransform" );
GDALClose( raster );
return 0;
}
QString proj( GDALGetProjectionRef( raster ) );
const QgsCoordinateReferenceSystem& rasterCrs = QgsCRSCache::instance()->crsByWkt( proj );
if ( !rasterCrs.isValid() )
{
if ( errMsg )
*errMsg = tr( "Failed to get raster CRS" );
GDALClose( raster );
return 0;
}
GDALRasterBandH band = GDALGetRasterBand( raster, 1 );
if ( !raster )
{
if ( errMsg )
*errMsg = tr( "Failed to open raster band 0" );
GDALClose( raster );
return 0;
}
// Get vertical unit
QGis::UnitType vertUnit = strcmp( GDALGetRasterUnitType( band ), "ft" ) == 0 ? QGis::Feet : QGis::Meters;
// Transform geo position to raster CRS
QgsPoint pRaster = QgsCoordinateTransformCache::instance()->transform( crs.authid(), rasterCrs.authid() )->transform( p );
QgsDebugMsg( QString( "Transform %1 from %2 to %3 gives %4" ).arg( p.toString() )
.arg( crs.authid() ).arg( rasterCrs.authid() ).arg( pRaster.toString() ) );
// Transform raster geo position to pixel coordinates
double row = ( -gtrans[0] * gtrans[4] + gtrans[1] * gtrans[3] - gtrans[1] * pRaster.y() + gtrans[4] * pRaster.x() ) / ( gtrans[2] * gtrans[4] - gtrans[1] * gtrans[5] );
double col = ( -gtrans[0] * gtrans[5] + gtrans[2] * gtrans[3] - gtrans[2] * pRaster.y() + gtrans[5] * pRaster.x() ) / ( gtrans[1] * gtrans[5] - gtrans[2] * gtrans[4] );
double pixValues[4] = {};
if ( CE_None != GDALRasterIO( band, GF_Read,
qFloor( col ), qFloor( row ), 2, 2, &pixValues[0], 2, 2, GDT_Float64, 0, 0 ) )
{
if ( errMsg )
*errMsg = tr( "Failed to read pixel values" );
GDALClose( raster );
return 0;
}
GDALClose( raster );
// Interpolate values
double lambdaR = row - qFloor( row );
double lambdaC = col - qFloor( col );
double value = ( pixValues[0] * ( 1. - lambdaC ) + pixValues[1] * lambdaC ) * ( 1. - lambdaR )
+ ( pixValues[2] * ( 1. - lambdaC ) + pixValues[3] * lambdaC ) * ( lambdaR );
if ( rasterCrs.mapUnits() != unit )
{
value *= QGis::fromUnitToUnitFactor( vertUnit, unit );
}
return value;
}
ral_grid_handle RAL_CALL ral_grid_create_using_GDAL(GDALDatasetH dataset, int band, ral_rectangle clip_region, double cell_size)
{
GDALRasterBandH hBand;
GDALDataType datatype;
int M, N, gd_datatype;
int W, H; /* size of the full GDAL raster */
int north_up, east_up, i0, j0, i1, j1, w, h; /* the clip region (P) */
int ws, hs; /* the size of the buffer into which to rasterIO to */
CPLErr err;
ral_grid *gd_s = NULL, *gd_t = NULL;
double t[6] = {0,1,0,0,0,1}; /* the geotransformation P -> G */
double tx[6]; /* the inverse geotransformation G -> P */
ral_rectangle GDAL; /* boundaries of the GDAL raster */
ral_point p0, p1, p2, p3; /* locations of corners of clip region:
top left, top right, bottom right, bottom left, i.e,
0,0 W',0 W',H' 0,H' */
CPLPushErrorHandler(ral_cpl_error);
GDALGetGeoTransform(dataset, t);
north_up = (t[2] == 0) AND (t[4] == 0);
east_up = (t[1] == 0) AND (t[5] == 0);
/*fprintf(stderr, "\nt is\n%f %f %f\n%f %f %f\n", t[0],t[1],t[2],t[3],t[4],t[5]);*/
W = GDALGetRasterXSize(dataset);
H = GDALGetRasterYSize(dataset);
/*fprintf(stderr, "cell size is %f, raster size is %i %i\n", cell_size, W, H);*/
/* test all corners to find the min & max xg and yg */
{
double x, y;
P2G(0, 0, t, GDAL.min.x, GDAL.min.y);
GDAL.max.x = GDAL.min.x;
GDAL.max.y = GDAL.min.y;
P2G(0, H, t, x, y);
GDAL.min.x = MIN(x, GDAL.min.x);
GDAL.min.y = MIN(y, GDAL.min.y);
GDAL.max.x = MAX(x, GDAL.max.x);
GDAL.max.y = MAX(y, GDAL.max.y);
P2G(W, H, t, x, y);
GDAL.min.x = MIN(x, GDAL.min.x);
GDAL.min.y = MIN(y, GDAL.min.y);
GDAL.max.x = MAX(x, GDAL.max.x);
GDAL.max.y = MAX(y, GDAL.max.y);
P2G(W, 0, t, x, y);
GDAL.min.x = MIN(x, GDAL.min.x);
GDAL.min.y = MIN(y, GDAL.min.y);
GDAL.max.x = MAX(x, GDAL.max.x);
GDAL.max.y = MAX(y, GDAL.max.y);
}
/*fprintf(stderr, "clip region is %f %f %f %f\n", clip_region.min.x, clip_region.min.y, clip_region.max.x, clip_region.max.y);
fprintf(stderr, "GDAL raster is %f %f %f %f\n", GDAL.min.x, GDAL.min.y, GDAL.max.x, GDAL.max.y);*/
clip_region.min.x = MAX(clip_region.min.x, GDAL.min.x);
clip_region.min.y = MAX(clip_region.min.y, GDAL.min.y);
clip_region.max.x = MIN(clip_region.max.x, GDAL.max.x);
clip_region.max.y = MIN(clip_region.max.y, GDAL.max.y);
/*fprintf(stderr, "visible region is %f %f %f %f\n", clip_region.min.x, clip_region.min.y, clip_region.max.x, clip_region.max.y);*/
RAL_CHECK((clip_region.min.x < clip_region.max.x) AND (clip_region.min.y < clip_region.max.y));
/* the inverse transformation, from georeferenced space to pixel space */
{
double tmp = t[2]*t[4] - t[1]*t[5];
tx[0] = (t[0]*t[5] - t[2]*t[3])/tmp;
tx[1] = -t[5]/tmp;
tx[2] = t[2]/tmp;
tx[3] = (t[1]*t[3] - t[0]*t[4])/tmp;
tx[4] = t[4]/tmp;
tx[5] = -t[1]/tmp;
}
/* the clip region in pixel space */
/* test all corners to find the min & max xp and yp (j0..j1, i0..i1) */
{
int i, j;
G2P(clip_region.min.x, clip_region.min.y, tx, j0, i0);
j1 = j0;
i1 = i0;
G2P(clip_region.min.x, clip_region.max.y, tx, j, i);
j0 = MIN(j, j0);
i0 = MIN(i, i0);
j1 = MAX(j, j1);
i1 = MAX(i, i1);
G2P(clip_region.max.x, clip_region.max.y, tx, j, i);
j0 = MIN(j, j0);
i0 = MIN(i, i0);
j1 = MAX(j, j1);
i1 = MAX(i, i1);
G2P(clip_region.max.x, clip_region.min.y, tx, j, i);
j0 = MIN(j, j0);
i0 = MIN(i, i0);
j1 = MAX(j, j1);
i1 = MAX(i, i1);
j0 = MAX(j0, 0); j0 = MIN(j0, W-1);
j1 = MAX(j1, 0); j1 = MIN(j1, W-1);
i0 = MAX(i0, 0); i0 = MIN(i0, H-1);
i1 = MAX(i1, 0); i1 = MIN(i1, H-1);
}
w = j1 - j0 + 1;
h = i1 - i0 + 1;
/*fprintf(stderr, "visible region in raster is %i %i %i %i\n", j0, i0, j1, i1);*/
RAL_CHECK(w > 0 AND h > 0);
/* the corners of the raster clip */
P2G(j0, i0, t, p0.x, p0.y);
P2G(j1+1, i0, t, p1.x, p1.y);
P2G(j1+1, i1+1, t, p2.x, p2.y);
P2G(j0, i1+1, t, p3.x, p3.y);
/*fprintf(stderr, "source corners: (%f,%f %f,%f %f,%f %f,%f)\n", p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);*/
/* the width and height of the resized raster clip */
/* the resized clip has the same corner coordinates as the clip */
ws = round(sqrt((p1.x-p0.x)*(p1.x-p0.x)+(p1.y-p0.y)*(p1.y-p0.y))/cell_size);
hs = round(sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y))/cell_size);
/*fprintf(stderr, "clipped source size is %i, %i\n", ws, hs);*/
hBand = GDALGetRasterBand(dataset, band);
RAL_CHECK(hBand);
switch (GDALGetRasterDataType(hBand)) {
case GDT_Byte:
case GDT_UInt16:
case GDT_Int16:
case GDT_UInt32:
case GDT_Int32:
gd_datatype = RAL_INTEGER_GRID;
switch (sizeof(RAL_INTEGER)) { /* hmm.. this breaks if INTEGER is unsigned */
case 1:
datatype = GDT_Byte;
break;
case 2:
datatype = GDT_Int16;
break;
case 4:
datatype = GDT_Int32;
break;
default:
RAL_CHECKM(0, ral_msg("Strange sizeof(INTEGER): %i",sizeof(RAL_INTEGER)));
}
break;
case GDT_Float32:
case GDT_Float64:
gd_datatype = RAL_REAL_GRID;
switch (sizeof(RAL_REAL)) {
case 4:
datatype = GDT_Float32;
break;
case 8:
datatype = GDT_Float64;
break;
default:
RAL_CHECKM(0, ral_msg("Strange sizeof(REAL): %i", sizeof(RAL_REAL)));
}
break;
default:
RAL_CHECKM(0, "complex data type not supported");
}
/* size of the grid in display */
M = ceil(fabs(clip_region.max.y - clip_region.min.y)/cell_size);
N = ceil(fabs(clip_region.max.x - clip_region.min.x)/cell_size);
/*fprintf(stderr, "display size is %i, %i\n", N, M);*/
RAL_CHECK(gd_s = ral_grid_create(gd_datatype, hs, ws));
RAL_CHECK(gd_t = ral_grid_create(gd_datatype, M, N));
ral_grid_set_bounds_csnx(gd_t, cell_size, clip_region.min.x, clip_region.max.y);
err = GDALRasterIO(hBand, GF_Read, j0, i0, w, h, gd_s->data, ws, hs, datatype, 0, 0);
RAL_CHECK(err == CE_None);
{
int success;
double nodata_value = GDALGetRasterNoDataValue(hBand, &success);
if (success) {
RAL_CHECK(ral_grid_set_real_nodata_value(gd_t, nodata_value));
RAL_CHECK(ral_grid_set_all_nodata(gd_t));
} else {
RAL_CHECK(ral_grid_set_real_nodata_value(gd_t, -9999)); /* change this! */
RAL_CHECK(ral_grid_set_all_nodata(gd_t));
}
}
/* from source to target */
{
/* b = from p0 to p1 */
double bx = p1.x - p0.x;
double by = p1.y - p0.y;
double b = east_up ? 0 : bx/by;
double b2 = east_up ? 1 : sqrt(1+1/b/b);
/*fprintf(stderr, "b = %f %f (%f)\n", bx, by, b);*/
/* c = from p0 to p3 */
double cx = p3.x - p0.x;
double cy = p3.y - p0.y;
double c = north_up ? 0 : cx/cy;
double c2 = north_up ? 1 : sqrt(1+1/c/c);
/*fprintf(stderr, "c = %f %f (%f)\n", cx, cy, c);*/
ral_cell cs, ct;
switch (gd_t->datatype) {
case RAL_REAL_GRID:
RAL_FOR(ct, gd_t) {
/* p = the location of the center of the target pixel in georeferenced coordinates */
double px = clip_region.min.x + cell_size*(ct.j+0.5);
double py = clip_region.max.y - cell_size*(ct.i+0.5);
/* vector a = from p0 to p */
double ax = px - p0.x;
double ay = py - p0.y;
/* x = the vector from p0 to the beginning of y */
double x = east_up ? ay : (north_up ? ax : (ax-c*ay)/(1-c/b));
if (!east_up AND !north_up AND (x/b > 0)) continue;
/* the length */
x = fabs(x)*b2;
/* y = length of the parallel to c vector from b to p */
double y = east_up ? ax : (north_up ? ay : (ax-b*ay)/(1-b/c));
if (!east_up AND !north_up AND (y/c < 0)) continue;
/* the length */
y = fabs(y)*c2;
ral_cell cs; /* the coordinates in the clipped raster */
cs.j = floor(x/cell_size);
cs.i = floor(y/cell_size);
if (RAL_GRID_CELL_IN(gd_s, cs))
RAL_REAL_GRID_CELL(gd_t, ct) = RAL_REAL_GRID_CELL(gd_s, cs);
}
break;
case RAL_INTEGER_GRID:
RAL_FOR(ct, gd_t) {
/* p = the location of the center of the target pixel in georeferenced coordinates */
double px = clip_region.min.x + cell_size*(ct.j+0.5);
double py = clip_region.max.y - cell_size*(ct.i+0.5);
/* vector a = from p0 to p */
double ax = px - p0.x;
double ay = py - p0.y;
/* x = the vector from p0 to the beginning of y */
double x = east_up ? ay : (north_up ? ax : (ax-c*ay)/(1-c/b));
if (!east_up AND !north_up AND (x/b > 0)) continue;
/* the length */
x = fabs(x)*b2;
/* y = length of the parallel to c vector from b to p */
double y = east_up ? ax : (north_up ? ay : (ax-b*ay)/(1-b/c));
if (!east_up AND !north_up AND (y/c < 0)) continue;
/* the length */
y = fabs(y)*c2;
ral_cell cs; /* the coordinates in the clipped raster */
cs.j = floor(x/cell_size);
cs.i = floor(y/cell_size);
/*
if ((cs.i == 0 AND cs.j == 0) OR (cs.i == hs-1 AND cs.j == 0) OR
(cs.i == 0 AND cs.j == ws-1) OR (cs.i == hs-1 AND cs.j == ws-1) OR
(ct.i == 0 AND ct.j == 0) OR (ct.i == M-1 AND ct.j == N-1)) {
fprintf(stderr, "p = %f %f\n", px, py);
fprintf(stderr, "a = %f %f\n", ax, ay);
fprintf(stderr, "x = %f\n", x);
fprintf(stderr, "y = %f\n", y);
fprintf(stderr, "copy %i, %i -> %i, %i\n", cs.j, cs.i, ct.j, ct.i);
}
*/
if (RAL_GRID_CELL_IN(gd_s, cs)) {
RAL_INTEGER_GRID_CELL(gd_t, ct) = RAL_INTEGER_GRID_CELL(gd_s, cs);
}
}
}
int main(void)
{
GDALAllRegister();
/*Open a file*/
GDALDatasetH hDataset;
hDataset = GDALOpen( "./dem.tif", GA_ReadOnly );
if( hDataset == NULL ) printf("The dataset is NULL!\n");
/*Getting Dasetset Information*/
GDALDriverH hDriver;
double adfGeoTransform[6];
hDriver = GDALGetDatasetDriver( hDataset );
printf( "Driver: %s/%s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ));
printf("Size is %dx%dx%d\n",
GDALGetRasterXSize( hDataset ),
GDALGetRasterYSize( hDataset ),
GDALGetRasterCount( hDataset ));
if( GDALGetProjectionRef( hDataset ) != NULL )
printf("Projection is '%s'\n", GDALGetProjectionRef( hDataset ) );
if (GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
printf("Origin = (%.6f,%.6f)\n",
adfGeoTransform[0], adfGeoTransform[3]);
printf( "Pixel Size = (%.6f,%.6f)\n",
adfGeoTransform[0], adfGeoTransform[5]);
}
/*Fetching a Raster Band*/
GDALRasterBandH hBand;
int nBlockXSize, nBlockYSize;
int bGotMin, bGotMax;
double adfMinMax[2];
hBand = GDALGetRasterBand( hDataset, 1);
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize);
printf( "Block=%dx%d Type=%s, ColorInterp=%s\n",
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(GDALGetRasterDataType(hBand)),
GDALGetColorInterpretationName(
GDALGetRasterColorInterpretation(hBand)) );
adfMinMax[0] = GDALGetRasterMinimum( hBand, &bGotMin );
adfMinMax[1] = GDALGetRasterMaximum( hBand, &bGotMax );
if( !(bGotMin && bGotMax) )
{
GDALComputeRasterMinMax( hBand, TRUE, adfMinMax );
}
printf( "Min=%.3fd, Max=%.3f\n", adfMinMax[0], adfMinMax[1]);
if(GDALGetOverviewCount(hBand) > 0)
printf( "Band has %d overviews.\n", GDALGetOverviewCount(hBand));
if( GDALGetRasterColorTable( hBand ) != NULL)
printf( "Band has a color table with %d entries.\n",
GDALGetColorEntryCount(
GDALGetRasterColorTable( hBand)));
/*Reading Raster Data*/
float *pafScanline;
int nXSize = GDALGetRasterBandXSize( hBand );
pafScanline = (float *)CPLMalloc(sizeof(float)*nXSize);
GDALRasterIO(hBand, GF_Read, 0, 0, nXSize, 1,
pafScanline, nXSize, 1, GDT_Float32, 0, 0);
CPLFree(pafScanline);
return 0;
}
int main(int argc, char* argv[])
{
fprintf(stderr, "TASSELED CAP TRANSFORMATION\nVersion %s.%s. Free software. GNU General Public License, version 3\n", PROG_VERSION, DATE_VERSION);
fprintf(stderr, "Copyright (C) 2016 Igor Garkusha.\nUkraine, Dnipro\n\n");
if(argc!=5)
{
fputs("Input parameters not found!\n", stderr);
printHelp();
fputs("\n", stderr);
return 1;
}
GDALDatasetH pSrcDataset = NULL;
GDALDatasetH pDstDataset = NULL;
GDALRasterBandH pSrcBand = NULL;
GDALRasterBandH pDstBand = NULL;
GDALDriverH pDriver = NULL;
GDALAllRegister();
bool flagNoData = (atoi(argv[argc-1]) == 1)?true:false;
int sensorIndexFlag = OLI;
if( strcmp(argv[argc-2], "oli") == 0) sensorIndexFlag = OLI;
else
if( strcmp(argv[argc-2], "etm") == 0) sensorIndexFlag = ETM;
else
if( strcmp(argv[argc-2], "tm4") == 0) sensorIndexFlag = TM4;
else
if( strcmp(argv[argc-2], "tm5") == 0) sensorIndexFlag = TM5;
else
//if( strcmp(argv[argc-2], "msi10") == 0) sensorIndexFlag = S2AMSI10;
//else
if( strcmp(argv[argc-2], "msi") == 0) sensorIndexFlag = S2AMSI;
pSrcDataset = GDALOpen( argv[1], GA_ReadOnly );
int bands = 0;
if(pSrcDataset!=NULL)
{
if(CUtils::isFloat32DataType(pSrcDataset))
{
bands = GDALGetRasterCount(pSrcDataset);
if( ((bands == 6)||(bands == 4)) )
{
pSrcBand = GDALGetRasterBand(pSrcDataset, 1);
if(pSrcBand != NULL)
{
int cols = GDALGetRasterBandXSize(pSrcBand);
int rows = GDALGetRasterBandYSize(pSrcBand);
float NoDataValue = 0;
pDriver = GDALGetDriverByName("GTiff");
char **papszOptions = NULL;
pDstDataset = GDALCreate(pDriver, argv[2], cols, rows, COUNT_OUT_BANDS, GDT_Float32, papszOptions);
double adfGeoTransform[6]={0};
GDALGetGeoTransform(pSrcDataset, adfGeoTransform );
const char *szProjection = GDALGetProjectionRef(pSrcDataset);
GDALSetGeoTransform(pDstDataset, adfGeoTransform );
GDALSetProjection(pDstDataset, szProjection );
pDstBand = GDALGetRasterBand(pDstDataset, 1);
float *pSrcLine = NULL;
float *pDstLine = NULL;
pSrcLine = (float*)CPLMalloc(sizeof(GDALGetRasterDataType(pSrcBand))*cols);
pDstLine = (float*)CPLMalloc(sizeof(GDALGetRasterDataType(pDstBand))*cols);
if(flagNoData == false)
{
for(int resultBandNumber=1; resultBandNumber <= COUNT_OUT_BANDS; resultBandNumber++)
{
fprintf(stderr, "Processing for band %d...\n", resultBandNumber);
pDstBand = GDALGetRasterBand(pDstDataset, resultBandNumber);
int pr = CUtils::progress_ln_ex(stderr, 0, 0, START_PROGRESS);
for(int i=0; i<rows; i++)
{
for(int j=0; j<cols; j++) pDstLine[j] = 0;
for(int currentBandNumber=1; currentBandNumber <= bands; currentBandNumber++)
{
pSrcBand = GDALGetRasterBand(pSrcDataset, currentBandNumber);
GDALRasterIO(pSrcBand, GF_Read, 0, i, cols, 1, pSrcLine, cols, 1, GDALGetRasterDataType(pSrcBand), 0, 0 );
for(int j=0; j<cols; j++) pDstLine[j] += getTasseledCapValue(pSrcLine[j], sensorIndexFlag, resultBandNumber, currentBandNumber);
}
if(sensorIndexFlag == TM5) for(int j=0; j<cols; j++) pDstLine[j] += TM5_TCCoeff[resultBandNumber][6];
GDALRasterIO(pDstBand, GF_Write, 0, i, cols, 1, pDstLine, cols, 1, GDT_Float32, 0, 0 );
pr = CUtils::progress_ln_ex(stderr, i, rows, pr);
}
CUtils::progress_ln_ex(stderr, 0, 0, END_PROGRESS);
}
}
else // WITH NODATA VALUE - pixel(1,1)
{
for(int resultBandNumber=1; resultBandNumber <= COUNT_OUT_BANDS; resultBandNumber++)
{
fprintf(stderr, "Processing for band %d...\n", resultBandNumber);
pDstBand = GDALGetRasterBand(pDstDataset, resultBandNumber);
int pr = CUtils::progress_ln_ex(stderr, 0, 0, START_PROGRESS);
for(int i=0; i<rows; i++)
{
for(int j=0; j<cols; j++) pDstLine[j] = 0;
for(int currentBandNumber=1; currentBandNumber <= bands; currentBandNumber++)
{
pSrcBand = GDALGetRasterBand(pSrcDataset, currentBandNumber);
NoDataValue = CUtils::getFloatNoDataValueAsBackground(pSrcBand);
GDALRasterIO(pSrcBand, GF_Read, 0, i, cols, 1, pSrcLine, cols, 1, GDALGetRasterDataType(pSrcBand), 0, 0 );
for(int j=0; j<cols; j++)
{
if(NoDataValue == pSrcLine[j]) pDstLine[j] = NoDataValue;
else pDstLine[j] += getTasseledCapValue(pSrcLine[j], sensorIndexFlag, resultBandNumber, currentBandNumber);
}
}
if(sensorIndexFlag == TM5)
{
for(int j=0; j<cols; j++) if(NoDataValue != pDstLine[j]) pDstLine[j] += TM5_TCCoeff[resultBandNumber][6];
}
GDALRasterIO(pDstBand, GF_Write, 0, i, cols, 1, pDstLine, cols, 1, GDT_Float32, 0, 0 );
pr = CUtils::progress_ln_ex(stderr, i, rows, pr);
}
CUtils::progress_ln_ex(stderr, 0, 0, END_PROGRESS);
}
}
CPLFree(pSrcLine); pSrcLine = NULL;
CPLFree(pDstLine); pDstLine = NULL;
if(flagNoData) CUtils::calculateFloatGeoTIFFStatistics(pDstDataset, -1, true);
else CUtils::calculateFloatGeoTIFFStatistics(pDstDataset, -1, false);
fputs("Output band:\n\tband1: Brightness, band2: Greenness (Vegetation), band3: Wetness, band4: Haze\n\n", stderr);
fputs("\nEnd Processing.\n\n", stderr);
}
}
else
{
fputs("\nERROR: Source Band Number is Invalid!!!\n", stderr);
fprintf(stderr, "Source Bands Number: %d!\n\n", bands);
printHelp();
}
}
if(pSrcDataset!=NULL) { GDALClose(pSrcDataset); }
if(pDstDataset!=NULL) { GDALClose(pDstDataset); }
}
return 0;
}
s_sat * sat_load(const char * dname)
{
try;
bool is_first = true;
unsigned v, height, width, height_width, raster_num = 0;
char str[BUF_SIZE], * sstr;
DIR * dir = NULL;
struct dirent * entry;
GDALDatasetH ds = NULL;
s_sat * sat = NULL;
throw_null((sat = sat_init(DIM)));
throw_null((dir = opendir(dname)));
while((entry = readdir(dir)) != NULL)
for(v = 0; v < DIM; v++)
{
sprintf(str, "B%u0.tif", v + 1);
sstr = strstr(entry->d_name, str);
if((sstr != NULL) && (sstr[7] == '\0'))
{
sprintf(str, "%s/%s", dname, entry->d_name);
throw_null(ds = GDALOpen(str, GA_ReadOnly));
if(is_first)
{
height = sat->height = GDALGetRasterYSize(ds);
width = sat->width = GDALGetRasterXSize(ds);
throw((GDALGetGeoTransform(ds, sat->gt_coef) == CE_Failure));
throw_null((sat->proj_ref = strdup(GDALGetProjectionRef(ds))));
height_width = height * width;
is_first = false;
}
throw_null((sat->pixel[v] = sfire_alloc(sizeof(uint8_t), 1, height_width)));
throw((GDALDatasetRasterIO(ds, GF_Read, 0, 0, width, height, sat->pixel[v], width, height, GDT_Byte, 1, NULL, 0, 0, 0) == CE_Failure));
GDALClose(ds);
ds = NULL;
raster_num++;
break;
}
}
throw((raster_num != DIM));
catch;
sat_destroy(sat);
sat = NULL;
finally;
if(ds != NULL)
GDALClose(ds);
if(dir != NULL)
closedir(dir);
return sat;
}
int main(int argc, char *argv[])
{
const char *index_filename = NULL;
const char *tile_index = "location";
int i_arg, ti_field;
OGRDataSourceH hTileIndexDS;
OGRLayerH hLayer = NULL;
OGRFeatureDefnH hFDefn;
int write_absolute_path = FALSE;
char* current_path = NULL;
int i;
int nExistingFiles;
int skip_different_projection = FALSE;
char** existingFilesTab = NULL;
int alreadyExistingProjectionRefValid = FALSE;
char* alreadyExistingProjectionRef = NULL;
char* index_filename_mod;
int bExists;
VSIStatBuf sStatBuf;
const char *pszTargetSRS = "";
int bSetTargetSRS = FALSE;
OGRSpatialReferenceH hTargetSRS = NULL;
/* Check that we are running against at least GDAL 1.4 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400)
{
fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
OGRRegisterAll();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Get commandline arguments other than the GDAL raster filenames. */
/* -------------------------------------------------------------------- */
for( i_arg = 1; i_arg < argc; i_arg++ )
{
if( EQUAL(argv[i_arg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( strcmp(argv[i_arg],"-tileindex") == 0 )
{
tile_index = argv[++i_arg];
}
else if( strcmp(argv[i_arg],"-t_srs") == 0 )
{
pszTargetSRS = argv[++i_arg];
bSetTargetSRS = TRUE;
}
else if ( strcmp(argv[i_arg],"-write_absolute_path") == 0 )
{
write_absolute_path = TRUE;
}
else if ( strcmp(argv[i_arg],"-skip_different_projection") == 0 )
{
skip_different_projection = TRUE;
}
else if( argv[i_arg][0] == '-' )
Usage();
else if( index_filename == NULL )
{
index_filename = argv[i_arg];
i_arg++;
break;
}
}
if( index_filename == NULL || i_arg == argc )
Usage();
/* -------------------------------------------------------------------- */
/* Create and validate target SRS if given. */
/* -------------------------------------------------------------------- */
if( bSetTargetSRS )
{
if ( skip_different_projection )
{
fprintf( stderr,
"Warning : -skip_different_projection does not apply "
"when -t_srs is requested.\n" );
}
hTargetSRS = OSRNewSpatialReference("");
if( OSRSetFromUserInput( hTargetSRS, pszTargetSRS ) != CE_None )
{
OSRDestroySpatialReference( hTargetSRS );
fprintf( stderr, "Invalid target SRS `%s'.\n",
pszTargetSRS );
exit(1);
}
}
/* -------------------------------------------------------------------- */
/* Open or create the target shapefile and DBF file. */
/* -------------------------------------------------------------------- */
index_filename_mod = CPLStrdup(CPLResetExtension(index_filename, "shp"));
bExists = (VSIStat(index_filename_mod, &sStatBuf) == 0);
if (!bExists)
{
CPLFree(index_filename_mod);
index_filename_mod = CPLStrdup(CPLResetExtension(index_filename, "SHP"));
bExists = (VSIStat(index_filename_mod, &sStatBuf) == 0);
}
CPLFree(index_filename_mod);
if (bExists)
{
hTileIndexDS = OGROpen( index_filename, TRUE, NULL );
if (hTileIndexDS != NULL)
{
hLayer = OGR_DS_GetLayer(hTileIndexDS, 0);
}
}
else
{
OGRSFDriverH hDriver;
const char* pszDriverName = "ESRI Shapefile";
printf( "Creating new index file...\n" );
hDriver = OGRGetDriverByName( pszDriverName );
if( hDriver == NULL )
{
printf( "%s driver not available.\n", pszDriverName );
exit( 1 );
}
hTileIndexDS = OGR_Dr_CreateDataSource( hDriver, index_filename, NULL );
if (hTileIndexDS)
{
char* pszLayerName = CPLStrdup(CPLGetBasename(index_filename));
/* get spatial reference for output file from target SRS (if set) */
/* or from first input file */
OGRSpatialReferenceH hSpatialRef = NULL;
if( bSetTargetSRS )
{
hSpatialRef = OSRClone( hTargetSRS );
}
else
{
GDALDatasetH hDS = GDALOpen( argv[i_arg], GA_ReadOnly );
if (hDS)
{
const char* pszWKT = GDALGetProjectionRef(hDS);
if (pszWKT != NULL && pszWKT[0] != '\0')
{
hSpatialRef = OSRNewSpatialReference(pszWKT);
}
GDALClose(hDS);
}
}
hLayer = OGR_DS_CreateLayer( hTileIndexDS, pszLayerName, hSpatialRef, wkbPolygon, NULL );
CPLFree(pszLayerName);
if (hSpatialRef)
OSRRelease(hSpatialRef);
if (hLayer)
{
OGRFieldDefnH hFieldDefn = OGR_Fld_Create( tile_index, OFTString );
OGR_Fld_SetWidth( hFieldDefn, 255);
OGR_L_CreateField( hLayer, hFieldDefn, TRUE );
OGR_Fld_Destroy(hFieldDefn);
}
}
}
if( hTileIndexDS == NULL || hLayer == NULL )
{
fprintf( stderr, "Unable to open/create shapefile `%s'.\n",
index_filename );
exit(2);
}
hFDefn = OGR_L_GetLayerDefn(hLayer);
for( ti_field = 0; ti_field < OGR_FD_GetFieldCount(hFDefn); ti_field++ )
{
OGRFieldDefnH hFieldDefn = OGR_FD_GetFieldDefn( hFDefn, ti_field );
if( strcmp(OGR_Fld_GetNameRef(hFieldDefn), tile_index) == 0 )
break;
}
if( ti_field == OGR_FD_GetFieldCount(hFDefn) )
{
fprintf( stderr, "Unable to find field `%s' in DBF file `%s'.\n",
tile_index, index_filename );
exit(2);
}
/* Load in memory existing file names in SHP */
nExistingFiles = OGR_L_GetFeatureCount(hLayer, FALSE);
if (nExistingFiles)
{
OGRFeatureH hFeature;
existingFilesTab = (char**)CPLMalloc(nExistingFiles * sizeof(char*));
for(i=0;i<nExistingFiles;i++)
{
hFeature = OGR_L_GetNextFeature(hLayer);
existingFilesTab[i] = CPLStrdup(OGR_F_GetFieldAsString( hFeature, ti_field ));
if (i == 0)
{
GDALDatasetH hDS = GDALOpen(existingFilesTab[i], GA_ReadOnly );
if (hDS)
{
alreadyExistingProjectionRefValid = TRUE;
alreadyExistingProjectionRef = CPLStrdup(GDALGetProjectionRef(hDS));
GDALClose(hDS);
}
}
OGR_F_Destroy( hFeature );
}
}
if (write_absolute_path)
{
current_path = CPLGetCurrentDir();
if (current_path == NULL)
{
fprintf( stderr, "This system does not support the CPLGetCurrentDir call. "
"The option -write_absolute_path will have no effect\n");
write_absolute_path = FALSE;
}
}
/* -------------------------------------------------------------------- */
/* loop over GDAL files, processing. */
/* -------------------------------------------------------------------- */
for( ; i_arg < argc; i_arg++ )
{
GDALDatasetH hDS;
double adfGeoTransform[6];
double adfX[5], adfY[5];
int nXSize, nYSize;
char* fileNameToWrite;
const char* projectionRef;
VSIStatBuf sStatBuf;
int k;
OGRFeatureH hFeature;
OGRGeometryH hPoly, hRing;
/* Make sure it is a file before building absolute path name */
if (write_absolute_path && CPLIsFilenameRelative( argv[i_arg] ) &&
VSIStat( argv[i_arg], &sStatBuf ) == 0)
{
fileNameToWrite = CPLStrdup(CPLProjectRelativeFilename(current_path, argv[i_arg]));
}
else
{
fileNameToWrite = CPLStrdup(argv[i_arg]);
}
/* Checks that file is not already in tileindex */
for(i=0;i<nExistingFiles;i++)
{
if (EQUAL(fileNameToWrite, existingFilesTab[i]))
{
fprintf(stderr, "File %s is already in tileindex. Skipping it.\n",
fileNameToWrite);
break;
}
}
if (i != nExistingFiles)
{
CPLFree(fileNameToWrite);
continue;
}
hDS = GDALOpen( argv[i_arg], GA_ReadOnly );
if( hDS == NULL )
{
fprintf( stderr, "Unable to open %s, skipping.\n",
argv[i_arg] );
CPLFree(fileNameToWrite);
continue;
}
GDALGetGeoTransform( hDS, adfGeoTransform );
if( adfGeoTransform[0] == 0.0
&& adfGeoTransform[1] == 1.0
&& adfGeoTransform[3] == 0.0
&& ABS(adfGeoTransform[5]) == 1.0 )
{
fprintf( stderr,
"It appears no georeferencing is available for\n"
"`%s', skipping.\n",
argv[i_arg] );
GDALClose( hDS );
CPLFree(fileNameToWrite);
continue;
}
projectionRef = GDALGetProjectionRef(hDS);
/* if not set target srs, test that the current file uses same projection as others */
if( !bSetTargetSRS )
{
if (alreadyExistingProjectionRefValid)
{
int projectionRefNotNull, alreadyExistingProjectionRefNotNull;
projectionRefNotNull = projectionRef && projectionRef[0];
alreadyExistingProjectionRefNotNull = alreadyExistingProjectionRef && alreadyExistingProjectionRef[0];
if ((projectionRefNotNull &&
alreadyExistingProjectionRefNotNull &&
EQUAL(projectionRef, alreadyExistingProjectionRef) == 0) ||
(projectionRefNotNull != alreadyExistingProjectionRefNotNull))
{
fprintf(stderr, "Warning : %s is not using the same projection system as "
"other files in the tileindex.\n"
"This may cause problems when using it in MapServer for example.\n"
"Use -t_srs option to set target projection system (not supported by MapServer).\n"
"%s\n", argv[i_arg],
(skip_different_projection) ? "Skipping this file." : "");
if (skip_different_projection)
{
CPLFree(fileNameToWrite);
GDALClose( hDS );
continue;
}
}
}
else
{
alreadyExistingProjectionRefValid = TRUE;
alreadyExistingProjectionRef = CPLStrdup(projectionRef);
}
}
nXSize = GDALGetRasterXSize( hDS );
nYSize = GDALGetRasterYSize( hDS );
adfX[0] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[0] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[1] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[1] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[2] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[2] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[3] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[3] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[4] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[4] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
/* if set target srs, do the forward transformation of all points */
if( bSetTargetSRS )
{
OGRSpatialReferenceH hSourceSRS = NULL;
OGRCoordinateTransformationH hCT = NULL;
hSourceSRS = OSRNewSpatialReference( projectionRef );
if( hSourceSRS && !OSRIsSame( hSourceSRS, hTargetSRS ) )
{
hCT = OCTNewCoordinateTransformation( hSourceSRS, hTargetSRS );
if( hCT == NULL || !OCTTransform( hCT, 5, adfX, adfY, NULL ) )
{
fprintf( stderr,
"Warning : unable to transform points from source SRS `%s' to target SRS `%s'\n"
"for file `%s' - file skipped\n",
projectionRef, pszTargetSRS, fileNameToWrite );
if ( hCT )
OCTDestroyCoordinateTransformation( hCT );
if ( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
continue;
}
if ( hCT )
OCTDestroyCoordinateTransformation( hCT );
}
if ( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
}
hFeature = OGR_F_Create( OGR_L_GetLayerDefn( hLayer ) );
OGR_F_SetFieldString( hFeature, ti_field, fileNameToWrite );
hPoly = OGR_G_CreateGeometry(wkbPolygon);
hRing = OGR_G_CreateGeometry(wkbLinearRing);
for(k=0;k<5;k++)
OGR_G_SetPoint_2D(hRing, k, adfX[k], adfY[k]);
OGR_G_AddGeometryDirectly( hPoly, hRing );
OGR_F_SetGeometryDirectly( hFeature, hPoly );
if( OGR_L_CreateFeature( hLayer, hFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature in shapefile.\n" );
break;
}
OGR_F_Destroy( hFeature );
CPLFree(fileNameToWrite);
GDALClose( hDS );
}
CPLFree(current_path);
if (nExistingFiles)
{
for(i=0;i<nExistingFiles;i++)
{
CPLFree(existingFilesTab[i]);
}
CPLFree(existingFilesTab);
}
CPLFree(alreadyExistingProjectionRef);
if ( hTargetSRS )
OSRDestroySpatialReference( hTargetSRS );
OGR_DS_Destroy( hTileIndexDS );
GDALDestroyDriverManager();
OGRCleanupAll();
CSLDestroy(argv);
exit( 0 );
}
static ERL_NIF_TERM gdal_nif_get_meta(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
gdal_img_handle* handle;
if (enif_get_resource(env, argv[0], gdal_img_RESOURCE, (void**)&handle)) {
GDALDatasetH in_ds = handle->in_ds;
if (in_ds != NULL) {
ERL_NIF_TERM terms[8];
int idx = 0;
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "description"),
enif_make_string(env, GDALGetDescription(in_ds), ERL_NIF_LATIN1));
GDALDriverH hDriver = GDALGetDatasetDriver(in_ds);
char buf[256];
sprintf(buf, "%s/%s",
GDALGetDriverShortName(hDriver), GDALGetDriverLongName(hDriver));
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "driver"),
enif_make_string(env, buf, ERL_NIF_LATIN1));
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "rasterSize"),
enif_make_tuple2(env,
enif_make_int(env, GDALGetRasterXSize(in_ds)),
enif_make_int(env, GDALGetRasterYSize(in_ds))));
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "rasterCount"),
enif_make_int(env, GDALGetRasterCount(in_ds)));
double adfGeoTransform[6];
if( GDALGetGeoTransform( in_ds, adfGeoTransform ) == CE_None ) {
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "origin"),
enif_make_tuple2(env,
enif_make_double(env, adfGeoTransform[0]),
enif_make_double(env, adfGeoTransform[3])));
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "pixelSize"),
enif_make_tuple2(env,
enif_make_double(env, adfGeoTransform[1]),
enif_make_double(env, adfGeoTransform[5])));
}
if (GDALGetProjectionRef(in_ds) != NULL) {
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "projection"),
enif_make_string(env,
GDALGetProjectionRef(in_ds), ERL_NIF_LATIN1));
}
char** fileList = GDALGetFileList(in_ds);
if (fileList != NULL) {
ERL_NIF_TERM fileTerms[16];
int fileIdx = 0;
char** files = fileList;
do {
fileTerms[ fileIdx++ ] = enif_make_string(env, *files, ERL_NIF_LATIN1);
} while(*(++files)) ;
CSLDestroy(fileList);
terms[idx++] = enif_make_tuple2(env,
enif_make_atom(env, "fileList"),
enif_make_list_from_array(env, fileTerms, fileIdx));
}
return enif_make_list_from_array(env, terms, idx);
}
else {
return ATOM_NOT_OPEN;
}
}
else {
return enif_make_badarg(env);
}
}
MAIN_START(argc, argv)
{
// Check that we are running against at least GDAL 1.4.
// Note to developers: if we use newer API, please change the requirement.
if( atoi(GDALVersionInfo("VERSION_NUM")) < 1400 )
{
fprintf(stderr,
"At least, GDAL >= 1.4.0 is required for this version of %s, "
"which was compiled against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
OGRRegisterAll();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Get commandline arguments other than the GDAL raster filenames. */
/* -------------------------------------------------------------------- */
const char* pszIndexLayerName = nullptr;
const char *index_filename = nullptr;
const char *tile_index = "location";
const char* pszDriverName = nullptr;
size_t nMaxFieldSize = 254;
bool write_absolute_path = false;
char* current_path = nullptr;
bool skip_different_projection = false;
const char *pszTargetSRS = "";
bool bSetTargetSRS = false;
const char* pszSrcSRSName = nullptr;
int i_SrcSRSName = -1;
bool bSrcSRSFormatSpecified = false;
SrcSRSFormat eSrcSRSFormat = FORMAT_AUTO;
int iArg = 1; // Used after for.
for( ; iArg < argc; iArg++ )
{
if( EQUAL(argv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against "
"GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[iArg],"--help") )
Usage(nullptr);
else if( (strcmp(argv[iArg],"-f") == 0 || strcmp(argv[iArg],"-of") == 0) )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszDriverName = argv[++iArg];
}
else if( strcmp(argv[iArg],"-lyr_name") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszIndexLayerName = argv[++iArg];
}
else if( strcmp(argv[iArg],"-tileindex") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
tile_index = argv[++iArg];
}
else if( strcmp(argv[iArg],"-t_srs") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszTargetSRS = argv[++iArg];
bSetTargetSRS = true;
}
else if ( strcmp(argv[iArg],"-write_absolute_path") == 0 )
{
write_absolute_path = true;
}
else if ( strcmp(argv[iArg],"-skip_different_projection") == 0 )
{
skip_different_projection = true;
}
else if( strcmp(argv[iArg], "-src_srs_name") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszSrcSRSName = argv[++iArg];
}
else if( strcmp(argv[iArg], "-src_srs_format") == 0 )
{
const char* pszFormat;
bSrcSRSFormatSpecified = true;
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszFormat = argv[++iArg];
if( EQUAL(pszFormat, "AUTO") )
eSrcSRSFormat = FORMAT_AUTO;
else if( EQUAL(pszFormat, "WKT") )
eSrcSRSFormat = FORMAT_WKT;
else if( EQUAL(pszFormat, "EPSG") )
eSrcSRSFormat = FORMAT_EPSG;
else if( EQUAL(pszFormat, "PROJ") )
eSrcSRSFormat = FORMAT_PROJ;
}
else if( argv[iArg][0] == '-' )
Usage(CPLSPrintf("Unknown option name '%s'", argv[iArg]));
else if( index_filename == nullptr )
{
index_filename = argv[iArg];
iArg++;
break;
}
}
if( index_filename == nullptr )
Usage("No index filename specified.");
if( iArg == argc )
Usage("No file to index specified.");
if( bSrcSRSFormatSpecified && pszSrcSRSName == nullptr )
Usage("-src_srs_name must be specified when -src_srs_format is "
"specified.");
/* -------------------------------------------------------------------- */
/* Create and validate target SRS if given. */
/* -------------------------------------------------------------------- */
OGRSpatialReferenceH hTargetSRS = nullptr;
if( bSetTargetSRS )
{
if( skip_different_projection )
{
fprintf( stderr,
"Warning : -skip_different_projection does not apply "
"when -t_srs is requested.\n" );
}
hTargetSRS = OSRNewSpatialReference("");
OSRSetAxisMappingStrategy(hTargetSRS, OAMS_TRADITIONAL_GIS_ORDER);
// coverity[tainted_data]
if( OSRSetFromUserInput( hTargetSRS, pszTargetSRS ) != CE_None )
{
OSRDestroySpatialReference( hTargetSRS );
fprintf( stderr, "Invalid target SRS `%s'.\n",
pszTargetSRS );
exit(1);
}
}
/* -------------------------------------------------------------------- */
/* Open or create the target datasource */
/* -------------------------------------------------------------------- */
GDALDatasetH hTileIndexDS = GDALOpenEx(
index_filename, GDAL_OF_VECTOR | GDAL_OF_UPDATE, nullptr, nullptr, nullptr );
OGRLayerH hLayer = nullptr;
CPLString osFormat;
if( hTileIndexDS != nullptr )
{
GDALDriverH hDriver = GDALGetDatasetDriver(hTileIndexDS);
if( hDriver )
osFormat = GDALGetDriverShortName(hDriver);
if( GDALDatasetGetLayerCount(hTileIndexDS) == 1 )
{
hLayer = GDALDatasetGetLayer(hTileIndexDS, 0);
}
else
{
if( pszIndexLayerName == nullptr )
{
printf( "-lyr_name must be specified.\n" );
exit( 1 );
}
CPLPushErrorHandler(CPLQuietErrorHandler);
hLayer = GDALDatasetGetLayerByName(hTileIndexDS, pszIndexLayerName);
CPLPopErrorHandler();
}
}
else
{
printf( "Creating new index file...\n" );
if( pszDriverName == nullptr )
{
std::vector<CPLString> aoDrivers =
GetOutputDriversFor(index_filename, GDAL_OF_VECTOR);
if( aoDrivers.empty() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot guess driver for %s", index_filename);
exit( 10 );
}
else
{
if( aoDrivers.size() > 1 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Several drivers matching %s extension. Using %s",
CPLGetExtension(index_filename), aoDrivers[0].c_str() );
}
osFormat = aoDrivers[0];
}
}
else
{
osFormat = pszDriverName;
}
if( !EQUAL(osFormat, "ESRI Shapefile") )
nMaxFieldSize = 0;
GDALDriverH hDriver = GDALGetDriverByName( osFormat.c_str() );
if( hDriver == nullptr )
{
printf( "%s driver not available.\n", osFormat.c_str() );
exit( 1 );
}
hTileIndexDS =
GDALCreate( hDriver, index_filename, 0, 0, 0, GDT_Unknown, nullptr );
}
if( hTileIndexDS != nullptr && hLayer == nullptr )
{
OGRSpatialReferenceH hSpatialRef = nullptr;
char* pszLayerName = nullptr;
if( pszIndexLayerName == nullptr )
{
VSIStatBuf sStat;
if( EQUAL(osFormat, "ESRI Shapefile") ||
VSIStat(index_filename, &sStat) == 0 )
{
pszLayerName = CPLStrdup(CPLGetBasename(index_filename));
}
else
{
printf( "-lyr_name must be specified.\n" );
exit( 1 );
}
}
else
{
pszLayerName = CPLStrdup(pszIndexLayerName);
}
/* get spatial reference for output file from target SRS (if set) */
/* or from first input file */
if( bSetTargetSRS )
{
hSpatialRef = OSRClone( hTargetSRS );
}
else
{
GDALDatasetH hDS = GDALOpen( argv[iArg], GA_ReadOnly );
if( hDS )
{
const char* pszWKT = GDALGetProjectionRef(hDS);
if (pszWKT != nullptr && pszWKT[0] != '\0')
{
hSpatialRef = OSRNewSpatialReference(pszWKT);
OSRSetAxisMappingStrategy(hSpatialRef, OAMS_TRADITIONAL_GIS_ORDER);
}
GDALClose(hDS);
}
}
hLayer =
GDALDatasetCreateLayer( hTileIndexDS, pszLayerName, hSpatialRef,
wkbPolygon, nullptr );
CPLFree(pszLayerName);
if( hSpatialRef )
OSRRelease(hSpatialRef);
if( hLayer )
{
OGRFieldDefnH hFieldDefn = OGR_Fld_Create( tile_index, OFTString );
if( nMaxFieldSize )
OGR_Fld_SetWidth( hFieldDefn, static_cast<int>(nMaxFieldSize));
OGR_L_CreateField( hLayer, hFieldDefn, TRUE );
OGR_Fld_Destroy(hFieldDefn);
if( pszSrcSRSName != nullptr )
{
hFieldDefn = OGR_Fld_Create( pszSrcSRSName, OFTString );
if( nMaxFieldSize )
OGR_Fld_SetWidth(hFieldDefn,
static_cast<int>(nMaxFieldSize));
OGR_L_CreateField( hLayer, hFieldDefn, TRUE );
OGR_Fld_Destroy(hFieldDefn);
}
}
}
if( hTileIndexDS == nullptr || hLayer == nullptr )
{
fprintf( stderr, "Unable to open/create shapefile `%s'.\n",
index_filename );
exit(2);
}
OGRFeatureDefnH hFDefn = OGR_L_GetLayerDefn(hLayer);
const int ti_field = OGR_FD_GetFieldIndex( hFDefn, tile_index );
if( ti_field < 0 )
{
fprintf( stderr, "Unable to find field `%s' in file `%s'.\n",
tile_index, index_filename );
exit(2);
}
if( pszSrcSRSName != nullptr )
i_SrcSRSName = OGR_FD_GetFieldIndex( hFDefn, pszSrcSRSName );
// Load in memory existing file names in SHP.
int nExistingFiles = static_cast<int>(OGR_L_GetFeatureCount(hLayer, FALSE));
if( nExistingFiles < 0)
nExistingFiles = 0;
char** existingFilesTab = nullptr;
bool alreadyExistingProjectionRefValid = false;
char* alreadyExistingProjectionRef = nullptr;
if( nExistingFiles > 0 )
{
OGRFeatureH hFeature = nullptr;
existingFilesTab = static_cast<char **>(
CPLMalloc(nExistingFiles * sizeof(char*)));
for( int i = 0; i < nExistingFiles; i++ )
{
hFeature = OGR_L_GetNextFeature(hLayer);
existingFilesTab[i] =
CPLStrdup(OGR_F_GetFieldAsString( hFeature, ti_field ));
if( i == 0 )
{
GDALDatasetH hDS = GDALOpen(existingFilesTab[i], GA_ReadOnly );
if( hDS )
{
alreadyExistingProjectionRefValid = true;
alreadyExistingProjectionRef =
CPLStrdup(GDALGetProjectionRef(hDS));
GDALClose(hDS);
}
}
OGR_F_Destroy( hFeature );
}
}
if( write_absolute_path )
{
current_path = CPLGetCurrentDir();
if (current_path == nullptr)
{
fprintf( stderr,
"This system does not support the CPLGetCurrentDir call. "
"The option -write_absolute_path will have no effect\n" );
write_absolute_path = FALSE;
}
}
/* -------------------------------------------------------------------- */
/* loop over GDAL files, processing. */
/* -------------------------------------------------------------------- */
for( ; iArg < argc; iArg++ )
{
char *fileNameToWrite = nullptr;
VSIStatBuf sStatBuf;
// Make sure it is a file before building absolute path name.
if( write_absolute_path && CPLIsFilenameRelative( argv[iArg] ) &&
VSIStat( argv[iArg], &sStatBuf ) == 0 )
{
fileNameToWrite =
CPLStrdup(CPLProjectRelativeFilename(current_path, argv[iArg]));
}
else
{
fileNameToWrite = CPLStrdup(argv[iArg]);
}
// Checks that file is not already in tileindex.
{
int i = 0; // Used after for.
for( ; i < nExistingFiles; i++ )
{
if (EQUAL(fileNameToWrite, existingFilesTab[i]))
{
fprintf(stderr,
"File %s is already in tileindex. Skipping it.\n",
fileNameToWrite);
break;
}
}
if (i != nExistingFiles)
{
CPLFree(fileNameToWrite);
continue;
}
}
GDALDatasetH hDS = GDALOpen( argv[iArg], GA_ReadOnly );
if( hDS == nullptr )
{
fprintf( stderr, "Unable to open %s, skipping.\n",
argv[iArg] );
CPLFree(fileNameToWrite);
continue;
}
double adfGeoTransform[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
GDALGetGeoTransform( hDS, adfGeoTransform );
if( adfGeoTransform[0] == 0.0
&& adfGeoTransform[1] == 1.0
&& adfGeoTransform[3] == 0.0
&& std::abs(adfGeoTransform[5]) == 1.0 )
{
fprintf( stderr,
"It appears no georeferencing is available for\n"
"`%s', skipping.\n",
argv[iArg] );
GDALClose( hDS );
CPLFree(fileNameToWrite);
continue;
}
const char *projectionRef = GDALGetProjectionRef(hDS);
// If not set target srs, test that the current file uses same
// projection as others.
if( !bSetTargetSRS )
{
if( alreadyExistingProjectionRefValid )
{
int projectionRefNotNull, alreadyExistingProjectionRefNotNull;
projectionRefNotNull = projectionRef && projectionRef[0];
alreadyExistingProjectionRefNotNull =
alreadyExistingProjectionRef &&
alreadyExistingProjectionRef[0];
if ((projectionRefNotNull &&
alreadyExistingProjectionRefNotNull &&
EQUAL(projectionRef, alreadyExistingProjectionRef) == 0) ||
(projectionRefNotNull != alreadyExistingProjectionRefNotNull))
{
fprintf(
stderr,
"Warning : %s is not using the same projection system "
"as other files in the tileindex.\n"
"This may cause problems when using it in MapServer "
"for example.\n"
"Use -t_srs option to set target projection system "
"(not supported by MapServer).\n"
"%s\n", argv[iArg],
skip_different_projection ? "Skipping this file." : "");
if( skip_different_projection )
{
CPLFree(fileNameToWrite);
GDALClose( hDS );
continue;
}
}
}
else
{
alreadyExistingProjectionRefValid = true;
alreadyExistingProjectionRef = CPLStrdup(projectionRef);
}
}
const int nXSize = GDALGetRasterXSize( hDS );
const int nYSize = GDALGetRasterYSize( hDS );
double adfX[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
double adfY[5] = { 0.0, 0.0, 0.0, 0.0, 0.0 };
adfX[0] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[0] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[1] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[1] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[2] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[2] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[3] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[3] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[4] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[4] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
OGRSpatialReferenceH hSourceSRS = nullptr;
if( (bSetTargetSRS || i_SrcSRSName >= 0) &&
projectionRef != nullptr &&
projectionRef[0] != '\0' )
{
hSourceSRS = OSRNewSpatialReference( projectionRef );
OSRSetAxisMappingStrategy(hSourceSRS, OAMS_TRADITIONAL_GIS_ORDER);
}
// If set target srs, do the forward transformation of all points.
if( bSetTargetSRS && projectionRef != nullptr && projectionRef[0] != '\0' )
{
OGRCoordinateTransformationH hCT = nullptr;
if( hSourceSRS && !OSRIsSame( hSourceSRS, hTargetSRS ) )
{
hCT = OCTNewCoordinateTransformation( hSourceSRS, hTargetSRS );
if( hCT == nullptr || !OCTTransform( hCT, 5, adfX, adfY, nullptr ) )
{
fprintf(
stderr,
"Warning : unable to transform points from source "
"SRS `%s' to target SRS `%s'\n"
"for file `%s' - file skipped\n",
projectionRef, pszTargetSRS, fileNameToWrite );
if( hCT )
OCTDestroyCoordinateTransformation( hCT );
if( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
continue;
}
if( hCT )
OCTDestroyCoordinateTransformation( hCT );
}
}
OGRFeatureH hFeature = OGR_F_Create( OGR_L_GetLayerDefn( hLayer ) );
OGR_F_SetFieldString( hFeature, ti_field, fileNameToWrite );
if( i_SrcSRSName >= 0 && hSourceSRS != nullptr )
{
const char* pszAuthorityCode =
OSRGetAuthorityCode(hSourceSRS, nullptr);
const char* pszAuthorityName =
OSRGetAuthorityName(hSourceSRS, nullptr);
if( eSrcSRSFormat == FORMAT_AUTO )
{
if( pszAuthorityName != nullptr && pszAuthorityCode != nullptr )
{
OGR_F_SetFieldString(
hFeature, i_SrcSRSName,
CPLSPrintf("%s:%s",
pszAuthorityName, pszAuthorityCode) );
}
else if( nMaxFieldSize == 0 ||
strlen(projectionRef) <= nMaxFieldSize )
{
OGR_F_SetFieldString(hFeature, i_SrcSRSName, projectionRef);
}
else
{
char* pszProj4 = nullptr;
if( OSRExportToProj4(hSourceSRS, &pszProj4) == OGRERR_NONE )
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName,
pszProj4 );
CPLFree(pszProj4);
}
else
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName,
projectionRef );
}
}
}
else if( eSrcSRSFormat == FORMAT_WKT )
{
if( nMaxFieldSize == 0 ||
strlen(projectionRef) <= nMaxFieldSize )
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName,
projectionRef );
}
else
{
fprintf(stderr,
"Cannot write WKT for file %s as it is too long!\n",
fileNameToWrite);
}
}
else if( eSrcSRSFormat == FORMAT_PROJ )
{
char* pszProj4 = nullptr;
if( OSRExportToProj4(hSourceSRS, &pszProj4) == OGRERR_NONE )
{
OGR_F_SetFieldString( hFeature, i_SrcSRSName, pszProj4 );
CPLFree(pszProj4);
}
}
else if( eSrcSRSFormat == FORMAT_EPSG )
{
if( pszAuthorityName != nullptr && pszAuthorityCode != nullptr )
OGR_F_SetFieldString(
hFeature, i_SrcSRSName,
CPLSPrintf("%s:%s",
pszAuthorityName, pszAuthorityCode) );
}
}
if( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
OGRGeometryH hPoly = OGR_G_CreateGeometry(wkbPolygon);
OGRGeometryH hRing = OGR_G_CreateGeometry(wkbLinearRing);
for( int k = 0; k < 5; k++ )
OGR_G_SetPoint_2D(hRing, k, adfX[k], adfY[k]);
OGR_G_AddGeometryDirectly( hPoly, hRing );
OGR_F_SetGeometryDirectly( hFeature, hPoly );
if( OGR_L_CreateFeature( hLayer, hFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature in shapefile.\n" );
break;
}
OGR_F_Destroy( hFeature );
CPLFree(fileNameToWrite);
GDALClose( hDS );
}
CPLFree(current_path);
if (nExistingFiles)
{
for( int i = 0; i < nExistingFiles; i++ )
{
CPLFree(existingFilesTab[i]);
}
CPLFree(existingFilesTab);
}
CPLFree(alreadyExistingProjectionRef);
if ( hTargetSRS )
OSRDestroySpatialReference( hTargetSRS );
GDALClose( hTileIndexDS );
GDALDestroyDriverManager();
OGRCleanupAll();
CSLDestroy(argv);
exit( 0 );
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset;
GDALRasterBandH hBand;
int i, iBand;
double adfGeoTransform[6];
GDALDriverH hDriver;
char **papszMetadata;
int bComputeMinMax = FALSE, bSample = FALSE;
int bShowGCPs = TRUE, bShowMetadata = TRUE, bShowRAT=TRUE;
int bStats = FALSE, bApproxStats = TRUE, iMDD;
int bShowColorTable = TRUE, bComputeChecksum = FALSE;
int bReportHistograms = FALSE;
const char *pszFilename = NULL;
char **papszExtraMDDomains = NULL, **papszFileList;
const char *pszProjection = NULL;
OGRCoordinateTransformationH hTransform = NULL;
/* Check that we are running against at least GDAL 1.5 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500)
{
fprintf(stderr, "At least, GDAL >= 1.5.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
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;
}
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i], "-mm") )
bComputeMinMax = TRUE;
else if( EQUAL(argv[i], "-hist") )
bReportHistograms = TRUE;
else if( EQUAL(argv[i], "-stats") )
{
bStats = TRUE;
bApproxStats = FALSE;
}
else if( EQUAL(argv[i], "-approx_stats") )
{
bStats = TRUE;
bApproxStats = TRUE;
}
else if( EQUAL(argv[i], "-sample") )
bSample = TRUE;
else if( EQUAL(argv[i], "-checksum") )
bComputeChecksum = TRUE;
else if( EQUAL(argv[i], "-nogcp") )
bShowGCPs = FALSE;
else if( EQUAL(argv[i], "-nomd") )
bShowMetadata = FALSE;
else if( EQUAL(argv[i], "-norat") )
bShowRAT = FALSE;
else if( EQUAL(argv[i], "-noct") )
bShowColorTable = FALSE;
else if( EQUAL(argv[i], "-mdd") && i < argc-1 )
papszExtraMDDomains = CSLAddString( papszExtraMDDomains,
argv[++i] );
else if( argv[i][0] == '-' )
Usage();
else if( pszFilename == NULL )
pszFilename = argv[i];
else
Usage();
}
if( pszFilename == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open dataset. */
/* -------------------------------------------------------------------- */
hDataset = GDALOpen( pszFilename, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"gdalinfo failed - unable to open '%s'.\n",
pszFilename );
CSLDestroy( argv );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Report general info. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDatasetDriver( hDataset );
printf( "Driver: %s/%s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
papszFileList = GDALGetFileList( hDataset );
if( CSLCount(papszFileList) == 0 )
{
printf( "Files: none associated\n" );
}
else
{
printf( "Files: %s\n", papszFileList[0] );
for( i = 1; papszFileList[i] != NULL; i++ )
printf( " %s\n", papszFileList[i] );
}
CSLDestroy( papszFileList );
printf( "Size is %d, %d\n",
GDALGetRasterXSize( hDataset ),
GDALGetRasterYSize( hDataset ) );
/* -------------------------------------------------------------------- */
/* Report projection. */
/* -------------------------------------------------------------------- */
if( GDALGetProjectionRef( hDataset ) != NULL )
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetProjectionRef( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "Coordinate System is:\n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "Coordinate System is `%s'\n",
GDALGetProjectionRef( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
/* -------------------------------------------------------------------- */
/* Report Geotransform. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
if( adfGeoTransform[2] == 0.0 && adfGeoTransform[4] == 0.0 )
{
printf( "Origin = (%.15f,%.15f)\n",
adfGeoTransform[0], adfGeoTransform[3] );
printf( "Pixel Size = (%.15f,%.15f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
}
else
printf( "GeoTransform =\n"
" %.16g, %.16g, %.16g\n"
" %.16g, %.16g, %.16g\n",
adfGeoTransform[0],
adfGeoTransform[1],
adfGeoTransform[2],
adfGeoTransform[3],
adfGeoTransform[4],
adfGeoTransform[5] );
}
/* -------------------------------------------------------------------- */
/* Report GCPs. */
/* -------------------------------------------------------------------- */
if( bShowGCPs && GDALGetGCPCount( hDataset ) > 0 )
{
if (GDALGetGCPProjection(hDataset) != NULL)
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetGCPProjection( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "GCP Projection = \n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "GCP Projection = %s\n",
GDALGetGCPProjection( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
for( i = 0; i < GDALGetGCPCount(hDataset); i++ )
{
const GDAL_GCP *psGCP;
psGCP = GDALGetGCPs( hDataset ) + i;
printf( "GCP[%3d]: Id=%s, Info=%s\n"
" (%.15g,%.15g) -> (%.15g,%.15g,%.15g)\n",
i, psGCP->pszId, psGCP->pszInfo,
psGCP->dfGCPPixel, psGCP->dfGCPLine,
psGCP->dfGCPX, psGCP->dfGCPY, psGCP->dfGCPZ );
}
}
/* -------------------------------------------------------------------- */
/* Report metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
for( iMDD = 0; bShowMetadata && iMDD < CSLCount(papszExtraMDDomains); iMDD++ )
{
papszMetadata = GDALGetMetadata( hDataset, papszExtraMDDomains[iMDD] );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Metadata (%s):\n", papszExtraMDDomains[iMDD]);
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
}
/* -------------------------------------------------------------------- */
/* Report "IMAGE_STRUCTURE" metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report subdatasets. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, "SUBDATASETS" );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Subdatasets:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report geolocation. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "GEOLOCATION" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Geolocation:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report RPCs */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "RPC" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "RPC Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Setup projected to lat/long transform if appropriate. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
pszProjection = GDALGetProjectionRef(hDataset);
if( pszProjection != NULL && strlen(pszProjection) > 0 )
{
OGRSpatialReferenceH hProj, hLatLong = NULL;
hProj = OSRNewSpatialReference( pszProjection );
if( hProj != NULL )
hLatLong = OSRCloneGeogCS( hProj );
if( hLatLong != NULL )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hTransform = OCTNewCoordinateTransformation( hProj, hLatLong );
CPLPopErrorHandler();
OSRDestroySpatialReference( hLatLong );
}
if( hProj != NULL )
OSRDestroySpatialReference( hProj );
}
/* -------------------------------------------------------------------- */
/* Report corners. */
/* -------------------------------------------------------------------- */
printf( "Corner Coordinates:\n" );
GDALInfoReportCorner( hDataset, hTransform, "Upper Left",
0.0, 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Left",
0.0, GDALGetRasterYSize(hDataset));
GDALInfoReportCorner( hDataset, hTransform, "Upper Right",
GDALGetRasterXSize(hDataset), 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Right",
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
GDALInfoReportCorner( hDataset, hTransform, "Center",
GDALGetRasterXSize(hDataset)/2.0,
GDALGetRasterYSize(hDataset)/2.0 );
if( hTransform != NULL )
{
OCTDestroyCoordinateTransformation( hTransform );
hTransform = NULL;
}
/* ==================================================================== */
/* Loop over bands. */
/* ==================================================================== */
for( iBand = 0; iBand < GDALGetRasterCount( hDataset ); iBand++ )
{
double dfMin, dfMax, adfCMinMax[2], dfNoData;
int bGotMin, bGotMax, bGotNodata, bSuccess;
int nBlockXSize, nBlockYSize, nMaskFlags;
double dfMean, dfStdDev;
GDALColorTableH hTable;
CPLErr eErr;
hBand = GDALGetRasterBand( hDataset, iBand+1 );
if( bSample )
{
float afSample[10000];
int nCount;
nCount = GDALGetRandomRasterSample( hBand, 10000, afSample );
printf( "Got %d samples.\n", nCount );
}
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
printf( "Band %d Block=%dx%d Type=%s, ColorInterp=%s\n", iBand+1,
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(
GDALGetRasterDataType(hBand)),
GDALGetColorInterpretationName(
GDALGetRasterColorInterpretation(hBand)) );
if( GDALGetDescription( hBand ) != NULL
&& strlen(GDALGetDescription( hBand )) > 0 )
printf( " Description = %s\n", GDALGetDescription(hBand) );
dfMin = GDALGetRasterMinimum( hBand, &bGotMin );
dfMax = GDALGetRasterMaximum( hBand, &bGotMax );
if( bGotMin || bGotMax || bComputeMinMax )
{
printf( " " );
if( bGotMin )
printf( "Min=%.3f ", dfMin );
if( bGotMax )
printf( "Max=%.3f ", dfMax );
if( bComputeMinMax )
{
CPLErrorReset();
GDALComputeRasterMinMax( hBand, FALSE, adfCMinMax );
if (CPLGetLastErrorType() == CE_None)
{
printf( " Computed Min/Max=%.3f,%.3f",
adfCMinMax[0], adfCMinMax[1] );
}
}
printf( "\n" );
}
eErr = GDALGetRasterStatistics( hBand, bApproxStats, bStats,
&dfMin, &dfMax, &dfMean, &dfStdDev );
if( eErr == CE_None )
{
printf( " Minimum=%.3f, Maximum=%.3f, Mean=%.3f, StdDev=%.3f\n",
dfMin, dfMax, dfMean, dfStdDev );
}
if( bReportHistograms )
{
int nBucketCount, *panHistogram = NULL;
eErr = GDALGetDefaultHistogram( hBand, &dfMin, &dfMax,
&nBucketCount, &panHistogram,
TRUE, GDALTermProgress, NULL );
if( eErr == CE_None )
{
int iBucket;
printf( " %d buckets from %g to %g:\n ",
nBucketCount, dfMin, dfMax );
for( iBucket = 0; iBucket < nBucketCount; iBucket++ )
printf( "%d ", panHistogram[iBucket] );
printf( "\n" );
CPLFree( panHistogram );
}
}
if ( bComputeChecksum)
{
printf( " Checksum=%d\n",
GDALChecksumImage(hBand, 0, 0,
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset)));
}
dfNoData = GDALGetRasterNoDataValue( hBand, &bGotNodata );
if( bGotNodata )
{
printf( " NoData Value=%.18g\n", dfNoData );
}
if( GDALGetOverviewCount(hBand) > 0 )
{
int iOverview;
printf( " Overviews: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
const char *pszResampling = NULL;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
pszResampling =
GDALGetMetadataItem( hOverview, "RESAMPLING", "" );
if( pszResampling != NULL
&& EQUALN(pszResampling,"AVERAGE_BIT2",12) )
printf( "*" );
}
printf( "\n" );
if ( bComputeChecksum)
{
printf( " Overviews checksum: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
printf( "%d",
GDALChecksumImage(hOverview, 0, 0,
GDALGetRasterBandXSize(hOverview),
GDALGetRasterBandYSize(hOverview)));
}
printf( "\n" );
}
}
if( GDALHasArbitraryOverviews( hBand ) )
{
printf( " Overviews: arbitrary\n" );
}
nMaskFlags = GDALGetMaskFlags( hBand );
if( (nMaskFlags & (GMF_NODATA|GMF_ALL_VALID)) == 0 )
{
GDALRasterBandH hMaskBand = GDALGetMaskBand(hBand) ;
printf( " Mask Flags: " );
if( nMaskFlags & GMF_PER_DATASET )
printf( "PER_DATASET " );
if( nMaskFlags & GMF_ALPHA )
printf( "ALPHA " );
if( nMaskFlags & GMF_NODATA )
printf( "NODATA " );
if( nMaskFlags & GMF_ALL_VALID )
printf( "ALL_VALID " );
printf( "\n" );
if( hMaskBand != NULL &&
GDALGetOverviewCount(hMaskBand) > 0 )
{
int iOverview;
printf( " Overviews of mask band: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hMaskBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hMaskBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
}
printf( "\n" );
}
}
if( strlen(GDALGetRasterUnitType(hBand)) > 0 )
{
printf( " Unit Type: %s\n", GDALGetRasterUnitType(hBand) );
}
if( GDALGetRasterCategoryNames(hBand) != NULL )
{
char **papszCategories = GDALGetRasterCategoryNames(hBand);
int i;
printf( " Categories:\n" );
for( i = 0; papszCategories[i] != NULL; i++ )
printf( " %3d: %s\n", i, papszCategories[i] );
}
if( GDALGetRasterScale( hBand, &bSuccess ) != 1.0
|| GDALGetRasterOffset( hBand, &bSuccess ) != 0.0 )
printf( " Offset: %.15g, Scale:%.15g\n",
GDALGetRasterOffset( hBand, &bSuccess ),
GDALGetRasterScale( hBand, &bSuccess ) );
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
if( GDALGetRasterColorInterpretation(hBand) == GCI_PaletteIndex
&& (hTable = GDALGetRasterColorTable( hBand )) != NULL )
{
int i;
printf( " Color Table (%s with %d entries)\n",
GDALGetPaletteInterpretationName(
GDALGetPaletteInterpretation( hTable )),
GDALGetColorEntryCount( hTable ) );
if (bShowColorTable)
{
for( i = 0; i < GDALGetColorEntryCount( hTable ); i++ )
{
GDALColorEntry sEntry;
GDALGetColorEntryAsRGB( hTable, i, &sEntry );
printf( " %3d: %d,%d,%d,%d\n",
i,
sEntry.c1,
sEntry.c2,
sEntry.c3,
sEntry.c4 );
}
}
}
if( bShowRAT && GDALGetDefaultRAT( hBand ) != NULL )
{
GDALRasterAttributeTableH hRAT = GDALGetDefaultRAT( hBand );
GDALRATDumpReadable( hRAT, NULL );
}
}
GDALClose( hDataset );
CSLDestroy( papszExtraMDDomains );
CSLDestroy( argv );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
CPLCleanupTLS();
exit( 0 );
}
// ===========================================================================
// Hauptprogramm
// ===========================================================================
int main(int argc, char* argv[])
{
// Standart Fehler Template
char * error_tmpl =
"USAGE: %s GEOTIFF [-d] [-v] [-s \"|\"] -p geo_x geo_y [-p geo_x geo_y]\n";
// Fehler-Template "nur einmal vewenden"
char * error_tmpl_single = "Option '%s' nur einmal am Anfang verwenden!";
//Ausgabe Hilfe
if ( argc < 3) {
fprintf(stderr, error_tmpl,argv[0]);
exit(1);
}
// Dateiname der Geotiff-Datei
char * pszFname = argv[1];
// Parametercounter
int i=1;
// Ausgabeseparator und Separator wurde gesetzt
char * pszSep = " "; int hasSep = 0;
// Debug Modus
int DEBUG=0; int hasDebug = 0;
// Aktuelles CLI-Tag
char * cur_arg = NULL;
// CLI-Tags fuer X und Y parsen
char * prm_x = NULL;
char * prm_y = NULL;
// X und Y parsen Koordinate
double x = 0;
double y = 0;
// c und r - Spalte und Zeile im Bild
long c = 0;
long r = 0;
// Datensatz Geotiff
GDALDatasetH hDataset;
double trfm[6];
// Alle GDAL Treiber registrieren
GDALAllRegister();
// Greetings
printf("# TOOL: GEOTIFF WORLD TO PIXEL TRANSFORM ---------------------------\n");
// Geotiff oeffnen
printf("# FILE: %s\n",pszFname);
hDataset = GDALOpen( pszFname, GA_ReadOnly );
// Geotiff Fehler abfangen
if( hDataset == NULL ) {
handleError("Datensatz %s kann nicht geoeffnet werden!\n",
pszFname, 10, hDataset);
}
// Transformation aus dem Geotiff holen und ausgeben
if( GDALGetGeoTransform( hDataset, trfm ) == CE_None ) {
printf("# TRANSFORM: \n");
printf("# X = %.6f + %.6f * COL + %.6f * ROW\n",
trfm[0], trfm[1], trfm[2] );
printf("# Y = %.6f + %.6f * COL + %.6f * ROW\n# EOF:\n",
trfm[3], trfm[4], trfm[5] );
} else {
handleError("Keine Transformation im TIFF vorhanden!\n","",10,hDataset);
}
// Header drucken
printf("# HEAD: WORLD.X WORLD.Y IMAGE.COL IMAGE.ROW ERROR.X ERROR.Y -------\n");
// Parameter Einlesen
while (i<argc-1) {
// Aktuelles Tag lesen
cur_arg = argv[++i];
if (DEBUG)
printf("# ARG.NUM: %d ARG.VAL: %s ARG.PRM %s\n",
i, cur_arg, argv[i+1] );
// Vermeiden dass Debug 2x gelesen wird
if ( strncmp(cur_arg,"-d",3)==0 && hasDebug ) {
handleError(error_tmpl_single,"-d", 11, hDataset);
}
// Debug setzen
else if ( strncmp(cur_arg,"-d",3)==0 && !hasDebug ) {
hasDebug=1; DEBUG=1;
// Vermeiden dass der Separator 2x gelesen wird
} else if ( strncmp(cur_arg,"-s",3)==0 && hasSep ) {
handleError(error_tmpl_single, "-s", 11,hDataset);
}
// Einlesen des Separators -s
else if ( strncmp(cur_arg,"-s",3)==0 && !hasSep ) {
if ( i < argc) {
pszSep = argv[i+1];
} else {
handleError(error_tmpl,argv[0],12, hDataset);
}
i++; hasSep=1;
} // Ende Einlesen des Separators
else
//Einlesen von Punkten
if ( strncmp(cur_arg,"-p",3)==0 ) {
// Kommandozeile hat genug Argumente ?
if ( i+2 < argc) {
prm_x = argv[i+1];
prm_y = argv[i+2];
} else {
handleError(error_tmpl,argv[0],10, hDataset);
}
// X-Koordinate scannen
if (! sscanf(prm_x,"%lf",&x) ) {
handleError("Ungueltiger numerischer Wert fuer X: %s\n!",
prm_x,1000+i-1, hDataset);
}
// Y-Koordinate scannen
if (! sscanf(prm_y,"%lf",&y) ) {
handleError("Ungueltiger numerischer Wert fuer Y: %s\n!",
prm_y,1000+i, hDataset);
}
// Kontrollausgabe
if (DEBUG) printf("# PARM.POINT %s %s : DATA.POINT %f %f\n",
prm_x, prm_y, x, y);
// Berechnung durchfuehren
int res = calcWorldToPixel(trfm,x,y,&c,&r);
if (res) {
double nx=0.0,ny=0.0;
// Variablen absoluter Fehler
calcPixelToWorld(trfm,c,r,&nx,&ny);
// Kontrollausgabe
if (DEBUG)
printf("# X:%f Y:%f C:%ld R:%ld ERRX:%f ERRY:%f\n",
x, y, c, r, x-nx, y-ny);
//Datenausgabe mit Separator
printf("%f%s%f%s%ld%s%ld%s%f%s%f\n",
x,pszSep,y,pszSep,c,pszSep,r,pszSep,x-nx,pszSep,y-ny);
}
// Parameterzaehler erhoehen
i+=2;
} // EOF Option -p
// Unbekannte Option
else {
handleError("Falscher Parameter %s\n",cur_arg,1000+i, hDataset);
}
}
// Augabeende signailsieren
printf("# EOF: ------------------------------------------------------------\n");
// Handles schliessen
finalize(hDataset);
// OK alles fine
exit(0);
}
void doTif2Con(char fileName[], int headerFormat, int BandNumber, char separator, char SHPMaskFile[])
{
bool flMask = false;
OGRDataSourceH poDS = NULL;
OGRSFDriverH poDriver = NULL;
if(strlen(SHPMaskFile)>0)
{
flMask = true;
poDS = OGROpen(SHPMaskFile, FALSE, &poDriver);
}
if(flMask && (poDS == NULL))
{
fputs("\nError open mask file!!!\n\n", stderr);
return ;
}
GDALDatasetH pDataset;
GDALRasterBandH pBand;
pDataset = GDALOpen( fileName, GA_ReadOnly );
if(pDataset!=NULL)
{
int bands = 0;
if(0 == BandNumber) bands = GDALGetRasterCount( pDataset );
else bands = 1;
int cols = GDALGetRasterXSize(pDataset);
int rows = GDALGetRasterYSize(pDataset);
double adfGeoTransform[6];
float xOrigin = 0;
float yOrigin = 0;
float pixelWidth = 0;
float pixelHeight = 0;
if( GDALGetGeoTransform( pDataset, adfGeoTransform ) == CE_None )
{
xOrigin = adfGeoTransform[0];
yOrigin = adfGeoTransform[3];
pixelWidth = adfGeoTransform[1];
pixelHeight = adfGeoTransform[5];
}
float *** pdata = NULL;
pdata = new float**[bands];
for(int i=0; i<bands; i++) pdata[i] = new float*[rows];
for(int i=0; i<bands; i++) for(int j=0; j<rows; j++) pdata[i][j] = new float[cols];
for(int i=0; i<bands; i++) for(int j=0; j<rows; j++) for(int k=0; k<cols; k++) pdata[i][j][k] = 0;
void *pbuf = NULL;
pBand = GDALGetRasterBand(pDataset, 1);
pbuf = CUtils::mallocData(pBand, pbuf, cols);
printHeader(headerFormat, BandNumber, bands, rows, cols, separator);
if(0 == BandNumber)
{
for(int i=1; i<=bands; i++)
{
pBand = GDALGetRasterBand(pDataset, i);
for(int j=0; j<rows; j++)
{
CUtils::getRasterLine(pBand, j, cols, pbuf);
for(int k=0; k<cols; k++) pdata[i-1][j][k] = CUtils::getDataAsFloat(pBand, pbuf, k);
}
}
}
else
{
pBand = GDALGetRasterBand(pDataset, BandNumber);
for(int j=0; j<rows; j++)
{
CUtils::getRasterLine(pBand, j, cols, pbuf);
for(int k=0; k<cols; k++) pdata[0][j][k] = CUtils::getDataAsFloat(pBand, pbuf, k);
}
}
CPLFree(pbuf);
GDALClose(pDataset);
printData((const float ***) pdata, headerFormat, bands, rows, cols,
xOrigin, yOrigin, pixelWidth, pixelHeight, separator, poDS);
if(poDS != NULL) OGR_DS_Destroy(poDS);
for(int i=0; i<bands; i++) for(int j=0; j<rows; j++) delete [] pdata[i][j];
for(int i=0; i<bands; i++) delete [] pdata[i];
delete [] pdata;
pdata = NULL;
fputs("\nProcessing COMPLETE.\n\n", stderr);
}
else
fputs("\nError open input image!!!\n\n", stderr);
}
int QgsRasterCalculator::processCalculation( QProgressDialog* p )
{
//prepare search string / tree
QString errorString;
QgsRasterCalcNode* calcNode = QgsRasterCalcNode::parseRasterCalcString( mFormulaString, errorString );
if ( !calcNode )
{
//error
}
double targetGeoTransform[6];
outputGeoTransform( targetGeoTransform );
//open all input rasters for reading
QMap< QString, GDALRasterBandH > mInputRasterBands; //raster references and corresponding scanline data
QMap< QString, QgsRasterMatrix* > inputScanLineData; //stores raster references and corresponding scanline data
QVector< GDALDatasetH > mInputDatasets; //raster references and corresponding dataset
QVector<QgsRasterCalculatorEntry>::const_iterator it = mRasterEntries.constBegin();
for ( ; it != mRasterEntries.constEnd(); ++it )
{
if ( !it->raster ) // no raster layer in entry
{
return 2;
}
GDALDatasetH inputDataset = GDALOpen( it->raster->source().toLocal8Bit().data(), GA_ReadOnly );
if ( inputDataset == NULL )
{
return 2;
}
//check if the input dataset is south up or rotated. If yes, use GDALAutoCreateWarpedVRT to create a north up raster
double inputGeoTransform[6];
if ( GDALGetGeoTransform( inputDataset, inputGeoTransform ) == CE_None
&& ( inputGeoTransform[1] < 0.0
|| inputGeoTransform[2] != 0.0
|| inputGeoTransform[4] != 0.0
|| inputGeoTransform[5] > 0.0 ) )
{
GDALDatasetH vDataset = GDALAutoCreateWarpedVRT( inputDataset, NULL, NULL, GRA_NearestNeighbour, 0.2, NULL );
mInputDatasets.push_back( vDataset );
mInputDatasets.push_back( inputDataset );
inputDataset = vDataset;
}
else
{
mInputDatasets.push_back( inputDataset );
}
GDALRasterBandH inputRasterBand = GDALGetRasterBand( inputDataset, it->bandNumber );
if ( inputRasterBand == NULL )
{
return 2;
}
int nodataSuccess;
double nodataValue = GDALGetRasterNoDataValue( inputRasterBand, &nodataSuccess );
mInputRasterBands.insert( it->ref, inputRasterBand );
inputScanLineData.insert( it->ref, new QgsRasterMatrix( mNumOutputColumns, 1, new float[mNumOutputColumns], nodataValue ) );
}
//open output dataset for writing
GDALDriverH outputDriver = openOutputDriver();
if ( outputDriver == NULL )
{
return 1;
}
GDALDatasetH outputDataset = openOutputFile( outputDriver );
GDALRasterBandH outputRasterBand = GDALGetRasterBand( outputDataset, 1 );
float outputNodataValue = -FLT_MAX;
GDALSetRasterNoDataValue( outputRasterBand, outputNodataValue );
float* resultScanLine = ( float * ) CPLMalloc( sizeof( float ) * mNumOutputColumns );
if ( p )
{
p->setMaximum( mNumOutputRows );
}
QgsRasterMatrix resultMatrix;
//read / write line by line
for ( int i = 0; i < mNumOutputRows; ++i )
{
if ( p )
{
p->setValue( i );
}
if ( p && p->wasCanceled() )
{
break;
}
//fill buffers
QMap< QString, QgsRasterMatrix* >::iterator bufferIt = inputScanLineData.begin();
for ( ; bufferIt != inputScanLineData.end(); ++bufferIt )
{
double sourceTransformation[6];
GDALRasterBandH sourceRasterBand = mInputRasterBands[bufferIt.key()];
GDALGetGeoTransform( GDALGetBandDataset( sourceRasterBand ), sourceTransformation );
//the function readRasterPart calls GDALRasterIO (and ev. does some conversion if raster transformations are not the same)
readRasterPart( targetGeoTransform, 0, i, mNumOutputColumns, 1, sourceTransformation, sourceRasterBand, bufferIt.value()->data() );
}
if ( calcNode->calculate( inputScanLineData, resultMatrix ) )
{
bool resultIsNumber = resultMatrix.isNumber();
float* calcData;
if ( resultIsNumber ) //scalar result. Insert number for every pixel
{
calcData = new float[mNumOutputColumns];
for ( int j = 0; j < mNumOutputColumns; ++j )
{
calcData[j] = resultMatrix.number();
}
}
else //result is real matrix
{
calcData = resultMatrix.data();
}
//replace all matrix nodata values with output nodatas
for ( int j = 0; j < mNumOutputColumns; ++j )
{
if ( calcData[j] == resultMatrix.nodataValue() )
{
calcData[j] = outputNodataValue;
}
}
//write scanline to the dataset
if ( GDALRasterIO( outputRasterBand, GF_Write, 0, i, mNumOutputColumns, 1, calcData, mNumOutputColumns, 1, GDT_Float32, 0, 0 ) != CE_None )
{
qWarning( "RasterIO error!" );
}
if ( resultIsNumber )
{
delete[] calcData;
}
}
}
if ( p )
{
p->setValue( mNumOutputRows );
}
//close datasets and release memory
delete calcNode;
QMap< QString, QgsRasterMatrix* >::iterator bufferIt = inputScanLineData.begin();
for ( ; bufferIt != inputScanLineData.end(); ++bufferIt )
{
delete bufferIt.value();
}
inputScanLineData.clear();
QVector< GDALDatasetH >::iterator datasetIt = mInputDatasets.begin();
for ( ; datasetIt != mInputDatasets.end(); ++ datasetIt )
{
GDALClose( *datasetIt );
}
if ( p && p->wasCanceled() )
{
//delete the dataset without closing (because it is faster)
GDALDeleteDataset( outputDriver, mOutputFile.toLocal8Bit().data() );
return 3;
}
GDALClose( outputDataset );
CPLFree( resultScanLine );
return 0;
}
static void DumpBand( GDALDatasetH hBaseDS, GDALRasterBandH hSrcOver,
const char *pszName )
{
/* -------------------------------------------------------------------- */
/* Get base ds info. */
/* -------------------------------------------------------------------- */
double adfGeoTransform[6];
bool bHaveGT = GDALGetGeoTransform( hBaseDS, adfGeoTransform ) == CE_None;
int nOrigXSize = GDALGetRasterXSize( hBaseDS );
int nOrigYSize = GDALGetRasterYSize( hBaseDS );
/* -------------------------------------------------------------------- */
/* Create matching output file. */
/* -------------------------------------------------------------------- */
int nXSize = GDALGetRasterBandXSize( hSrcOver );
int nYSize = GDALGetRasterBandYSize( hSrcOver );
GDALDataType eDT = GDALGetRasterDataType( hSrcOver );
GDALDriverH hDriver = GDALGetDriverByName( "GTiff" );
GDALDatasetH hDstDS = GDALCreate( hDriver, pszName, nXSize, nYSize,
1, eDT, NULL );
if( hDstDS == NULL )
exit( 1 );
/* -------------------------------------------------------------------- */
/* Apply corresponding georeferencing, scaled to size. */
/* -------------------------------------------------------------------- */
if( bHaveGT )
{
double adfOvGeoTransform[6];
memcpy( adfOvGeoTransform, adfGeoTransform,
sizeof(double) * 6 );
adfOvGeoTransform[1] *= (nOrigXSize / (double) nXSize);
adfOvGeoTransform[2] *= (nOrigXSize / (double) nXSize);
adfOvGeoTransform[4] *= (nOrigYSize / (double) nYSize);
adfOvGeoTransform[5] *= (nOrigYSize / (double) nYSize);
GDALSetGeoTransform( hDstDS, adfOvGeoTransform );
GDALSetProjection( hDstDS, GDALGetProjectionRef( hBaseDS ) );
}
/* -------------------------------------------------------------------- */
/* Copy over all the image data. */
/* -------------------------------------------------------------------- */
void *pData = CPLMalloc(64 * nXSize);
for( int iLine = 0; iLine < nYSize; iLine++ )
{
GDALRasterIO( hSrcOver, GF_Read, 0, iLine, nXSize, 1,
pData, nXSize, 1, eDT, 0, 0 );
GDALRasterIO( GDALGetRasterBand( hDstDS, 1 ), GF_Write,
0, iLine, nXSize, 1,
pData, nXSize, 1, eDT, 0, 0 );
}
CPLFree( pData );
GDALClose( hDstDS );
}
int main(int argc, char *argv[])
{
GDALDatasetH hDataset = NULL;
OGRDataSourceH hDS = NULL;
OGRSFDriverH *pahDriver = NULL;
OGRLayerH hLR = NULL;
OGREnvelope hEnv;
double adfGeoTransform[6];
int columns, lines;
double minx, miny, maxx, maxy, x, y, z;
register int i;
FILE *fin=NULL;
if(argc != 2)
{
printf("Usage: geo_extents <input file>\n");
return 1;
}
GDALAllRegister();
OGRRegisterAll();
char *egsa = "PROJCS[\"GGRS87 / Greek Grid\",GEOGCS[\"GGRS87\",DATUM[\"Greek_Geodetic_Reference_System_1987\",SPHEROID[\"GRS 1980\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"7019\"]],TOWGS84[-199.87,74.79,246.62,0,0,0,0],AUTHORITY[\"EPSG\",\"6121\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4121\"]],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",24],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],AUTHORITY[\"EPSG\",\"2100\"],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH]]";
char *wgs = "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]]";
OGRSpatialReferenceH oSourceSRS;
OGRSpatialReferenceH oTargetSRS;
oSourceSRS = OSRNewSpatialReference(NULL);
oTargetSRS = OSRNewSpatialReference(NULL);
OSRImportFromWkt(oSourceSRS, &egsa);
OSRImportFromWkt(oTargetSRS, &wgs);
OGRCoordinateTransformationH poCT;
poCT = OCTNewCoordinateTransformation(oSourceSRS, oTargetSRS);
hDataset = GDALOpen(argv[1], GA_ReadOnly);
if(hDataset != NULL)//It is raster
{
columns = GDALGetRasterXSize(hDataset);
lines = GDALGetRasterYSize(hDataset);
if(GDALGetGeoTransform(hDataset, adfGeoTransform) == CE_None)
{
minx = (adfGeoTransform[0] - (adfGeoTransform[1] / 2));
maxy = (adfGeoTransform[3] - (adfGeoTransform[5] / 2));
miny = (maxy + ((lines + 1) * adfGeoTransform[5]));
maxx = (minx + (adfGeoTransform[1] * (columns + 1)));
OCTTransform(poCT, 1, &minx, &miny, 0);
OCTTransform(poCT, 1, &maxx, &maxy, 0);
printf("BoundingBox: %f %f %f %f\n",minx ,miny, maxx, maxy);
GDALClose (hDataset);
}
else
{
printf("Failure: No Georeference info found for this raster file\n");
return 0;
}
}
else//Try if it is vector
{
hDS = OGROpen( argv[1], FALSE , pahDriver );
if( hDS == NULL )//Not vector
{
//Parse for DTM file
fin=fopen(argv[1],"r");
fseek(fin,0L,SEEK_SET);
minx=50000000.0;
miny=50000000.0;
maxx=0.0;
maxy=0.0;
while(!feof(fin))
{
fscanf(fin,"%lf,%lf,%lf\n",&x,&y,&z);
if(ferror(fin))//input error
{
printf("Failure: Unsupported file type\n");
return 0;
}
if(x>maxx) maxx=x;
if(y>maxy) maxy=y;
if(x<minx) minx=x;
if(y<miny) miny=y;
}
if(minx==50000000.0 || miny==50000000.0)
{
printf("Failure: Unsupported file type\n");
return 0;
}
if(maxx==0 || maxy==0)
{
printf("Failure: Unsupported file type\n");
return 0;
}
if(minx==maxx)
{
minx-=1;
maxx+=1;
}
if(miny==maxy)
{
miny-=1;
maxy+=1;
}
//DTM file
OCTTransform(poCT, 1, &minx, &miny, 0);
OCTTransform(poCT, 1, &maxx, &maxy, 0);
printf("BoundingBox: %f %f %f %f\n",minx ,miny, maxx, maxy);
return 0;
}
//It is vector
for(i=0; i< OGR_DS_GetLayerCount (hDS); i++)
{
hLR = OGR_DS_GetLayer(hDS, i);
if(OGR_L_GetExtent (hLR, &hEnv, FALSE) == OGRERR_NONE)
{
minx = hEnv.MinX;
miny = hEnv.MinY;
maxx = hEnv.MaxX;
maxy = hEnv.MaxY;
OCTTransform(poCT, 1, &minx, &miny, 0);
OCTTransform(poCT, 1, &maxx, &maxy, 0);
printf("BoundingBox: %f %f %f %f\n",minx ,miny, maxx, maxy);
}
}
OGRReleaseDataSource( hDS );
}
return 0;
}
static int
GDALInfoReportCorner( GDALDatasetH hDataset,
const char * corner_name,
double x, double y )
{
double dfGeoX, dfGeoY;
const char *pszProjection;
double adfGeoTransform[6];
OGRCoordinateTransformationH hTransform = NULL;
printf( "%-11s ", corner_name );
/* -------------------------------------------------------------------- */
/* Transform the point into georeferenced coordinates. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
pszProjection = GDALGetProjectionRef(hDataset);
dfGeoX = adfGeoTransform[0] + adfGeoTransform[1] * x
+ adfGeoTransform[2] * y;
dfGeoY = adfGeoTransform[3] + adfGeoTransform[4] * x
+ adfGeoTransform[5] * y;
}
else
{
printf( "(%7.1f,%7.1f)\n", x, y );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Report the georeferenced coordinates. */
/* -------------------------------------------------------------------- */
if( fabs(dfGeoX) < 181 && fabs(dfGeoY) < 91 )
{
printf( "(%12.7f,%12.7f) ", dfGeoX, dfGeoY );
}
else
{
printf( "(%12.3f,%12.3f) ", dfGeoX, dfGeoY );
}
/* -------------------------------------------------------------------- */
/* Setup transformation to lat/long. */
/* -------------------------------------------------------------------- */
if( pszProjection != NULL && strlen(pszProjection) > 0 )
{
OGRSpatialReferenceH hProj, hLatLong = NULL;
hProj = OSRNewSpatialReference( pszProjection );
if( hProj != NULL )
hLatLong = OSRCloneGeogCS( hProj );
if( hLatLong != NULL )
{
hTransform = OCTNewCoordinateTransformation( hProj, hLatLong );
OSRDestroySpatialReference( hLatLong );
}
if( hProj != NULL )
OSRDestroySpatialReference( hProj );
}
/* -------------------------------------------------------------------- */
/* Transform to latlong and report. */
/* -------------------------------------------------------------------- */
if( hTransform != NULL
&& OCTTransform(hTransform,1,&dfGeoX,&dfGeoY,NULL) )
{
printf( "(%s,", GDALDecToDMS( dfGeoX, "Long", 2 ) );
printf( "%s)", GDALDecToDMS( dfGeoY, "Lat", 2 ) );
}
if( hTransform != NULL )
OCTDestroyCoordinateTransformation( hTransform );
printf( "\n" );
return TRUE;
}
SVImage init(int xLow, int xHigh, int yLow, int yHigh, const char *filepath){
GDALDatasetH hDataset;
// Register drivers
GDALAllRegister();
// open the given file as Read Only
hDataset = GDALOpen(filepath, GA_ReadOnly );
// if opening failed
if( hDataset == NULL )
{
fprintf(stderr, "Unable to open file.");
exit(EXIT_FAILURE);
}
/* Declare some variables to be used later */
int *xBlockSize = malloc(sizeof(int));
int *yBlockSize = malloc(sizeof(int));
int xOutputSize;
int yOutputSize;
int numXBlocks;
int numYBlocks;
int origWidth;
int origHeight;
int origBandCount;
/*Get some information on the image*/
origWidth = GDALGetRasterXSize( hDataset ); // Get raster pixel width
origHeight = GDALGetRasterYSize( hDataset ); // Get raster pixel height
origBandCount = GDALGetRasterCount( hDataset ); // Get number of raster bands in the image
GDALRasterBandH hBand = GDALGetRasterBand( hDataset, 1 ); // Get raster band with id 1
GDALGetBlockSize( hBand, xBlockSize, yBlockSize); // Fetch the block size for this band
/*TODO make sure scale is set somewhere*/
/*Store some information on what the output should have*/
xOutputSize = ((*xBlockSize) / scale); // get the new x block size
yOutputSize = ((*yBlockSize) / scale); // get the new y block size
numXBlocks = origWidth/(*xBlockSize); // Get x block count
numYBlocks = origHeight/(*yBlockSize); // Get y block count
int bandCount;
if (origBandCount >= 3) // Just a guess, limit bands to RGB?
{
bandCount = 3;
}
else // Otherwise image is probably grayscale, one band?
{
bandCount = 1;
}
/*TODO edit this or remove it since we aren't using focusing on openGL*/
/*
*int format;
*if (bandCount == 3)
*{
* format = GL_RGBA;
*}
*else
*{
* format = GL_LUMINANCE_ALPHA;
*}
*/
int usedBlocks;
int usedXBlocks;
int usedYBlocks;
/*
*This is odd, xHigh and yHigh are
*passed as parameters but changed here
*TODO see if we can remove parameters or just use this
*/
if ((xHigh < 0) || (xHigh < xLow))
{
xHigh = numXBlocks;
}
if ((yHigh < 0)|| (yHigh < yLow))
{
yHigh = numYBlocks;
}
usedXBlocks = (xHigh - xLow); // This is probably the part of the image that should be displayed on screen
usedYBlocks = (yHigh - yLow); // Y part on screen?
usedBlocks = (usedXBlocks * usedYBlocks); // Total blocks on screen?
SVImage svip =
{
.Width = xOutputSize*usedXBlocks,
.Height = yOutputSize*usedYBlocks,
.BytesPerPixel = 1,
.Data = (CPLMalloc((sizeof(char) * xOutputSize * yOutputSize * usedBlocks * (bandCount+1))))
// Data = xOutputSize * yOutputSize = pixels/block * usedBlocks = totalpixels
};
free(xBlockSize);
free(yBlockSize);
return svip;
}
/*
Uses stochastic sampling to fill the data section of an SVImage struct.
*/
void sample(params *in) //TODO handle 32 bit representations
{
/*Set variables from the params struct*/
SVImage* out = in->target;
int xLow = in->xLow;
int xHigh = in->xHigh;
int yLow = in->yLow;
int yHigh = in->yHigh;
const char *file = in->file;
GDALDatasetH hDataset;
GDALRasterBandH hBand;
/*Register drivers*/
GDALAllRegister();
//TODO Dynamically calculate sample count?
int avgSampleCount = 25;
//Open GDAL File
//------------------------------------------------
hDataset = GDALOpen(file, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf(stderr, "Unable to open file.\n");
exit(EXIT_FAILURE);
}
//GDAL FILE INFO
//---------------------------------------------
GDALDriverH hDriver;
hDriver = GDALGetDatasetDriver( hDataset ); // Get driver for this file
double adfGeoTransform[6];
//Print GDAL Driver
printf( "Driver: %s/%s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
//Get original raster size
int origWidth = GDALGetRasterXSize( hDataset );
int origHeight = GDALGetRasterYSize( hDataset );
printf("width = %i\n", origWidth);
printf("height = %i\n", origHeight);
//Get Raster band count
int origBandCount = GDALGetRasterCount( hDataset );
printf("origBandCount = %i\n", origBandCount);
int bandCount;
if (origBandCount >= 3)
{
bandCount = 3;
}
else
{
bandCount = 1;
}
//Target output Width and Height
float stride = (scale * scale);
stride /= (avgSampleCount);
//the greatest number of pixels that can be skipped in a single iteration
int maxStride = ((int)stride) + 1;
//Load band 1
hBand = GDALGetRasterBand( hDataset, 1 );
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
printf( "Pixel Size = (%.6f,%.6f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
}
else
{
fprintf(stderr, "Failed to get pixel size\n");
}
int* xBlockSize = malloc(sizeof(int));
int* yBlockSize = malloc(sizeof(int));
//get block size
GDALGetBlockSize( hBand, xBlockSize, yBlockSize);
printf("xBlockSize = %i\n", *xBlockSize);
printf("yBlockSize = %i\n", *yBlockSize);
int xOutputSize = ((*xBlockSize) / scale);
int yOutputSize = ((*yBlockSize) / scale);
printf("X Output Size%i\n", xOutputSize);
int numXBlocks = origWidth/(*xBlockSize);
int numYBlocks = origHeight/(*yBlockSize);
printf("numXBlocks = %i\n", numXBlocks);
printf("numYBlocks = %i\n", numYBlocks);
if ((xHigh < 0) || (xHigh < xLow))
{
xHigh = numXBlocks;
}
if ((yHigh < 0)|| (yHigh < yLow))
{
yHigh = numYBlocks;
}
int usedXBlocks = (xHigh - xLow);
int usedYBlocks = (yHigh - yLow);
int usedBlocks = (usedXBlocks * usedYBlocks);
unsigned char* output = CPLMalloc((sizeof(char) * xOutputSize* yOutputSize *usedBlocks * (bandCount+1))); // Allocate space for the output
float* vals = calloc( xOutputSize* yOutputSize *usedBlocks * (bandCount+1), sizeof(float)); //stores pixel values
unsigned long* valsPerIndex = calloc( xOutputSize* yOutputSize * usedBlocks * (bandCount+1), sizeof(unsigned long)); //stores number of pixel values per output index
unsigned long rseed = 0;
unsigned long rowIndex = 0; //the index of the row to which we will output our value
unsigned long colIndex = 0; //the index of the column to which we will output our value
unsigned long outIndex = 0;
unsigned long sampledIndex = 0; //One dimensional representation of column/row index
//iterate through each pixel, jump to the last pixel we sampled.
long long i = 0;
int outputXOffset = 0;
int outputYOffset = 0;
int outputIndexOffset = 0;
if (GDALGetRasterDataType(hBand) == GDT_Int16)
{
short* data = (short *) CPLMalloc(sizeof(unsigned short) * (*xBlockSize)*(*yBlockSize)); //TODO: GDAL Raster can be 16 bit pixel representation
int band;
for (band = 1; band <= bandCount; band++){
hBand = GDALGetRasterBand( hDataset, band );
int yBlock, xBlock;
for(yBlock = yLow; yBlock < yHigh; yBlock++){
for(xBlock = xLow; xBlock < xHigh; xBlock++){
if(GDALReadBlock(hBand,xBlock,yBlock, data) != CE_None)
{
fprintf(stderr, "Read block failed\n");
exit(EXIT_FAILURE);
}
for(i = 0 ; i < ((*xBlockSize)*(*yBlockSize)-1) ; i += rseed){
rseed = (214013 * rseed + 2531011); // Magic numbers.
rseed %= maxStride;
sampledIndex = i;
i = (maxStride ==1) ? (i+1) : i;
rowIndex = (sampledIndex/(xOutputSize*scale* scale)) + ((yBlock - yLow)* yOutputSize);
colIndex = ((sampledIndex % (xOutputSize * scale))/scale) + ((xBlock - xLow) * xOutputSize);
outIndex = ((rowIndex * (xOutputSize * usedXBlocks ) + colIndex) * (bandCount+1) ) + (band -1);
vals[outIndex] += (*(data + sampledIndex));
vals[outIndex] += 118.450588 + ((*(data + sampledIndex))/128);
if (vals[outIndex]/valsPerIndex[outIndex] < 0) {
vals[outIndex] =0;
}else if (vals[outIndex]/valsPerIndex[outIndex] > 255){
vals[outIndex] = 255;
}
}
}
}
}
}
else
{
unsigned char* data = (unsigned char *) CPLMalloc(sizeof(char) * (*xBlockSize)*(*yBlockSize));
int band;
for (band = 1; band <= bandCount; band++)
{
hBand = GDALGetRasterBand( hDataset, band );
int yBlock, xBlock;
outputYOffset = 0;
for(yBlock = yLow; yBlock < yHigh; yBlock++){
outputYOffset = ((yBlock - yLow) * yOutputSize * xOutputSize * usedXBlocks * (bandCount + 1));
outputXOffset = 0;
for(xBlock = xLow; xBlock < xHigh; xBlock++){
outputXOffset = ((xBlock - xLow) * xOutputSize * (bandCount + 1));
if(GDALReadBlock(hBand,xBlock,yBlock, data) != CE_None)
{
fprintf(stderr, "Read block failed\n");
exit(EXIT_FAILURE);
}
for(i = 0 ; i < ((*xBlockSize)*(*yBlockSize)) ; i += rseed){
rseed = (214013 * rseed + 2531011);
rseed %= maxStride;
sampledIndex = i;
i = (maxStride ==1) ? (i+1) : i;
rowIndex = (sampledIndex/(xOutputSize*scale* scale)) + ((yBlock - yLow)* yOutputSize);
colIndex = ((sampledIndex % (xOutputSize * scale))/scale) + ((xBlock - xLow) * xOutputSize);
outIndex = ((rowIndex * (xOutputSize * usedXBlocks ) + colIndex) * (bandCount+1) ) + (band -1);
vals[outIndex] += (*(data + sampledIndex));
valsPerIndex[outIndex] +=1;
}
outputIndexOffset = (outputYOffset + outputXOffset);
int j;
for (j = 0; j<yOutputSize; j++){
i = outputIndexOffset;
int k = (i + (xOutputSize * (bandCount+1)));
for (i = 0; i<k;i++){
int x = (i+(j*(xOutputSize * (bandCount + 1) * (usedXBlocks))));
if(((x+1)%4==0&&bandCount==3)||((x+1)%2==0&&bandCount==1)){
output[x] = (unsigned char) 1; //Sets the alpha to opaque
}else{
output[x] = (unsigned char) (vals[x]/valsPerIndex[x]); //calculate final output by averaging each color value
}
}
}
out->Data = output;
}
}
}
}
printf("sampling complete\n");
GDALClose(hDataset);
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset, hOutDS;
int i;
const char *pszSource=NULL, *pszDest=NULL, *pszFormat = "GTiff";
GDALDriverH hDriver;
GDALDataType eOutputType = GDT_Unknown;
char **papszCreateOptions = NULL;
GDALProgressFunc pfnProgress = GDALTermProgress;
int nLUTBins = 256;
const char *pszMethod = "minmax";
// double dfStdDevMult = 0.0;
double *padfScaleMin = NULL;
double *padfScaleMax = NULL;
int **papanLUTs = NULL;
int iBand;
const char *pszConfigFile = NULL;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
/* -------------------------------------------------------------------- */
/* 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], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i],"-of") && i < argc-1 )
pszFormat = argv[++i];
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( EQUALN(argv[i],"-s_nodata",9) )
{
// TODO
i += 1;
}
else if( EQUAL(argv[i],"-co") && i < argc-1 )
{
papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] );
}
else if( EQUALN(argv[i],"-src_scale",10) && i < argc-2)
{
// TODO
i += 2;
}
else if( EQUALN(argv[i],"-dst_scale",10) && i < argc-2 )
{
// TODO
i += 2;
}
else if( EQUAL(argv[i],"-config") && i < argc-1 )
{
pszConfigFile = argv[++i];
}
else if( EQUAL(argv[i],"-equalize") )
{
pszMethod = "equalize";
}
else if( EQUAL(argv[i],"-quiet") )
{
pfnProgress = GDALDummyProgress;
}
else if( argv[i][0] == '-' )
{
printf( "Option %s incomplete, or not recognised.\n\n",
argv[i] );
Usage();
GDALDestroyDriverManager();
exit( 2 );
}
else if( pszSource == NULL )
{
pszSource = argv[i];
}
else if( pszDest == NULL )
{
pszDest = argv[i];
}
else
{
printf( "Too many command options.\n\n" );
Usage();
GDALDestroyDriverManager();
exit( 2 );
}
}
if( pszSource == NULL )
{
Usage();
GDALDestroyDriverManager();
exit( 10 );
}
/* -------------------------------------------------------------------- */
/* Attempt to open source file. */
/* -------------------------------------------------------------------- */
hDataset = GDALOpenShared( pszSource, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"GDALOpen failed - %d\n%s\n",
CPLGetLastErrorNo(), CPLGetLastErrorMsg() );
GDALDestroyDriverManager();
exit( 1 );
}
int nBandCount = GDALGetRasterCount(hDataset);
/* -------------------------------------------------------------------- */
/* Find the output driver. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDriverByName( 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( hDataset );
GDALDestroyDriverManager();
CSLDestroy( argv );
CSLDestroy( papszCreateOptions );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* If histogram equalization is requested, do it now. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszMethod,"equalize") )
{
ComputeEqualizationLUTs( hDataset, nLUTBins,
&padfScaleMin, &padfScaleMax,
&papanLUTs, pfnProgress );
}
/* -------------------------------------------------------------------- */
/* If we have a config file, assume it is for input and read */
/* it. */
/* -------------------------------------------------------------------- */
else if( pszConfigFile != NULL )
{
char **papszLines = CSLLoad( pszConfigFile );
if( CSLCount(papszLines) == 0 )
exit( 1 );
if( CSLCount(papszLines) != nBandCount )
{
fprintf( stderr, "Did not get %d lines in config file as expected.\n", nBandCount );
exit( 1 );
}
padfScaleMin = (double *) CPLCalloc(nBandCount,sizeof(double));
padfScaleMax = (double *) CPLCalloc(nBandCount,sizeof(double));
for( iBand = 0; iBand < nBandCount; iBand++ )
{
int iLUT;
char **papszTokens = CSLTokenizeString( papszLines[iBand] );
if( CSLCount(papszTokens) < 3
|| atoi(papszTokens[0]) != iBand+1 )
{
fprintf( stderr, "Line %d seems to be corrupt.\n", iBand+1 );
exit( 1 );
}
// Process scale min/max
padfScaleMin[iBand] = atof(papszTokens[1]);
padfScaleMax[iBand] = atof(papszTokens[2]);
if( CSLCount(papszTokens) == 3 )
continue;
// process lut
if( iBand == 0 )
{
nLUTBins = CSLCount(papszTokens) - 3;
papanLUTs = (int **) CPLCalloc(sizeof(int*),nBandCount);
}
papanLUTs[iBand] = (int *) CPLCalloc(nLUTBins,sizeof(int));
for( iLUT = 0; iLUT < nLUTBins; iLUT++ )
papanLUTs[iBand][iLUT] = atoi(papszTokens[iLUT+3]);
CSLDestroy( papszTokens );
}
}
/* -------------------------------------------------------------------- */
/* If there is no destination, just report the scaling values */
/* and luts. */
/* -------------------------------------------------------------------- */
if( pszDest == NULL )
{
FILE *fpConfig = stdout;
if( pszConfigFile )
fpConfig = fopen( pszConfigFile, "w" );
for( iBand = 0; iBand < nBandCount; iBand++ )
{
fprintf( fpConfig, "%d:Band ", iBand+1 );
if( padfScaleMin != NULL )
fprintf( fpConfig, "%g:ScaleMin %g:ScaleMax ",
padfScaleMin[iBand], padfScaleMax[iBand] );
if( papanLUTs )
{
int iLUT;
for( iLUT = 0; iLUT < nLUTBins; iLUT++ )
fprintf( fpConfig, "%d ", papanLUTs[iBand][iLUT] );
}
fprintf( fpConfig, "\n" );
}
if( pszConfigFile )
fclose( fpConfig );
exit( 0 );
}
if (padfScaleMin == NULL || padfScaleMax == NULL)
{
fprintf( stderr, "-equalize or -config filename command line options must be specified.\n");
exit(1);
}
/* ==================================================================== */
/* Create a virtual dataset. */
/* ==================================================================== */
VRTDataset *poVDS;
EnhanceCBInfo *pasEInfo = (EnhanceCBInfo *)
CPLCalloc(nBandCount, sizeof(EnhanceCBInfo));
/* -------------------------------------------------------------------- */
/* Make a virtual clone. */
/* -------------------------------------------------------------------- */
poVDS = new VRTDataset( GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
if( GDALGetGCPCount(hDataset) == 0 )
{
const char *pszProjection;
double adfGeoTransform[6];
pszProjection = GDALGetProjectionRef( hDataset );
if( pszProjection != NULL && strlen(pszProjection) > 0 )
poVDS->SetProjection( pszProjection );
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
poVDS->SetGeoTransform( adfGeoTransform );
}
else
{
poVDS->SetGCPs( GDALGetGCPCount(hDataset),
GDALGetGCPs(hDataset),
GDALGetGCPProjection( hDataset ) );
}
poVDS->SetMetadata( ((GDALDataset*)hDataset)->GetMetadata() );
for( iBand = 0; iBand < nBandCount; iBand++ )
{
VRTSourcedRasterBand *poVRTBand;
GDALRasterBand *poSrcBand;
GDALDataType eBandType;
poSrcBand = ((GDALDataset *) hDataset)->GetRasterBand(iBand+1);
/* -------------------------------------------------------------------- */
/* Select output data type to match source. */
/* -------------------------------------------------------------------- */
if( eOutputType == GDT_Unknown )
eBandType = GDT_Byte;
else
eBandType = eOutputType;
/* -------------------------------------------------------------------- */
/* Create this band. */
/* -------------------------------------------------------------------- */
poVDS->AddBand( eBandType, NULL );
poVRTBand = (VRTSourcedRasterBand *) poVDS->GetRasterBand( iBand+1 );
/* -------------------------------------------------------------------- */
/* Create a function based source with info on how to apply the */
/* enhancement. */
/* -------------------------------------------------------------------- */
pasEInfo[iBand].poSrcBand = poSrcBand;
pasEInfo[iBand].eWrkType = eBandType;
pasEInfo[iBand].dfScaleMin = padfScaleMin[iBand];
pasEInfo[iBand].dfScaleMax = padfScaleMax[iBand];
pasEInfo[iBand].nLUTBins = nLUTBins;
if( papanLUTs )
pasEInfo[iBand].panLUT = papanLUTs[iBand];
poVRTBand->AddFuncSource( EnhancerCallback, pasEInfo + iBand );
/* -------------------------------------------------------------------- */
/* copy over some other information of interest. */
/* -------------------------------------------------------------------- */
poVRTBand->CopyCommonInfoFrom( poSrcBand );
}
/* -------------------------------------------------------------------- */
/* Write to the output file using CopyCreate(). */
/* -------------------------------------------------------------------- */
hOutDS = GDALCreateCopy( hDriver, pszDest, (GDALDatasetH) poVDS,
FALSE, papszCreateOptions,
pfnProgress, NULL );
if( hOutDS != NULL )
GDALClose( hOutDS );
GDALClose( (GDALDatasetH) poVDS );
GDALClose( hDataset );
/* -------------------------------------------------------------------- */
/* Cleanup and exit. */
/* -------------------------------------------------------------------- */
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CSLDestroy( argv );
CSLDestroy( papszCreateOptions );
exit( 0 );
}
int main( int argc, char ** argv )
{
/* Check that we are running against at least GDAL 1.4 (probably older in fact !) */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400)
{
fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
/* -------------------------------------------------------------------- */
/* Generic arg processing. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
GDALSetCacheMax( 100000000 );
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
int i;
const char *pszOutFile = NULL;
const char *pszInFile = NULL;
int nMaxNonBlack = 2;
int nNearDist = 15;
int bNearWhite = FALSE;
int bSetAlpha = FALSE;
int bSetMask = FALSE;
const char* pszDriverName = "HFA";
int bFormatExplicitelySet = FALSE;
char** papszCreationOptions = NULL;
int bQuiet = FALSE;
Colors oColors;
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i], "-o") && i < argc-1 )
pszOutFile = argv[++i];
else if( EQUAL(argv[i], "-of") && i < argc-1 )
{
pszDriverName = argv[++i];
bFormatExplicitelySet = TRUE;
}
else if( EQUAL(argv[i], "-white") ) {
bNearWhite = TRUE;
}
/***** -color c1,c2,c3...cn *****/
else if( EQUAL(argv[i], "-color") && i < argc-1 ) {
Color oColor;
/***** tokenize the arg on , *****/
char **papszTokens;
papszTokens = CSLTokenizeString2( argv[++i], ",", 0 );
/***** loop over the tokens *****/
int iToken;
for( iToken = 0; papszTokens && papszTokens[iToken]; iToken++ )
{
/***** ensure the token is an int and add it to the color *****/
if ( IsInt( papszTokens[iToken] ) )
oColor.push_back( atoi( papszTokens[iToken] ) );
else {
CPLError(CE_Failure, CPLE_AppDefined,
"Colors must be valid integers." );
CSLDestroy( papszTokens );
exit(1);
}
}
CSLDestroy( papszTokens );
/***** check if the number of bands is consistant *****/
if ( oColors.size() > 0 &&
oColors.front().size() != oColor.size() )
{
CPLError(CE_Failure, CPLE_AppDefined,
"ERROR: all -color args must have the same number of values.\n" );
exit(1);
}
/***** add the color to the colors *****/
oColors.push_back( oColor );
}
else if( EQUAL(argv[i], "-nb") && i < argc-1 )
nMaxNonBlack = atoi(argv[++i]);
else if( EQUAL(argv[i], "-near") && i < argc-1 )
nNearDist = atoi(argv[++i]);
else if( EQUAL(argv[i], "-setalpha") )
bSetAlpha = TRUE;
else if( EQUAL(argv[i], "-setmask") )
bSetMask = TRUE;
else if( EQUAL(argv[i], "-q") || EQUAL(argv[i], "-quiet") )
bQuiet = TRUE;
else if( EQUAL(argv[i], "-co") && i < argc-1 )
papszCreationOptions = CSLAddString(papszCreationOptions, argv[++i]);
else if( argv[i][0] == '-' )
Usage();
else if( pszInFile == NULL )
pszInFile = argv[i];
else
Usage();
}
if( pszInFile == NULL )
Usage();
if( pszOutFile == NULL )
pszOutFile = pszInFile;
/* -------------------------------------------------------------------- */
/* Open input file. */
/* -------------------------------------------------------------------- */
GDALDatasetH hInDS, hOutDS = NULL;
int nXSize, nYSize, nBands;
if( pszOutFile == pszInFile )
hInDS = hOutDS = GDALOpen( pszInFile, GA_Update );
else
hInDS = GDALOpen( pszInFile, GA_ReadOnly );
if( hInDS == NULL )
exit( 1 );
nXSize = GDALGetRasterXSize( hInDS );
nYSize = GDALGetRasterYSize( hInDS );
nBands = GDALGetRasterCount( hInDS );
int nDstBands = nBands;
if( hOutDS != NULL && papszCreationOptions != NULL)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Warning: creation options are ignored when writing to an existing file.");
}
/* -------------------------------------------------------------------- */
/* Do we need to create output file? */
/* -------------------------------------------------------------------- */
if( hOutDS == NULL )
{
GDALDriverH hDriver = GDALGetDriverByName( pszDriverName );
if (hDriver == NULL)
exit(1);
if (!bQuiet && !bFormatExplicitelySet)
CheckExtensionConsistency(pszOutFile, pszDriverName);
if (bSetAlpha)
{
/***** fixme there should be a way to preserve alpha band data not in the collar *****/
if (nBands == 4)
nBands --;
else
nDstBands ++;
}
if (bSetMask)
{
if (nBands == 4)
nDstBands = nBands = 3;
}
hOutDS = GDALCreate( hDriver, pszOutFile,
nXSize, nYSize, nDstBands, GDT_Byte,
papszCreationOptions );
if( hOutDS == NULL )
exit( 1 );
double adfGeoTransform[6];
if( GDALGetGeoTransform( hInDS, adfGeoTransform ) == CE_None )
{
GDALSetGeoTransform( hOutDS, adfGeoTransform );
GDALSetProjection( hOutDS, GDALGetProjectionRef( hInDS ) );
}
}
else
{
if (bSetAlpha)
{
if (nBands != 4 &&
(nBands < 2 ||
GDALGetRasterColorInterpretation(GDALGetRasterBand(hOutDS, nBands)) != GCI_AlphaBand))
{
CPLError(CE_Failure, CPLE_AppDefined,
"Last band is not an alpha band.");
exit(1);
}
nBands --;
}
if (bSetMask)
{
if (nBands == 4)
nDstBands = nBands = 3;
}
}
/***** set a color if there are no colors set? *****/
if ( oColors.size() == 0) {
Color oColor;
/***** loop over the bands to get the right number of values *****/
int iBand;
for (iBand = 0; iBand < nBands ; iBand++) {
/***** black or white? *****/
if (bNearWhite)
oColor.push_back(255);
else
oColor.push_back(0);
}
/***** add the color to the colors *****/
oColors.push_back(oColor);
}
/***** does the number of bands match the number of color values? *****/
if ( (int)oColors.front().size() != nBands ) {
CPLError( CE_Failure, CPLE_AppDefined,
"-color args must have the same number of values as the non alpha input band count.\n" );
exit(1);
}
/***** check the input and output datasets are the same size *****/
if (GDALGetRasterXSize(hOutDS) != nXSize ||
GDALGetRasterYSize(hOutDS) != nYSize)
{
CPLError(CE_Failure, CPLE_AppDefined,
"The dimensions of the output dataset don't match "
"the dimensions of the input dataset.");
exit(1);
}
int iBand;
for( iBand = 0; iBand < nBands; iBand++ )
{
GDALRasterBandH hBand = GDALGetRasterBand(hInDS, iBand+1);
if (GDALGetRasterDataType(hBand) != GDT_Byte)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Band %d is not of type GDT_Byte. It can lead to unexpected results.", iBand+1);
}
if (GDALGetRasterColorTable(hBand) != NULL)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Band %d has a color table, which is ignored by nearblack. "
"It can lead to unexpected results.", iBand+1);
}
}
GDALRasterBandH hMaskBand = NULL;
if (bSetMask) {
/***** if there isn't already a mask band on the output file create one *****/
if ( GMF_PER_DATASET != GDALGetMaskFlags( GDALGetRasterBand(hOutDS, 1) ) )
{
if ( CE_None != GDALCreateDatasetMaskBand(hOutDS, GMF_PER_DATASET) ) {
CPLError(CE_Failure, CPLE_AppDefined,
"Failed to create mask band on output DS");
bSetMask = FALSE;
}
}
if (bSetMask) {
hMaskBand = GDALGetMaskBand(GDALGetRasterBand(hOutDS, 1));
}
}
/* -------------------------------------------------------------------- */
/* Allocate a line buffer. */
/* -------------------------------------------------------------------- */
GByte *pabyLine;
GByte *pabyMask=NULL;
int *panLastLineCounts;
pabyLine = (GByte *) CPLMalloc(nXSize * nDstBands);
if (bSetMask)
pabyMask = (GByte *) CPLMalloc(nXSize);
panLastLineCounts = (int *) CPLCalloc(sizeof(int),nXSize);
/* -------------------------------------------------------------------- */
/* Processing data one line at a time. */
/* -------------------------------------------------------------------- */
int iLine;
for( iLine = 0; iLine < nYSize; iLine++ )
{
CPLErr eErr;
eErr = GDALDatasetRasterIO( hInDS, GF_Read, 0, iLine, nXSize, 1,
pabyLine, nXSize, 1, GDT_Byte,
nBands, NULL, nDstBands, nXSize * nDstBands, 1 );
if( eErr != CE_None )
break;
if (bSetAlpha)
{
int iCol;
for(iCol = 0; iCol < nXSize; iCol ++)
{
pabyLine[iCol * nDstBands + nDstBands - 1] = 255;
}
}
if (bSetMask)
{
int iCol;
for(iCol = 0; iCol < nXSize; iCol ++)
{
pabyMask[iCol] = 255;
}
}
ProcessLine( pabyLine, pabyMask, 0, nXSize-1, nBands, nDstBands,
nNearDist, nMaxNonBlack, bNearWhite, &oColors,
panLastLineCounts,
TRUE, // bDoHorizontalCheck
TRUE, // bDoVerticalCheck
FALSE // bBottomUp
);
ProcessLine( pabyLine, pabyMask, nXSize-1, 0, nBands, nDstBands,
nNearDist, nMaxNonBlack, bNearWhite, &oColors,
panLastLineCounts,
TRUE, // bDoHorizontalCheck
FALSE, // bDoVerticalCheck
FALSE // bBottomUp
);
eErr = GDALDatasetRasterIO( hOutDS, GF_Write, 0, iLine, nXSize, 1,
pabyLine, nXSize, 1, GDT_Byte,
nDstBands, NULL, nDstBands, nXSize * nDstBands, 1 );
if( eErr != CE_None )
break;
/***** write out the mask band line *****/
if (bSetMask) {
eErr = GDALRasterIO ( hMaskBand, GF_Write, 0, iLine, nXSize, 1,
pabyMask, nXSize, 1, GDT_Byte,
0, 0 );
if( eErr != CE_None ) {
CPLError(CE_Warning, CPLE_AppDefined,
"ERROR writeing out line to mask band.");
break;
}
}
if (!bQuiet)
GDALTermProgress( 0.5 * ((iLine+1) / (double) nYSize), NULL, NULL );
}
/* -------------------------------------------------------------------- */
/* Now process from the bottom back up .*/
/* -------------------------------------------------------------------- */
memset( panLastLineCounts, 0, sizeof(int) * nXSize);
for( iLine = nYSize-1; iLine >= 0; iLine-- )
{
CPLErr eErr;
eErr = GDALDatasetRasterIO( hOutDS, GF_Read, 0, iLine, nXSize, 1,
pabyLine, nXSize, 1, GDT_Byte,
nDstBands, NULL, nDstBands, nXSize * nDstBands, 1 );
if( eErr != CE_None )
break;
/***** read the mask band line back in *****/
if (bSetMask) {
eErr = GDALRasterIO ( hMaskBand, GF_Read, 0, iLine, nXSize, 1,
pabyMask, nXSize, 1, GDT_Byte,
0, 0 );
if( eErr != CE_None )
break;
}
ProcessLine( pabyLine, pabyMask, 0, nXSize-1, nBands, nDstBands,
nNearDist, nMaxNonBlack, bNearWhite, &oColors,
panLastLineCounts,
TRUE, // bDoHorizontalCheck
TRUE, // bDoVerticalCheck
TRUE // bBottomUp
);
ProcessLine( pabyLine, pabyMask, nXSize-1, 0, nBands, nDstBands,
nNearDist, nMaxNonBlack, bNearWhite, &oColors,
panLastLineCounts,
TRUE, // bDoHorizontalCheck
FALSE, // bDoVerticalCheck
TRUE // bBottomUp
);
eErr = GDALDatasetRasterIO( hOutDS, GF_Write, 0, iLine, nXSize, 1,
pabyLine, nXSize, 1, GDT_Byte,
nDstBands, NULL, nDstBands, nXSize * nDstBands, 1 );
if( eErr != CE_None )
break;
/***** write out the mask band line *****/
if (bSetMask) {
eErr = GDALRasterIO ( hMaskBand, GF_Write, 0, iLine, nXSize, 1,
pabyMask, nXSize, 1, GDT_Byte,
0, 0 );
if( eErr != CE_None )
break;
}
if (!bQuiet)
GDALTermProgress( 0.5 + 0.5 * (nYSize-iLine) / (double) nYSize,
NULL, NULL );
}
CPLFree(pabyLine);
if (bSetMask)
CPLFree(pabyMask);
CPLFree( panLastLineCounts );
GDALClose( hOutDS );
if( hInDS != hOutDS )
GDALClose( hInDS );
GDALDumpOpenDatasets( stderr );
CSLDestroy( argv );
CSLDestroy( papszCreationOptions );
GDALDestroyDriverManager();
return 0;
}
int main( int argc, char ** argv )
{
GDALDatasetH hSrcDS;
int iY, iX, nOutLevel=0, nXSize, nYSize, iArg, nFillDist=0;
void *pStream;
GInt16 *panData;
const char *pszFilename = NULL;
GDALRasterBandH hSrcBand;
double adfGeoTransform[6];
int bEnableTrim = FALSE;
GInt16 noDataValue = 0;
int bHasNoData;
/* -------------------------------------------------------------------- */
/* Identify arguments. */
/* -------------------------------------------------------------------- */
for( iArg = 1; iArg < argc; iArg++ )
{
if( EQUAL(argv[iArg],"-trim") )
bEnableTrim = TRUE;
else if( EQUAL(argv[iArg],"-fill") )
nFillDist = atoi(argv[++iArg]);
else if( EQUAL(argv[iArg],"-level") )
nOutLevel = atoi(argv[++iArg]);
else
{
if( pszFilename != NULL )
Usage();
pszFilename = argv[iArg];
}
}
if( pszFilename == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open input file. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
hSrcDS = GDALOpen( pszFilename, GA_ReadOnly );
if( hSrcDS == NULL )
exit(1);
hSrcBand = GDALGetRasterBand( hSrcDS, 1 );
noDataValue = (GInt16)GDALGetRasterNoDataValue(hSrcBand, &bHasNoData);
nXSize = GDALGetRasterXSize( hSrcDS );
nYSize = GDALGetRasterYSize( hSrcDS );
GDALGetGeoTransform( hSrcDS, adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Create output stream. */
/* -------------------------------------------------------------------- */
pStream = DTEDCreatePtStream( ".", nOutLevel );
if( pStream == NULL )
exit( 1 );
/* -------------------------------------------------------------------- */
/* Process all the profiles. */
/* -------------------------------------------------------------------- */
panData = (GInt16 *) malloc(sizeof(GInt16) * nXSize);
for( iY = 0; iY < nYSize; iY++ )
{
GDALRasterIO( hSrcBand, GF_Read, 0, iY, nXSize, 1,
panData, nXSize, 1, GDT_Int16, 0, 0 );
if (bHasNoData)
{
for( iX = 0; iX < nXSize; iX++ )
{
if (panData[iX] == noDataValue)
panData[iX] = DTED_NODATA_VALUE;
}
}
for( iX = 0; iX < nXSize; iX++ )
{
DTEDWritePt( pStream,
adfGeoTransform[0]
+ adfGeoTransform[1] * (iX + 0.5)
+ adfGeoTransform[2] * (iY + 0.5),
adfGeoTransform[3]
+ adfGeoTransform[4] * (iX + 0.5)
+ adfGeoTransform[5] * (iY + 0.5),
panData[iX] );
}
}
free( panData );
/* -------------------------------------------------------------------- */
/* Cleanup. */
/* -------------------------------------------------------------------- */
if( bEnableTrim )
DTEDPtStreamTrimEdgeOnlyTiles( pStream );
if( nFillDist > 0 )
DTEDFillPtStream( pStream, nFillDist );
DTEDClosePtStream( pStream );
GDALClose( hSrcDS );
exit( 0 );
}
/** GDALComputeMatchingPoints. TODO document */
GDAL_GCP CPL_DLL *
GDALComputeMatchingPoints( GDALDatasetH hFirstImage,
GDALDatasetH hSecondImage,
char **papszOptions,
int *pnGCPCount )
{
*pnGCPCount = 0;
/* -------------------------------------------------------------------- */
/* Override default algorithm parameters. */
/* -------------------------------------------------------------------- */
int nOctaveStart, nOctaveEnd;
double dfSURFThreshold;
nOctaveStart =atoi(CSLFetchNameValueDef(papszOptions, "OCTAVE_START", "2"));
nOctaveEnd = atoi(CSLFetchNameValueDef(papszOptions, "OCTAVE_END", "2"));
dfSURFThreshold = CPLAtof(
CSLFetchNameValueDef(papszOptions, "SURF_THRESHOLD", "0.001"));
const double dfMatchingThreshold = CPLAtof(
CSLFetchNameValueDef(papszOptions, "MATCHING_THRESHOLD", "0.015"));
/* -------------------------------------------------------------------- */
/* Identify the bands to use. For now we are effectively */
/* limited to using RGB input so if we have one band only treat */
/* it as red=green=blue=band 1. Disallow non eightbit imagery. */
/* -------------------------------------------------------------------- */
int anBandMap1[3] = { 1, 1, 1 };
if( GDALGetRasterCount(hFirstImage) >= 3 )
{
anBandMap1[1] = 2;
anBandMap1[2] = 3;
}
int anBandMap2[3] = { 1, 1, 1 };
if( GDALGetRasterCount(hSecondImage) >= 3 )
{
anBandMap2[1] = 2;
anBandMap2[2] = 3;
}
/* -------------------------------------------------------------------- */
/* Collect reference points on each image. */
/* -------------------------------------------------------------------- */
std::vector<GDALFeaturePoint> *poFPCollection1 =
GatherFeaturePoints(reinterpret_cast<GDALDataset *>(hFirstImage),
anBandMap1,
nOctaveStart, nOctaveEnd, dfSURFThreshold);
if( poFPCollection1 == nullptr )
return nullptr;
std::vector<GDALFeaturePoint> *poFPCollection2 =
GatherFeaturePoints(reinterpret_cast<GDALDataset *>(hSecondImage),
anBandMap2,
nOctaveStart, nOctaveEnd,
dfSURFThreshold);
if( poFPCollection2 == nullptr )
{
delete poFPCollection1;
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Try to find corresponding locations. */
/* -------------------------------------------------------------------- */
std::vector<GDALFeaturePoint *> oMatchPairs;
if( CE_None != GDALSimpleSURF::MatchFeaturePoints(
&oMatchPairs, poFPCollection1, poFPCollection2,
dfMatchingThreshold ))
{
delete poFPCollection1;
delete poFPCollection2;
return nullptr;
}
*pnGCPCount = static_cast<int>(oMatchPairs.size()) / 2;
/* -------------------------------------------------------------------- */
/* Translate these into GCPs - but with the output coordinate */
/* system being pixel/line on the second image. */
/* -------------------------------------------------------------------- */
GDAL_GCP *pasGCPList =
static_cast<GDAL_GCP*>(CPLCalloc(*pnGCPCount, sizeof(GDAL_GCP)));
GDALInitGCPs(*pnGCPCount, pasGCPList);
for( int i=0; i < *pnGCPCount; i++ )
{
GDALFeaturePoint *poPoint1 = oMatchPairs[i*2 ];
GDALFeaturePoint *poPoint2 = oMatchPairs[i*2+1];
pasGCPList[i].dfGCPPixel = poPoint1->GetX() + 0.5;
pasGCPList[i].dfGCPLine = poPoint1->GetY() + 0.5;
pasGCPList[i].dfGCPX = poPoint2->GetX() + 0.5;
pasGCPList[i].dfGCPY = poPoint2->GetY() + 0.5;
pasGCPList[i].dfGCPZ = 0.0;
}
// Cleanup the feature point lists.
delete poFPCollection1;
delete poFPCollection2;
/* -------------------------------------------------------------------- */
/* Optionally transform into the georef coordinates of the */
/* output image. */
/* -------------------------------------------------------------------- */
const bool bGeorefOutput =
CPLTestBool(CSLFetchNameValueDef(papszOptions, "OUTPUT_GEOREF", "NO"));
if( bGeorefOutput )
{
double adfGeoTransform[6] = {};
GDALGetGeoTransform( hSecondImage, adfGeoTransform );
for( int i=0; i < *pnGCPCount; i++ )
{
GDALApplyGeoTransform(adfGeoTransform,
pasGCPList[i].dfGCPX,
pasGCPList[i].dfGCPY,
&(pasGCPList[i].dfGCPX),
&(pasGCPList[i].dfGCPY));
}
}
return pasGCPList;
}
void CDialog3D::OnBnClickedBtnOpen()
{
// TODO: 在此添加控件通知处理程序代码
CFileDialog fileDlg(TRUE);
if(fileDlg.DoModal()!=IDOK)
return;
CString strExt =fileDlg.GetFileExt();
CString strPathName=fileDlg.GetPathName();
if(strExt=="txt")
{
ifstream ifs(strPathName,ios_base::in);
char tmpchr[2048];
ifs.getline(tmpchr,2048);
do
{
PNT3D tmpPnt;
ifs.getline(tmpchr,2048);
sscanf(tmpchr,"%f,%f,%f",&tmpPnt.DX,&tmpPnt.DY,&tmpPnt.DZ);
m_vec_PNT3Ds.push_back(tmpPnt);
} while (!ifs.eof());
ifs.close();
}
if(strExt=="BMP"||strExt=="bmp"||strExt=="JPG"||strExt=="jpg"||strExt=="TIF"||strExt=="tif")
{
GDALAllRegister();
GDALDatasetH hSrcDS=GDALOpen(strPathName,GA_ReadOnly);
double adfGeoTrans[6];
double scalex=1,scaley=1;
GDALGetGeoTransform(hSrcDS,adfGeoTrans);
int xsize=GDALGetRasterXSize(hSrcDS);
int ysize=GDALGetRasterYSize(hSrcDS);
int tmpxsize=xsize,tmpysize=ysize;
if(xsize>800)
{
tmpxsize=800;
scalex=xsize/tmpxsize;
}
if(ysize>600)
{
tmpysize=600;
scaley=ysize/tmpysize;
}
float *dataIn=new float[tmpxsize*tmpysize];
GDALRasterIO(GDALGetRasterBand(hSrcDS,1),GF_Read,0,0,xsize,ysize,dataIn,tmpxsize,tmpysize,GDT_Float32,0,0);
for(int i=0;i<tmpxsize;i++)
{
for (int j=0;j<tmpysize;j++)
{
PNT3D tmpPnt;
tmpPnt.DX=adfGeoTrans[0]+adfGeoTrans[1]*i*scalex+adfGeoTrans[2]*j*scaley;
tmpPnt.DY=adfGeoTrans[3]+adfGeoTrans[4]*i*scalex+adfGeoTrans[5]*j*scaley;
//tmpPnt.DX=i;
//tmpPnt.DY=j;
tmpPnt.DZ=dataIn[j*tmpxsize+i];
m_vec_PNT3Ds.push_back(tmpPnt);
}
}
delete[]dataIn;
GDALClose(hSrcDS);
}
if(!m_vec_PNT3Ds.empty())
{
m_min_DX=m_max_DX=m_vec_PNT3Ds[0].DX;
m_min_DY=m_max_DY=m_vec_PNT3Ds[0].DY;
m_min_DZ=m_max_DZ=m_vec_PNT3Ds[0].DZ;
for (int i=0;i<m_vec_PNT3Ds.size();i++)
{
m_max_DX=max(m_vec_PNT3Ds[i].DX,m_max_DX);
m_min_DX=min(m_vec_PNT3Ds[i].DX,m_min_DX);
m_max_DY=max(m_vec_PNT3Ds[i].DY,m_max_DY);
m_min_DY=min(m_vec_PNT3Ds[i].DY,m_min_DY);
m_max_DZ=max(m_vec_PNT3Ds[i].DZ,m_max_DZ);
m_min_DZ=min(m_vec_PNT3Ds[i].DZ,m_min_DZ);
}
AfxMessageBox("数据读取成功!\n");
InvalidateRect(NULL,FALSE);
}
}
int QgsZonalStatistics::calculateStatistics( QProgressDialog* p )
{
if ( !mPolygonLayer || mPolygonLayer->geometryType() != QGis::Polygon )
{
return 1;
}
QgsVectorDataProvider* vectorProvider = mPolygonLayer->dataProvider();
if ( !vectorProvider )
{
return 2;
}
//open the raster layer and the raster band
GDALAllRegister();
GDALDatasetH inputDataset = GDALOpen( TO8F( mRasterFilePath ), GA_ReadOnly );
if ( !inputDataset )
{
return 3;
}
if ( GDALGetRasterCount( inputDataset ) < ( mRasterBand - 1 ) )
{
GDALClose( inputDataset );
return 4;
}
GDALRasterBandH rasterBand = GDALGetRasterBand( inputDataset, mRasterBand );
if ( !rasterBand )
{
GDALClose( inputDataset );
return 5;
}
mInputNodataValue = GDALGetRasterNoDataValue( rasterBand, nullptr );
//get geometry info about raster layer
int nCellsXGDAL = GDALGetRasterXSize( inputDataset );
int nCellsYGDAL = GDALGetRasterYSize( inputDataset );
double geoTransform[6];
if ( GDALGetGeoTransform( inputDataset, geoTransform ) != CE_None )
{
GDALClose( inputDataset );
return 6;
}
double cellsizeX = geoTransform[1];
if ( cellsizeX < 0 )
{
cellsizeX = -cellsizeX;
}
double cellsizeY = geoTransform[5];
if ( cellsizeY < 0 )
{
cellsizeY = -cellsizeY;
}
QgsRectangle rasterBBox( geoTransform[0], geoTransform[3] - ( nCellsYGDAL * cellsizeY ),
geoTransform[0] + ( nCellsXGDAL * cellsizeX ), geoTransform[3] );
//add the new fields to the provider
QList<QgsField> newFieldList;
QString countFieldName;
if ( mStatistics & QgsZonalStatistics::Count )
{
countFieldName = getUniqueFieldName( mAttributePrefix + "count" );
QgsField countField( countFieldName, QVariant::Double, "double precision" );
newFieldList.push_back( countField );
}
QString sumFieldName;
if ( mStatistics & QgsZonalStatistics::Sum )
{
sumFieldName = getUniqueFieldName( mAttributePrefix + "sum" );
QgsField sumField( sumFieldName, QVariant::Double, "double precision" );
newFieldList.push_back( sumField );
}
QString meanFieldName;
if ( mStatistics & QgsZonalStatistics::Mean )
{
meanFieldName = getUniqueFieldName( mAttributePrefix + "mean" );
QgsField meanField( meanFieldName, QVariant::Double, "double precision" );
newFieldList.push_back( meanField );
}
QString medianFieldName;
if ( mStatistics & QgsZonalStatistics::Median )
{
medianFieldName = getUniqueFieldName( mAttributePrefix + "median" );
QgsField medianField( medianFieldName, QVariant::Double, "double precision" );
newFieldList.push_back( medianField );
}
QString stdevFieldName;
if ( mStatistics & QgsZonalStatistics::StDev )
{
stdevFieldName = getUniqueFieldName( mAttributePrefix + "stdev" );
QgsField stdField( stdevFieldName, QVariant::Double, "double precision" );
newFieldList.push_back( stdField );
}
QString minFieldName;
if ( mStatistics & QgsZonalStatistics::Min )
{
minFieldName = getUniqueFieldName( mAttributePrefix + "min" );
QgsField minField( minFieldName, QVariant::Double, "double precision" );
newFieldList.push_back( minField );
}
QString maxFieldName;
if ( mStatistics & QgsZonalStatistics::Max )
{
maxFieldName = getUniqueFieldName( mAttributePrefix + "max" );
QgsField maxField( maxFieldName, QVariant::Double, "double precision" );
newFieldList.push_back( maxField );
}
QString rangeFieldName;
if ( mStatistics & QgsZonalStatistics::Range )
{
rangeFieldName = getUniqueFieldName( mAttributePrefix + "range" );
QgsField rangeField( rangeFieldName, QVariant::Double, "double precision" );
newFieldList.push_back( rangeField );
}
QString minorityFieldName;
if ( mStatistics & QgsZonalStatistics::Minority )
{
minorityFieldName = getUniqueFieldName( mAttributePrefix + "minority" );
QgsField minorityField( minorityFieldName, QVariant::Double, "double precision" );
newFieldList.push_back( minorityField );
}
QString majorityFieldName;
if ( mStatistics & QgsZonalStatistics::Majority )
{
majorityFieldName = getUniqueFieldName( mAttributePrefix + "majority" );
QgsField majField( majorityFieldName, QVariant::Double, "double precision" );
newFieldList.push_back( majField );
}
QString varietyFieldName;
if ( mStatistics & QgsZonalStatistics::Variety )
{
varietyFieldName = getUniqueFieldName( mAttributePrefix + "variety" );
QgsField varietyField( varietyFieldName, QVariant::Int, "int" );
newFieldList.push_back( varietyField );
}
vectorProvider->addAttributes( newFieldList );
//index of the new fields
int countIndex = mStatistics & QgsZonalStatistics::Count ? vectorProvider->fieldNameIndex( countFieldName ) : -1;
int sumIndex = mStatistics & QgsZonalStatistics::Sum ? vectorProvider->fieldNameIndex( sumFieldName ) : -1;
int meanIndex = mStatistics & QgsZonalStatistics::Mean ? vectorProvider->fieldNameIndex( meanFieldName ) : -1;
int medianIndex = mStatistics & QgsZonalStatistics::Median ? vectorProvider->fieldNameIndex( medianFieldName ) : -1;
int stdevIndex = mStatistics & QgsZonalStatistics::StDev ? vectorProvider->fieldNameIndex( stdevFieldName ) : -1;
int minIndex = mStatistics & QgsZonalStatistics::Min ? vectorProvider->fieldNameIndex( minFieldName ) : -1;
int maxIndex = mStatistics & QgsZonalStatistics::Max ? vectorProvider->fieldNameIndex( maxFieldName ) : -1;
int rangeIndex = mStatistics & QgsZonalStatistics::Range ? vectorProvider->fieldNameIndex( rangeFieldName ) : -1;
int minorityIndex = mStatistics & QgsZonalStatistics::Minority ? vectorProvider->fieldNameIndex( minorityFieldName ) : -1;
int majorityIndex = mStatistics & QgsZonalStatistics::Majority ? vectorProvider->fieldNameIndex( majorityFieldName ) : -1;
int varietyIndex = mStatistics & QgsZonalStatistics::Variety ? vectorProvider->fieldNameIndex( varietyFieldName ) : -1;
if (( mStatistics & QgsZonalStatistics::Count && countIndex == -1 )
|| ( mStatistics & QgsZonalStatistics::Sum && sumIndex == -1 )
|| ( mStatistics & QgsZonalStatistics::Mean && meanIndex == -1 )
|| ( mStatistics & QgsZonalStatistics::Median && medianIndex == -1 )
|| ( mStatistics & QgsZonalStatistics::StDev && stdevIndex == -1 )
|| ( mStatistics & QgsZonalStatistics::Min && minIndex == -1 )
|| ( mStatistics & QgsZonalStatistics::Max && maxIndex == -1 )
|| ( mStatistics & QgsZonalStatistics::Range && rangeIndex == -1 )
|| ( mStatistics & QgsZonalStatistics::Minority && minorityIndex == -1 )
|| ( mStatistics & QgsZonalStatistics::Majority && majorityIndex == -1 )
|| ( mStatistics & QgsZonalStatistics::Variety && varietyIndex == -1 )
)
{
//failed to create a required field
return 8;
}
//progress dialog
long featureCount = vectorProvider->featureCount();
if ( p )
{
p->setMaximum( featureCount );
}
//iterate over each polygon
QgsFeatureRequest request;
request.setSubsetOfAttributes( QgsAttributeList() );
QgsFeatureIterator fi = vectorProvider->getFeatures( request );
QgsFeature f;
bool statsStoreValues = ( mStatistics & QgsZonalStatistics::Median ) ||
( mStatistics & QgsZonalStatistics::StDev );
bool statsStoreValueCount = ( mStatistics & QgsZonalStatistics::Minority ) ||
( mStatistics & QgsZonalStatistics::Majority );
FeatureStats featureStats( statsStoreValues, statsStoreValueCount );
int featureCounter = 0;
QgsChangedAttributesMap changeMap;
while ( fi.nextFeature( f ) )
{
if ( p )
{
p->setValue( featureCounter );
}
if ( p && p->wasCanceled() )
{
break;
}
if ( !f.constGeometry() )
{
++featureCounter;
continue;
}
const QgsGeometry* featureGeometry = f.constGeometry();
QgsRectangle featureRect = featureGeometry->boundingBox().intersect( &rasterBBox );
if ( featureRect.isEmpty() )
{
++featureCounter;
continue;
}
int offsetX, offsetY, nCellsX, nCellsY;
if ( cellInfoForBBox( rasterBBox, featureRect, cellsizeX, cellsizeY, offsetX, offsetY, nCellsX, nCellsY ) != 0 )
{
++featureCounter;
continue;
}
//avoid access to cells outside of the raster (may occur because of rounding)
if (( offsetX + nCellsX ) > nCellsXGDAL )
{
nCellsX = nCellsXGDAL - offsetX;
}
if (( offsetY + nCellsY ) > nCellsYGDAL )
{
nCellsY = nCellsYGDAL - offsetY;
}
statisticsFromMiddlePointTest( rasterBand, featureGeometry, offsetX, offsetY, nCellsX, nCellsY, cellsizeX, cellsizeY,
rasterBBox, featureStats );
if ( featureStats.count <= 1 )
{
//the cell resolution is probably larger than the polygon area. We switch to precise pixel - polygon intersection in this case
statisticsFromPreciseIntersection( rasterBand, featureGeometry, offsetX, offsetY, nCellsX, nCellsY, cellsizeX, cellsizeY,
rasterBBox, featureStats );
}
//write the statistics value to the vector data provider
QgsAttributeMap changeAttributeMap;
if ( mStatistics & QgsZonalStatistics::Count )
changeAttributeMap.insert( countIndex, QVariant( featureStats.count ) );
if ( mStatistics & QgsZonalStatistics::Sum )
changeAttributeMap.insert( sumIndex, QVariant( featureStats.sum ) );
if ( featureStats.count > 0 )
{
double mean = featureStats.sum / featureStats.count;
if ( mStatistics & QgsZonalStatistics::Mean )
changeAttributeMap.insert( meanIndex, QVariant( mean ) );
if ( mStatistics & QgsZonalStatistics::Median )
{
qSort( featureStats.values.begin(), featureStats.values.end() );
int size = featureStats.values.count();
bool even = ( size % 2 ) < 1;
double medianValue;
if ( even )
{
medianValue = ( featureStats.values.at( size / 2 - 1 ) + featureStats.values.at( size / 2 ) ) / 2;
}
else //odd
{
medianValue = featureStats.values.at(( size + 1 ) / 2 - 1 );
}
changeAttributeMap.insert( medianIndex, QVariant( medianValue ) );
}
if ( mStatistics & QgsZonalStatistics::StDev )
{
double sumSquared = 0;
for ( int i = 0; i < featureStats.values.count(); ++i )
{
double diff = featureStats.values.at( i ) - mean;
sumSquared += diff * diff;
}
double stdev = qPow( sumSquared / featureStats.values.count(), 0.5 );
changeAttributeMap.insert( stdevIndex, QVariant( stdev ) );
}
if ( mStatistics & QgsZonalStatistics::Min )
changeAttributeMap.insert( minIndex, QVariant( featureStats.min ) );
if ( mStatistics & QgsZonalStatistics::Max )
changeAttributeMap.insert( maxIndex, QVariant( featureStats.max ) );
if ( mStatistics & QgsZonalStatistics::Range )
changeAttributeMap.insert( rangeIndex, QVariant( featureStats.max - featureStats.min ) );
if ( mStatistics & QgsZonalStatistics::Minority || mStatistics & QgsZonalStatistics::Majority )
{
QList<int> vals = featureStats.valueCount.values();
qSort( vals.begin(), vals.end() );
if ( mStatistics & QgsZonalStatistics::Minority )
{
float minorityKey = featureStats.valueCount.key( vals.first() );
changeAttributeMap.insert( minorityIndex, QVariant( minorityKey ) );
}
if ( mStatistics & QgsZonalStatistics::Majority )
{
float majKey = featureStats.valueCount.key( vals.last() );
changeAttributeMap.insert( majorityIndex, QVariant( majKey ) );
}
}
if ( mStatistics & QgsZonalStatistics::Variety )
changeAttributeMap.insert( varietyIndex, QVariant( featureStats.valueCount.count() ) );
}
changeMap.insert( f.id(), changeAttributeMap );
++featureCounter;
}
vectorProvider->changeAttributeValues( changeMap );
if ( p )
{
p->setValue( featureCount );
}
GDALClose( inputDataset );
mPolygonLayer->updateFields();
if ( p && p->wasCanceled() )
{
return 9;
}
return 0;
}