void object::test<8>()
{
// Index of test file being tested
const std::size_t fileIdx = 1;
std::string file(data_ + SEP);
file += grids_.at(fileIdx).file_;
GDALDatasetH ds = GDALOpen(file.c_str(), GA_ReadOnly);
ensure("Can't open dataset: " + file, nullptr != ds);
GDALRasterBandH band = GDALGetRasterBand(ds, grids_.at(fileIdx).band_);
ensure("Can't get raster band", nullptr != band);
// Sub-windows size
const int win[4] = { 5, 5, 5, 5 };
// subwindow checksum
const int winChecksum = 187;
const int checksum = GDALChecksumImage(band, win[0], win[1], win[2], win[3]);
std::stringstream os;
os << "Checksums for '" << file << "' not equal";
ensure_equals(os.str().c_str(), checksum, winChecksum);
GDALClose(ds);
}
void object::test<3>()
{
rasters_t::const_iterator it;
for (it = grids_.begin(); it != grids_.end(); ++it)
{
std::string file(data_ + SEP);
file += it->file_;
GDALDatasetH ds = GDALOpen(file.c_str(), GA_ReadOnly);
ensure("Can't open dataset: " + file, nullptr != ds);
GDALRasterBandH band = GDALGetRasterBand(ds, it->band_);
ensure("Can't get raster band", nullptr != band);
const int xsize = GDALGetRasterXSize(ds);
const int ysize = GDALGetRasterYSize(ds);
const int checksum = GDALChecksumImage(band, 0, 0, xsize, ysize);
std::stringstream os;
os << "Checksums for '" << file << "' not equal";
ensure_equals(os.str().c_str(), checksum, it->checksum_);
GDALClose(ds);
}
}
void object::test<7>()
{
// Index of test file being tested
const std::size_t fileIdx = 0;
std::string src(data_ + SEP);
src += rasters_.at(fileIdx).file_;
GDALDatasetH dsSrc = GDALOpen(src.c_str(), GA_ReadOnly);
ensure("Can't open source dataset: " + src, nullptr != dsSrc);
std::string dst(data_tmp_ + SEP);
dst += rasters_.at(fileIdx).file_;
dst += ".grd";
GDALDatasetH dsDst = nullptr;
dsDst = GDALCreateCopy(drv_, dst.c_str(), dsSrc, FALSE, nullptr, nullptr, nullptr);
GDALClose(dsSrc);
ensure("Can't copy dataset", nullptr != dsDst);
std::string proj(GDALGetProjectionRef(dsDst));
ensure_equals("Projection definition is not available", proj.empty(), false);
std::string expect(
"PROJCS[\"NAD27 / UTM zone 11N\",GEOGCS[\"NAD27\","
"DATUM[\"North_American_Datum_1927\",SPHEROID[\"Clarke 1866\","
"6378206.4,294.978698213898,AUTHORITY[\"EPSG\",\"7008\"]],"
"AUTHORITY[\"EPSG\",\"6267\"]],PRIMEM[\"Greenwich\",0],"
"UNIT[\"Degree\",0.0174532925199433]],"
"PROJECTION[\"Transverse_Mercator\"],"
"PARAMETER[\"latitude_of_origin\",0],"
"PARAMETER[\"central_meridian\",-117],"
"PARAMETER[\"scale_factor\",0.9996],"
"PARAMETER[\"false_easting\",500000],"
"PARAMETER[\"false_northing\",0],"
"UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],"
"AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH]]");
ensure_equals("Projection does not match expected", proj, expect);
GDALRasterBandH band = GDALGetRasterBand(dsDst, rasters_.at(fileIdx).band_);
ensure("Can't get raster band", nullptr != band);
const int xsize = GDALGetRasterXSize(dsDst);
const int ysize = GDALGetRasterYSize(dsDst);
const int checksum = GDALChecksumImage(band, 0, 0, xsize, ysize);
std::stringstream os;
os << "Checksums for '" << dst << "' not equal";
ensure_equals(os.str().c_str(), checksum, rasters_.at(fileIdx).checksum_);
GDALClose(dsDst);
}
static void WorkerFunc( void *arg )
{
GDALDatasetH hDSIn = static_cast<GDALDatasetH>(arg);
GDALDatasetH hDS = nullptr;
for( int iOpenIter = 0; iOpenIter < nOpenIterations; iOpenIter++ )
{
if( hDSIn != nullptr )
{
hDS = hDSIn;
}
else
{
if( bLockOnOpen )
CPLAcquireMutex(pGlobalMutex, 100.0);
hDS = GDALOpen(pszFilename, GA_ReadOnly);
if( bLockOnOpen )
CPLReleaseMutex(pGlobalMutex);
}
for( int iIter = 0; iIter < nIterations && hDS != nullptr; iIter++ )
{
const int nMyChecksum = GDALChecksumImage(GDALGetRasterBand(hDS, 1),
0, 0,
GDALGetRasterXSize(hDS),
GDALGetRasterYSize(hDS));
if( nMyChecksum != nChecksum )
{
printf("Checksum ERROR in worker thread!\n");
break;
}
}
if( hDS && hDSIn == nullptr )
{
if( bLockOnOpen )
CPLAcquireMutex(pGlobalMutex, 100.0);
GDALClose( hDS );
if( bLockOnOpen )
CPLReleaseMutex(pGlobalMutex);
}
else if ( hDSIn != nullptr )
{
GDALFlushCache(hDSIn);
}
}
CPLAcquireMutex(pGlobalMutex, 100.0);
nPendingThreads--;
CPLReleaseMutex(pGlobalMutex);
}
static void WorkerFunc( void * )
{
GDALDatasetH hDS;
int iIter, iOpenIter;
for( iOpenIter = 0; iOpenIter < nOpenIterations; iOpenIter++ )
{
if( bLockOnOpen )
CPLAcquireMutex( pGlobalMutex, 100.0 );
hDS = GDALOpen( pszFilename, GA_ReadOnly );
if( bLockOnOpen )
CPLReleaseMutex( pGlobalMutex );
for( iIter = 0; iIter < nIterations && hDS != NULL; iIter++ )
{
int nMyChecksum;
nMyChecksum = GDALChecksumImage( GDALGetRasterBand( hDS, 1 ),
0, 0,
GDALGetRasterXSize( hDS ),
GDALGetRasterYSize( hDS ) );
if( nMyChecksum != nChecksum )
{
printf( "Checksum ERROR in worker thread!\n" );
break;
}
}
if( hDS )
{
if( bLockOnOpen )
CPLAcquireMutex( pGlobalMutex, 100.0 );
GDALClose( hDS );
if( bLockOnOpen )
CPLReleaseMutex( pGlobalMutex );
}
}
CPLAcquireMutex( pGlobalMutex, 100.0 );
nPendingThreads--;
CPLReleaseMutex( pGlobalMutex );
}
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 );
}
static void test_raw_auto(int bFileMapping)
{
GDALAllRegister();
CPLString osTmpFile;
if( bFileMapping )
osTmpFile = CPLResetExtension(CPLGenerateTempFilename("ehdr"), "img");
else
osTmpFile = "/vsimem/tmp.img";
GDALDatasetH hDS = GDALCreate(GDALGetDriverByName("EHdr"),
osTmpFile.c_str(),
400, 300, 2, GDT_Byte, NULL );
assert(hDS);
int nPixelSpace1;
GIntBig nLineSpace1;
int nPixelSpace2;
GIntBig nLineSpace2;
CPLVirtualMem* pVMem1 = GDALGetVirtualMemAuto(GDALGetRasterBand(hDS, 1),
GF_Write,
&nPixelSpace1,
&nLineSpace1,
NULL);
CPLVirtualMem* pVMem2 = GDALGetVirtualMemAuto(GDALGetRasterBand(hDS, 2),
GF_Write,
&nPixelSpace2,
&nLineSpace2,
NULL);
assert(pVMem1 != NULL);
assert(pVMem2 != NULL);
assert(CPLVirtualMemIsFileMapping(pVMem1) == bFileMapping);
assert(nPixelSpace1 == 1);
if( bFileMapping )
assert(nLineSpace1 == 400 * 2);
else
assert(nLineSpace1 == 400);
GByte* pBase1 = (GByte*) CPLVirtualMemGetAddr(pVMem1);
GByte* pBase2 = (GByte*) CPLVirtualMemGetAddr(pVMem2);
for(int j=0; j<300; j++)
{
for(int i=0; i<400; i++)
{
pBase1[j * nLineSpace1 + i * nPixelSpace1] = 127;
pBase2[j * nLineSpace2 + i * nPixelSpace2] = 255;
}
}
CPLVirtualMemFree(pVMem1);
CPLVirtualMemFree(pVMem2);
GDALClose(hDS);
hDS = GDALOpen(osTmpFile.c_str(), GA_ReadOnly);
assert(GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, 400, 300) == 52906);
assert(GDALChecksumImage(GDALGetRasterBand(hDS, 2), 0, 0, 400, 300) == 30926);
GDALClose(hDS);
GDALDeleteDataset(NULL, osTmpFile.c_str());
}
int main( int argc, char ** argv )
{
int iArg;
/* -------------------------------------------------------------------- */
/* Process arguments. */
/* -------------------------------------------------------------------- */
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
for( iArg = 1; iArg < argc; iArg++ )
{
if( EQUAL(argv[iArg],"-i") && iArg < argc-1 )
nIterations = atoi(argv[++iArg]);
else if( EQUAL(argv[iArg],"-oi") && iArg < argc-1 )
nOpenIterations = atoi(argv[++iArg]);
else if( EQUAL(argv[iArg],"-t") && iArg < argc-1 )
nThreadCount = atoi(argv[++iArg]);
else if( EQUAL(argv[iArg],"-nlo") )
bLockOnOpen = FALSE;
else if( pszFilename == NULL )
pszFilename = argv[iArg];
else
{
printf( "Unrecognised argument: %s\n", argv[iArg] );
Usage();
}
}
if( pszFilename == NULL )
{
printf( "Need a file to operate on.\n" );
Usage();
exit( 1 );
}
if( nOpenIterations > 0 )
bLockOnOpen = FALSE;
/* -------------------------------------------------------------------- */
/* Get the checksum of band1. */
/* -------------------------------------------------------------------- */
GDALDatasetH hDS;
GDALAllRegister();
hDS = GDALOpen( pszFilename, GA_ReadOnly );
if( hDS == NULL )
exit( 1 );
nChecksum = GDALChecksumImage( GDALGetRasterBand( hDS, 1 ),
0, 0,
GDALGetRasterXSize( hDS ),
GDALGetRasterYSize( hDS ) );
GDALClose( hDS );
printf( "Got checksum %d, launching %d worker threads on %s, %d iterations.\n",
nChecksum, nThreadCount, pszFilename, nIterations );
/* -------------------------------------------------------------------- */
/* Fire off worker threads. */
/* -------------------------------------------------------------------- */
int iThread;
pGlobalMutex = CPLCreateMutex();
CPLReleaseMutex( pGlobalMutex );
nPendingThreads = nThreadCount;
for( iThread = 0; iThread < nThreadCount; iThread++ )
{
if( CPLCreateThread( WorkerFunc, NULL ) == -1 )
{
printf( "CPLCreateThread() failed.\n" );
exit( 1 );
}
}
while( nPendingThreads > 0 )
CPLSleep( 0.5 );
CPLReleaseMutex( pGlobalMutex );
printf( "All threads complete.\n" );
CSLDestroy( argv );
GDALDestroyDriverManager();
return 0;
}
int main(int /* argc*/ , char* /* argv */[])
{
int nOvrLevel;
int nBandNum;
GDALDatasetH hDS;
GDALDatasetH hSrcDS;
FILE* f;
const char* pszGDAL_SKIP = CPLGetConfigOption("GDAL_SKIP", NULL);
if( pszGDAL_SKIP == NULL )
CPLSetConfigOption("GDAL_SKIP", "GIF");
else
CPLSetConfigOption("GDAL_SKIP", CPLSPrintf("%s GIF", pszGDAL_SKIP));
GDALAllRegister();
hDS = GDALOpen("../gcore/data/byte.tif", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gcore/data/byte.vrt", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/rgb_warp.vrt", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/A.TOC", GA_ReadOnly);
hDS = GDALOpen("NITF_TOC_ENTRY:CADRG_ONC_1,000,000_2_0:../gdrivers/data/A.TOC", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/testtil.til", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/product.xml", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/METADATA.DIM", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/tmp/cache/file9_j2c.ntf", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/bug407.gif", GA_ReadOnly);
if (hDS)
{
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
GDALSetCacheMax(0);
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
}
/* Create external overviews */
hSrcDS = GDALOpen("../gcore/data/byte.tif", GA_ReadOnly);
hDS = GDALCreateCopy(GDALGetDriverByName("GTiff"), "byte.tif", hSrcDS, 0, NULL, NULL, NULL);
GDALClose(hSrcDS);
hSrcDS = NULL;
hDS = GDALOpen("byte.tif", GA_ReadOnly);
nOvrLevel = 2;
nBandNum = 1;
GDALBuildOverviews( hDS, "NEAR", 1, &nOvrLevel, 1, &nBandNum, NULL, NULL);
GDALClose(hDS);
hDS = GDALOpen("byte.tif", GA_ReadOnly);
GDALGetOverviewCount(GDALGetRasterBand(hDS, 1));
/* Create internal overviews */
hSrcDS = GDALOpen("../gcore/data/byte.tif", GA_ReadOnly);
hDS = GDALCreateCopy(GDALGetDriverByName("GTiff"), "byte2.tif", hSrcDS, 0, NULL, NULL, NULL);
GDALClose(hSrcDS);
hSrcDS = NULL;
hDS = GDALOpen("byte2.tif", GA_Update);
nOvrLevel = 2;
nBandNum = 1;
GDALBuildOverviews( hDS, "NEAR", 1, &nOvrLevel, 1, &nBandNum, NULL, NULL);
GDALClose(hDS);
hDS = GDALOpen("byte2.tif", GA_ReadOnly);
GDALGetOverviewCount(GDALGetRasterBand(hDS, 1));
/* Create external mask */
hSrcDS = GDALOpen("../gcore/data/byte.tif", GA_ReadOnly);
hDS = GDALCreateCopy(GDALGetDriverByName("GTiff"), "byte3.tif", hSrcDS, 0, NULL, NULL, NULL);
GDALClose(hSrcDS);
hSrcDS = NULL;
hDS = GDALOpen("byte3.tif", GA_ReadOnly);
GDALCreateDatasetMaskBand(hDS, GMF_PER_DATASET);
GDALClose(hDS);
hDS = GDALOpen("byte3.tif", GA_ReadOnly);
GDALGetMaskFlags(GDALGetRasterBand(hDS, 1));
f = fopen("byte.vrt", "wb");
fprintf(f, "%s", "<VRTDataset rasterXSize=\"20\" rasterYSize=\"20\">"
"<VRTRasterBand dataType=\"Byte\" band=\"1\">"
"<SimpleSource>"
"<SourceFilename relativeToVRT=\"1\">../gcore/data/byte.tif</SourceFilename>"
"<SourceBand>1</SourceBand>"
"<SourceProperties RasterXSize=\"20\" RasterYSize=\"20\" DataType=\"Byte\" BlockXSize=\"20\" BlockYSize=\"20\" />"
"<SrcRect xOff=\"0\" yOff=\"0\" xSize=\"20\" ySize=\"20\"/>"
"<DstRect xOff=\"0\" yOff=\"0\" xSize=\"20\" ySize=\"20\"/>"
"</SimpleSource>"
"</VRTRasterBand>"
"</VRTDataset>");
fclose(f);
hDS = GDALOpen("byte.vrt", GA_ReadOnly);
nOvrLevel = 2;
nBandNum = 1;
GDALBuildOverviews( hDS, "NEAR", 1, &nOvrLevel, 1, &nBandNum, NULL, NULL);
GDALClose(hDS);
hDS = GDALOpen("byte.vrt", GA_ReadOnly);
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
GDALGetOverviewCount(GDALGetRasterBand(hDS, 1));
hDS = GDALOpen("<VRTDataset rasterXSize=\"20\" rasterYSize=\"20\">"
"<VRTRasterBand dataType=\"Byte\" band=\"1\">"
"<SimpleSource>"
"<SourceFilename relativeToVRT=\"1\">byte.vrt</SourceFilename>"
"<SourceBand>1</SourceBand>"
"<SourceProperties RasterXSize=\"20\" RasterYSize=\"20\" DataType=\"Byte\" BlockXSize=\"20\" BlockYSize=\"20\" />"
"<SrcRect xOff=\"0\" yOff=\"0\" xSize=\"20\" ySize=\"20\"/>"
"<DstRect xOff=\"0\" yOff=\"0\" xSize=\"20\" ySize=\"20\"/>"
"</SimpleSource>"
"</VRTRasterBand>"
"</VRTDataset>", GA_ReadOnly);
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpenShared("../gcore/data/byte.tif", GA_ReadOnly);
hDS = GDALOpenShared("../gcore/data/byte.tif", GA_ReadOnly);
hDS = GDALOpenShared("../gdrivers/data/mercator.sid", GA_ReadOnly);
hDS = GDALOpen("RASTERLITE:../gdrivers/data/rasterlite_pyramids.sqlite,table=test", GA_ReadOnly);
hDS = GDALOpen("RASTERLITE:../gdrivers/data/rasterlite_pyramids.sqlite,table=test,level=1", GA_ReadOnly);
OpenJPEG2000("../gdrivers/data/rgbwcmyk01_YeGeo_kakadu.jp2");
hDS = GDALOpen("../gdrivers/tmp/cache/Europe 2001_OZF.map", GA_ReadOnly);
CPLDebug("TEST","Call GDALDestroyDriverManager()");
GDALDestroyDriverManager();
unlink("byte.tif");
unlink("byte.tif.ovr");
unlink("byte2.tif");
unlink("byte3.tif");
unlink("byte3.tif.msk");
unlink("byte.vrt");
return 0;
}
int main( int argc, char ** argv )
{
/* -------------------------------------------------------------------- */
/* Process arguments. */
/* -------------------------------------------------------------------- */
argc = GDALGeneralCmdLineProcessor(argc, &argv, 0);
if( argc < 1 )
exit(-argc);
int nThreadCount = 4;
bool bOpenInThreads = true;
for( int iArg = 1; iArg < argc; iArg++ )
{
if( iArg < argc-1 && EQUAL(argv[iArg], "-i") )
{
nIterations = atoi(argv[++iArg]);
}
else if( iArg < argc-1 && EQUAL(argv[iArg], "-oi") )
{
nOpenIterations = atoi(argv[++iArg]);
}
else if( iArg < argc-1 && EQUAL(argv[iArg], "-t") )
{
nThreadCount = atoi(argv[++iArg]);
}
else if( EQUAL(argv[iArg], "-lock_on_open") )
{
bLockOnOpen = true;
}
else if( EQUAL(argv[iArg], "-open_in_main") )
{
bOpenInThreads = false;
}
else if( pszFilename == nullptr )
{
pszFilename = argv[iArg];
}
else
{
printf("Unrecognized argument: %s\n", argv[iArg]);
Usage();
}
}
if( pszFilename == nullptr )
{
printf("Need a file to operate on.\n");
Usage();
exit(1);
}
if( nOpenIterations > 0 )
bLockOnOpen = false;
/* -------------------------------------------------------------------- */
/* Get the checksum of band1. */
/* -------------------------------------------------------------------- */
GDALDatasetH hDS = nullptr;
GDALAllRegister();
for( int i = 0; i < 2; i++ )
{
hDS = GDALOpen( pszFilename, GA_ReadOnly );
if( hDS == nullptr )
exit( 1 );
nChecksum = GDALChecksumImage(GDALGetRasterBand(hDS, 1),
0, 0,
GDALGetRasterXSize(hDS),
GDALGetRasterYSize(hDS));
GDALClose(hDS);
}
printf(
"Got checksum %d, launching %d worker threads on %s, %d iterations.\n",
nChecksum, nThreadCount, pszFilename, nIterations);
/* -------------------------------------------------------------------- */
/* Fire off worker threads. */
/* -------------------------------------------------------------------- */
pGlobalMutex = CPLCreateMutex();
CPLReleaseMutex(pGlobalMutex);
nPendingThreads = nThreadCount;
std::vector<GDALDatasetH> aoDS;
for( int iThread = 0; iThread < nThreadCount; iThread++ )
{
hDS = nullptr;
if( !bOpenInThreads )
{
hDS = GDALOpen(pszFilename, GA_ReadOnly);
if( !hDS )
{
printf("GDALOpen() failed.\n");
exit(1);
}
aoDS.push_back(hDS);
}
if( CPLCreateThread(WorkerFunc, hDS) == -1 )
{
printf("CPLCreateThread() failed.\n");
exit(1);
}
}
while( nPendingThreads > 0 )
CPLSleep(0.5);
CPLDestroyMutex(pGlobalMutex);
for( size_t i = 0; i < aoDS.size(); ++i )
GDALClose(aoDS[i]);
printf("All threads complete.\n");
CSLDestroy(argv);
GDALDestroyDriverManager();
return 0;
}
