bool OGRAmigoCloudDataSource::ListDatasets()
{
std::stringstream url;
url << std::string(GetAPIURL()) << "/users/0/projects/" << std::string(GetProjectId()) << "/datasets/?summary";
json_object* result = RunGET(url.str().c_str());
if( result == nullptr ) {
CPLError(CE_Failure, CPLE_AppDefined, "AmigoCloud:get failed.");
return false;
}
if( result != nullptr )
{
auto type = json_object_get_type(result);
if(type == json_type_object)
{
json_object *poResults = CPL_json_object_object_get(result, "results");
if(poResults != nullptr &&
json_object_get_type(poResults) == json_type_array)
{
CPLprintf("List of available datasets for project id: %s\n", GetProjectId());
CPLprintf("| id \t | name\n");
CPLprintf("|--------|-------------------\n");
const auto nSize = json_object_array_length(poResults);
for(auto i = decltype(nSize){0}; i < nSize; ++i) {
json_object *ds = json_object_array_get_idx(poResults, i);
if(ds!=nullptr) {
const char *name = nullptr;
int64_t dataset_id = 0;
json_object *poName = CPL_json_object_object_get(ds, "name");
if (poName != nullptr) {
name = json_object_get_string(poName);
}
json_object *poId = CPL_json_object_object_get(ds, "id");
if (poId != nullptr) {
dataset_id = json_object_get_int64(poId);
}
if (name != nullptr) {
std::stringstream str;
str << "| " << dataset_id << "\t | " << name;
CPLprintf("%s\n", str.str().c_str());
}
}
}
}
}
json_object_put(result);
}
return true;
}
static void ReportOnLayer( OGRLayer * poLayer, int bVerbose )
{
OGRFeatureDefn *poDefn = poLayer->GetLayerDefn();
/* -------------------------------------------------------------------- */
/* Report various overall information. */
/* -------------------------------------------------------------------- */
printf( "\n" );
printf( "Layer name: %s\n", poLayer->GetName() );
if( bVerbose )
{
int nGeomFieldCount =
poLayer->GetLayerDefn()->GetGeomFieldCount();
if( nGeomFieldCount > 1 )
{
for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ )
{
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom);
printf( "Geometry (%s): %s\n", poGFldDefn->GetNameRef(),
OGRGeometryTypeToName( poGFldDefn->GetType() ) );
}
}
else
{
printf( "Geometry: %s\n",
OGRGeometryTypeToName( poLayer->GetGeomType() ) );
}
printf( "Feature Count: " CPL_FRMT_GIB "\n", poLayer->GetFeatureCount() );
OGREnvelope oExt;
if( nGeomFieldCount > 1 )
{
for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ )
{
if (poLayer->GetExtent(iGeom, &oExt, TRUE) == OGRERR_NONE)
{
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom);
CPLprintf("Extent (%s): (%f, %f) - (%f, %f)\n",
poGFldDefn->GetNameRef(),
oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY);
}
}
}
else if ( poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE)
{
CPLprintf("Extent: (%f, %f) - (%f, %f)\n",
oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY);
}
char *pszWKT;
if( nGeomFieldCount > 1 )
{
for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ )
{
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom);
OGRSpatialReference* poSRS = poGFldDefn->GetSpatialRef();
if( poSRS == NULL )
pszWKT = CPLStrdup( "(unknown)" );
else
{
poSRS->exportToPrettyWkt( &pszWKT );
}
printf( "SRS WKT (%s):\n%s\n",
poGFldDefn->GetNameRef(), pszWKT );
CPLFree( pszWKT );
}
}
else
{
if( poLayer->GetSpatialRef() == NULL )
pszWKT = CPLStrdup( "(unknown)" );
else
{
poLayer->GetSpatialRef()->exportToPrettyWkt( &pszWKT );
}
printf( "Layer SRS WKT:\n%s\n", pszWKT );
CPLFree( pszWKT );
}
if( strlen(poLayer->GetFIDColumn()) > 0 )
printf( "FID Column = %s\n",
poLayer->GetFIDColumn() );
for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ )
{
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom);
if( nGeomFieldCount == 1 &&
EQUAL(poGFldDefn->GetNameRef(), "") && poGFldDefn->IsNullable() )
break;
printf( "Geometry Column ");
if( nGeomFieldCount > 1 )
printf("%d ", iGeom + 1);
if( !poGFldDefn->IsNullable() )
printf("NOT NULL ");
printf("= %s\n", poGFldDefn->GetNameRef() );
}
for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ )
{
OGRFieldDefn *poField = poDefn->GetFieldDefn( iAttr );
const char* pszType = (poField->GetSubType() != OFSTNone) ?
CPLSPrintf("%s(%s)",
poField->GetFieldTypeName( poField->GetType() ),
poField->GetFieldSubTypeName(poField->GetSubType())) :
poField->GetFieldTypeName( poField->GetType() );
printf( "%s: %s (%d.%d)",
poField->GetNameRef(),
pszType,
poField->GetWidth(),
poField->GetPrecision() );
if( !poField->IsNullable() )
printf(" NOT NULL");
if( poField->GetDefault() != NULL )
printf(" DEFAULT %s", poField->GetDefault() );
printf( "\n" );
}
}
/* -------------------------------------------------------------------- */
/* Read, and dump features. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature = NULL;
while( (poFeature = poLayer->GetNextFeature()) != NULL )
{
poFeature->DumpReadable( NULL );
OGRFeature::DestroyFeature( poFeature );
}
}
MAIN_START(argc, argv)
{
// 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);
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
const char *pszSrcFilename = nullptr;
const char *pszDstFilename = nullptr;
int nOrder = 0;
void *hTransformArg;
GDALTransformerFunc pfnTransformer = nullptr;
int nGCPCount = 0;
GDAL_GCP *pasGCPs = nullptr;
int bInverse = FALSE;
CPLStringList aosTO;
int bOutputXY = FALSE;
double dfX = 0.0;
double dfY = 0.0;
double dfZ = 0.0;
double dfT = 0.0;
bool bCoordOnCommandLine = false;
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( int i = 1; i < argc && argv[i] != nullptr; 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"));
CSLDestroy(argv);
return 0;
}
else if( EQUAL(argv[i],"--help") )
{
Usage();
}
else if( EQUAL(argv[i],"-t_srs") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszSRS = argv[++i];
if( !IsValidSRS(pszSRS) )
exit(1);
aosTO.SetNameValue("DST_SRS", pszSRS );
}
else if( EQUAL(argv[i],"-s_srs") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszSRS = argv[++i];
if( !IsValidSRS(pszSRS) )
exit(1);
aosTO.SetNameValue("SRC_SRS", pszSRS );
}
else if( EQUAL(argv[i],"-ct") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszCT = argv[++i];
aosTO.SetNameValue("COORDINATE_OPERATION", pszCT );
}
else if( EQUAL(argv[i],"-order") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nOrder = atoi(argv[++i]);
aosTO.SetNameValue("MAX_GCP_ORDER", argv[i] );
}
else if( EQUAL(argv[i],"-tps") )
{
aosTO.SetNameValue("METHOD", "GCP_TPS" );
nOrder = -1;
}
else if( EQUAL(argv[i],"-rpc") )
{
aosTO.SetNameValue("METHOD", "RPC" );
}
else if( EQUAL(argv[i],"-geoloc") )
{
aosTO.SetNameValue("METHOD", "GEOLOC_ARRAY" );
}
else if( EQUAL(argv[i],"-i") )
{
bInverse = TRUE;
}
else if( EQUAL(argv[i],"-to") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
aosTO.AddString( argv[++i] );
}
else if( EQUAL(argv[i],"-gcp") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(4);
char* endptr = nullptr;
/* -gcp pixel line easting northing [elev] */
nGCPCount++;
pasGCPs = static_cast<GDAL_GCP *>(
CPLRealloc(pasGCPs, sizeof(GDAL_GCP) * nGCPCount));
GDALInitGCPs( 1, pasGCPs + nGCPCount - 1 );
pasGCPs[nGCPCount-1].dfGCPPixel = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPLine = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPX = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPY = CPLAtof(argv[++i]);
if( argv[i+1] != nullptr &&
(CPLStrtod(argv[i+1], &endptr) != 0.0 || argv[i+1][0] == '0') )
{
// Check that last argument is really a number and not a
// filename looking like a number (see ticket #863).
if (endptr && *endptr == 0)
pasGCPs[nGCPCount-1].dfGCPZ = CPLAtof(argv[++i]);
}
/* should set id and info? */
}
else if( EQUAL(argv[i],"-output_xy") )
{
bOutputXY = TRUE;
}
else if( EQUAL(argv[i],"-coord") && i + 2 < argc)
{
bCoordOnCommandLine = true;
dfX = CPLAtof(argv[++i]);
dfY = CPLAtof(argv[++i]);
if( i + 1 < argc && CPLGetValueType(argv[i+1]) != CPL_VALUE_STRING )
dfZ = CPLAtof(argv[++i]);
if( i + 1 < argc && CPLGetValueType(argv[i+1]) != CPL_VALUE_STRING )
dfT = CPLAtof(argv[++i]);
}
else if( argv[i][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", argv[i]));
}
else if( pszSrcFilename == nullptr )
{
pszSrcFilename = argv[i];
}
else if( pszDstFilename == nullptr )
{
pszDstFilename = argv[i];
}
else
{
Usage("Too many command options.");
}
}
/* -------------------------------------------------------------------- */
/* Open src and destination file, if appropriate. */
/* -------------------------------------------------------------------- */
GDALDatasetH hSrcDS = nullptr;
if( pszSrcFilename != nullptr )
{
hSrcDS = GDALOpen( pszSrcFilename, GA_ReadOnly );
if( hSrcDS == nullptr )
exit( 1 );
}
GDALDatasetH hDstDS = nullptr;
if( pszDstFilename != nullptr )
{
hDstDS = GDALOpen( pszDstFilename, GA_ReadOnly );
if( hDstDS == nullptr )
exit( 1 );
}
if( hSrcDS != nullptr && nGCPCount > 0 )
{
fprintf(stderr,
"Command line GCPs and input file specified, "
"specify one or the other.\n");
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Create a transformation object from the source to */
/* destination coordinate system. */
/* -------------------------------------------------------------------- */
if( nGCPCount != 0 && nOrder == -1 )
{
pfnTransformer = GDALTPSTransform;
hTransformArg =
GDALCreateTPSTransformer( nGCPCount, pasGCPs, FALSE );
}
else if( nGCPCount != 0 )
{
pfnTransformer = GDALGCPTransform;
hTransformArg =
GDALCreateGCPTransformer( nGCPCount, pasGCPs, nOrder, FALSE );
}
else
{
pfnTransformer = GDALGenImgProjTransform;
hTransformArg =
GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, aosTO.List() );
}
if( hTransformArg == nullptr )
{
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Read points from stdin, transform and write to stdout. */
/* -------------------------------------------------------------------- */
double dfLastT = 0.0;
while( bCoordOnCommandLine || !feof(stdin) )
{
if( !bCoordOnCommandLine )
{
char szLine[1024];
if( fgets( szLine, sizeof(szLine)-1, stdin ) == nullptr )
break;
char **papszTokens = CSLTokenizeString(szLine);
const int nCount = CSLCount(papszTokens);
if( nCount < 2 )
{
CSLDestroy(papszTokens);
continue;
}
dfX = CPLAtof(papszTokens[0]);
dfY = CPLAtof(papszTokens[1]);
if( nCount >= 3 )
dfZ = CPLAtof(papszTokens[2]);
else
dfZ = 0.0;
if( nCount == 4 )
dfT = CPLAtof(papszTokens[3]);
else
dfT = 0.0;
CSLDestroy(papszTokens);
}
if( dfT != dfLastT && nGCPCount == 0 )
{
if( dfT != 0.0 )
{
aosTO.SetNameValue("COORDINATE_EPOCH", CPLSPrintf("%g", dfT));
}
else
{
aosTO.SetNameValue("COORDINATE_EPOCH", nullptr);
}
GDALDestroyGenImgProjTransformer(hTransformArg);
hTransformArg =
GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, aosTO.List() );
}
int bSuccess = TRUE;
if( pfnTransformer( hTransformArg, bInverse, 1,
&dfX, &dfY, &dfZ, &bSuccess )
&& bSuccess )
{
if( bOutputXY )
CPLprintf( "%.15g %.15g\n", dfX, dfY );
else
CPLprintf( "%.15g %.15g %.15g\n", dfX, dfY, dfZ );
}
else
{
printf( "transformation failed.\n" );
}
if( bCoordOnCommandLine )
break;
dfLastT = dfT;
}
if( nGCPCount != 0 && nOrder == -1 )
{
GDALDestroyTPSTransformer(hTransformArg);
}
else if( nGCPCount != 0 )
{
GDALDestroyGCPTransformer(hTransformArg);
}
else
{
GDALDestroyGenImgProjTransformer(hTransformArg);
}
if (nGCPCount)
{
GDALDeinitGCPs( nGCPCount, pasGCPs );
CPLFree( pasGCPs );
}
if (hSrcDS)
GDALClose(hSrcDS);
if (hDstDS)
GDALClose(hDstDS);
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CSLDestroy( argv );
return 0;
}
static void PrintAlgorithmAndOptions( GDALGridAlgorithm eAlgorithm,
void *pOptions )
{
switch ( eAlgorithm )
{
case GGA_InverseDistanceToAPower:
printf( "Algorithm name: \"%s\".\n", szAlgNameInvDist );
CPLprintf( "Options are "
"\"power=%f:smoothing=%f:radius1=%f:radius2=%f:angle=%f"
":max_points=%lu:min_points=%lu:nodata=%f\"\n",
((GDALGridInverseDistanceToAPowerOptions *)pOptions)->dfPower,
((GDALGridInverseDistanceToAPowerOptions *)pOptions)->dfSmoothing,
((GDALGridInverseDistanceToAPowerOptions *)pOptions)->dfRadius1,
((GDALGridInverseDistanceToAPowerOptions *)pOptions)->dfRadius2,
((GDALGridInverseDistanceToAPowerOptions *)pOptions)->dfAngle,
(unsigned long)((GDALGridInverseDistanceToAPowerOptions *)pOptions)->nMaxPoints,
(unsigned long)((GDALGridInverseDistanceToAPowerOptions *)pOptions)->nMinPoints,
((GDALGridInverseDistanceToAPowerOptions *)pOptions)->dfNoDataValue);
break;
case GGA_MovingAverage:
printf( "Algorithm name: \"%s\".\n", szAlgNameAverage );
CPLprintf( "Options are "
"\"radius1=%f:radius2=%f:angle=%f:min_points=%lu"
":nodata=%f\"\n",
((GDALGridMovingAverageOptions *)pOptions)->dfRadius1,
((GDALGridMovingAverageOptions *)pOptions)->dfRadius2,
((GDALGridMovingAverageOptions *)pOptions)->dfAngle,
(unsigned long)((GDALGridMovingAverageOptions *)pOptions)->nMinPoints,
((GDALGridMovingAverageOptions *)pOptions)->dfNoDataValue);
break;
case GGA_NearestNeighbor:
printf( "Algorithm name: \"%s\".\n", szAlgNameNearest );
CPLprintf( "Options are "
"\"radius1=%f:radius2=%f:angle=%f:nodata=%f\"\n",
((GDALGridNearestNeighborOptions *)pOptions)->dfRadius1,
((GDALGridNearestNeighborOptions *)pOptions)->dfRadius2,
((GDALGridNearestNeighborOptions *)pOptions)->dfAngle,
((GDALGridNearestNeighborOptions *)pOptions)->dfNoDataValue);
break;
case GGA_MetricMinimum:
printf( "Algorithm name: \"%s\".\n", szAlgNameMinimum );
CPLprintf( "Options are "
"\"radius1=%f:radius2=%f:angle=%f:min_points=%lu"
":nodata=%f\"\n",
((GDALGridDataMetricsOptions *)pOptions)->dfRadius1,
((GDALGridDataMetricsOptions *)pOptions)->dfRadius2,
((GDALGridDataMetricsOptions *)pOptions)->dfAngle,
(unsigned long)((GDALGridDataMetricsOptions *)pOptions)->nMinPoints,
((GDALGridDataMetricsOptions *)pOptions)->dfNoDataValue);
break;
case GGA_MetricMaximum:
printf( "Algorithm name: \"%s\".\n", szAlgNameMaximum );
CPLprintf( "Options are "
"\"radius1=%f:radius2=%f:angle=%f:min_points=%lu"
":nodata=%f\"\n",
((GDALGridDataMetricsOptions *)pOptions)->dfRadius1,
((GDALGridDataMetricsOptions *)pOptions)->dfRadius2,
((GDALGridDataMetricsOptions *)pOptions)->dfAngle,
(unsigned long)((GDALGridDataMetricsOptions *)pOptions)->nMinPoints,
((GDALGridDataMetricsOptions *)pOptions)->dfNoDataValue);
break;
case GGA_MetricRange:
printf( "Algorithm name: \"%s\".\n", szAlgNameRange );
CPLprintf( "Options are "
"\"radius1=%f:radius2=%f:angle=%f:min_points=%lu"
":nodata=%f\"\n",
((GDALGridDataMetricsOptions *)pOptions)->dfRadius1,
((GDALGridDataMetricsOptions *)pOptions)->dfRadius2,
((GDALGridDataMetricsOptions *)pOptions)->dfAngle,
(unsigned long)((GDALGridDataMetricsOptions *)pOptions)->nMinPoints,
((GDALGridDataMetricsOptions *)pOptions)->dfNoDataValue);
break;
case GGA_MetricCount:
printf( "Algorithm name: \"%s\".\n", szAlgNameCount );
CPLprintf( "Options are "
"\"radius1=%f:radius2=%f:angle=%f:min_points=%lu"
":nodata=%f\"\n",
((GDALGridDataMetricsOptions *)pOptions)->dfRadius1,
((GDALGridDataMetricsOptions *)pOptions)->dfRadius2,
((GDALGridDataMetricsOptions *)pOptions)->dfAngle,
(unsigned long)((GDALGridDataMetricsOptions *)pOptions)->nMinPoints,
((GDALGridDataMetricsOptions *)pOptions)->dfNoDataValue);
break;
case GGA_MetricAverageDistance:
printf( "Algorithm name: \"%s\".\n", szAlgNameAverageDistance );
CPLprintf( "Options are "
"\"radius1=%f:radius2=%f:angle=%f:min_points=%lu"
":nodata=%f\"\n",
((GDALGridDataMetricsOptions *)pOptions)->dfRadius1,
((GDALGridDataMetricsOptions *)pOptions)->dfRadius2,
((GDALGridDataMetricsOptions *)pOptions)->dfAngle,
(unsigned long)((GDALGridDataMetricsOptions *)pOptions)->nMinPoints,
((GDALGridDataMetricsOptions *)pOptions)->dfNoDataValue);
break;
case GGA_MetricAverageDistancePts:
printf( "Algorithm name: \"%s\".\n", szAlgNameAverageDistancePts );
CPLprintf( "Options are "
"\"radius1=%f:radius2=%f:angle=%f:min_points=%lu"
":nodata=%f\"\n",
((GDALGridDataMetricsOptions *)pOptions)->dfRadius1,
((GDALGridDataMetricsOptions *)pOptions)->dfRadius2,
((GDALGridDataMetricsOptions *)pOptions)->dfAngle,
(unsigned long)((GDALGridDataMetricsOptions *)pOptions)->nMinPoints,
((GDALGridDataMetricsOptions *)pOptions)->dfNoDataValue);
break;
default:
printf( "Algorithm is unknown.\n" );
break;
}
}
static CPLErr ProcessLayer( OGRLayerH hSrcLayer, GDALDatasetH hDstDS,
OGRGeometry *poClipSrc,
GUInt32 nXSize, GUInt32 nYSize, int nBand,
int& bIsXExtentSet, int& bIsYExtentSet,
double& dfXMin, double& dfXMax,
double& dfYMin, double& dfYMax,
const char *pszBurnAttribute,
const double dfIncreaseBurnValue,
const double dfMultiplyBurnValue,
GDALDataType eType,
GDALGridAlgorithm eAlgorithm, void *pOptions,
int bQuiet, GDALProgressFunc pfnProgress )
{
/* -------------------------------------------------------------------- */
/* Get field index, and check. */
/* -------------------------------------------------------------------- */
int iBurnField = -1;
if ( pszBurnAttribute )
{
iBurnField = OGR_FD_GetFieldIndex( OGR_L_GetLayerDefn( hSrcLayer ),
pszBurnAttribute );
if( iBurnField == -1 )
{
printf( "Failed to find field %s on layer %s, skipping.\n",
pszBurnAttribute,
OGR_FD_GetName( OGR_L_GetLayerDefn( hSrcLayer ) ) );
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Collect the geometries from this layer, and build list of */
/* values to be interpolated. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeat;
std::vector<double> adfX, adfY, adfZ;
OGR_L_ResetReading( hSrcLayer );
while( (poFeat = (OGRFeature *)OGR_L_GetNextFeature( hSrcLayer )) != NULL )
{
OGRGeometry *poGeom = poFeat->GetGeometryRef();
double dfBurnValue = 0.0;
if ( iBurnField >= 0 )
dfBurnValue = poFeat->GetFieldAsDouble( iBurnField );
ProcessCommonGeometry(poGeom, poClipSrc, iBurnField, dfBurnValue,
dfIncreaseBurnValue, dfMultiplyBurnValue, adfX, adfY, adfZ);
OGRFeature::DestroyFeature( poFeat );
}
if ( adfX.size() == 0 )
{
printf( "No point geometry found on layer %s, skipping.\n",
OGR_FD_GetName( OGR_L_GetLayerDefn( hSrcLayer ) ) );
return CE_None;
}
/* -------------------------------------------------------------------- */
/* Compute grid geometry. */
/* -------------------------------------------------------------------- */
if ( !bIsXExtentSet || !bIsYExtentSet )
{
OGREnvelope sEnvelope;
OGR_L_GetExtent( hSrcLayer, &sEnvelope, TRUE );
if ( !bIsXExtentSet )
{
dfXMin = sEnvelope.MinX;
dfXMax = sEnvelope.MaxX;
bIsXExtentSet = TRUE;
}
if ( !bIsYExtentSet )
{
dfYMin = sEnvelope.MinY;
dfYMax = sEnvelope.MaxY;
bIsYExtentSet = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Perform gridding. */
/* -------------------------------------------------------------------- */
const double dfDeltaX = ( dfXMax - dfXMin ) / nXSize;
const double dfDeltaY = ( dfYMax - dfYMin ) / nYSize;
if ( !bQuiet )
{
printf( "Grid data type is \"%s\"\n", GDALGetDataTypeName(eType) );
printf( "Grid size = (%lu %lu).\n",
(unsigned long)nXSize, (unsigned long)nYSize );
CPLprintf( "Corner coordinates = (%f %f)-(%f %f).\n",
dfXMin - dfDeltaX / 2, dfYMax + dfDeltaY / 2,
dfXMax + dfDeltaX / 2, dfYMin - dfDeltaY / 2 );
CPLprintf( "Grid cell size = (%f %f).\n", dfDeltaX, dfDeltaY );
printf( "Source point count = %lu.\n", (unsigned long)adfX.size() );
PrintAlgorithmAndOptions( eAlgorithm, pOptions );
printf("\n");
}
GDALRasterBandH hBand = GDALGetRasterBand( hDstDS, nBand );
if (adfX.size() == 0)
{
// FIXME: Shoulda' set to nodata value instead
GDALFillRaster( hBand, 0.0 , 0.0 );
return CE_None;
}
GUInt32 nXOffset, nYOffset;
int nBlockXSize, nBlockYSize;
int nDataTypeSize = GDALGetDataTypeSize(eType) / 8;
// Try to grow the work buffer up to 16 MB if it is smaller
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
const GUInt32 nDesiredBufferSize = 16*1024*1024;
if( (GUInt32)nBlockXSize < nXSize && (GUInt32)nBlockYSize < nYSize &&
(GUInt32)nBlockXSize < nDesiredBufferSize / (nBlockYSize * nDataTypeSize) )
{
int nNewBlockXSize = nDesiredBufferSize / (nBlockYSize * nDataTypeSize);
nBlockXSize = (nNewBlockXSize / nBlockXSize) * nBlockXSize;
if( (GUInt32)nBlockXSize > nXSize )
nBlockXSize = nXSize;
}
else if( (GUInt32)nBlockXSize == nXSize && (GUInt32)nBlockYSize < nYSize &&
(GUInt32)nBlockYSize < nDesiredBufferSize / (nXSize * nDataTypeSize) )
{
int nNewBlockYSize = nDesiredBufferSize / (nXSize * nDataTypeSize);
nBlockYSize = (nNewBlockYSize / nBlockYSize) * nBlockYSize;
if( (GUInt32)nBlockYSize > nYSize )
nBlockYSize = nYSize;
}
CPLDebug("GDAL_GRID", "Work buffer: %d * %d", nBlockXSize, nBlockYSize);
void *pData =
VSIMalloc3( nBlockXSize, nBlockYSize, nDataTypeSize );
if( pData == NULL )
{
CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot allocate work buffer");
return CE_Failure;
}
GUInt32 nBlock = 0;
GUInt32 nBlockCount = ((nXSize + nBlockXSize - 1) / nBlockXSize)
* ((nYSize + nBlockYSize - 1) / nBlockYSize);
CPLErr eErr = CE_None;
for ( nYOffset = 0; nYOffset < nYSize && eErr == CE_None; nYOffset += nBlockYSize )
{
for ( nXOffset = 0; nXOffset < nXSize && eErr == CE_None; nXOffset += nBlockXSize )
{
void *pScaledProgress;
pScaledProgress =
GDALCreateScaledProgress( (double)nBlock / nBlockCount,
(double)(nBlock + 1) / nBlockCount,
pfnProgress, NULL );
nBlock ++;
int nXRequest = nBlockXSize;
if (nXOffset + nXRequest > nXSize)
nXRequest = nXSize - nXOffset;
int nYRequest = nBlockYSize;
if (nYOffset + nYRequest > nYSize)
nYRequest = nYSize - nYOffset;
eErr = GDALGridCreate( eAlgorithm, pOptions,
adfX.size(), &(adfX[0]), &(adfY[0]), &(adfZ[0]),
dfXMin + dfDeltaX * nXOffset,
dfXMin + dfDeltaX * (nXOffset + nXRequest),
dfYMin + dfDeltaY * nYOffset,
dfYMin + dfDeltaY * (nYOffset + nYRequest),
nXRequest, nYRequest, eType, pData,
GDALScaledProgress, pScaledProgress );
if( eErr == CE_None )
eErr = GDALRasterIO( hBand, GF_Write, nXOffset, nYOffset,
nXRequest, nYRequest, pData,
nXRequest, nYRequest, eType, 0, 0 );
GDALDestroyScaledProgress( pScaledProgress );
}
}
CPLFree( pData );
return eErr;
}
static void ReportOnLayer( OGRLayer * poLayer, const char *pszWHERE,
const char* pszGeomField,
OGRGeometry *poSpatialFilter,
bool bListMDD,
bool bShowMetadata,
char** papszExtraMDDomains,
bool bFeatureCount,
bool bExtent,
const char* pszWKTFormat )
{
OGRFeatureDefn *poDefn = poLayer->GetLayerDefn();
/* -------------------------------------------------------------------- */
/* Set filters if provided. */
/* -------------------------------------------------------------------- */
if( pszWHERE != nullptr )
{
if( poLayer->SetAttributeFilter(pszWHERE) != OGRERR_NONE )
{
printf("FAILURE: SetAttributeFilter(%s) failed.\n", pszWHERE);
exit(1);
}
}
if( poSpatialFilter != nullptr )
{
if( pszGeomField != nullptr )
{
const int iGeomField = poDefn->GetGeomFieldIndex(pszGeomField);
if( iGeomField >= 0 )
poLayer->SetSpatialFilter(iGeomField, poSpatialFilter);
else
printf("WARNING: Cannot find geometry field %s.\n",
pszGeomField);
}
else
{
poLayer->SetSpatialFilter(poSpatialFilter);
}
}
/* -------------------------------------------------------------------- */
/* Report various overall information. */
/* -------------------------------------------------------------------- */
if( !bSuperQuiet )
{
printf("\n");
printf("Layer name: %s\n", poLayer->GetName());
}
GDALInfoReportMetadata(static_cast<GDALMajorObjectH>(poLayer),
bListMDD,
bShowMetadata,
papszExtraMDDomains);
if( bVerbose )
{
const int nGeomFieldCount =
poLayer->GetLayerDefn()->GetGeomFieldCount();
if( nGeomFieldCount > 1 )
{
for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ )
{
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom);
printf("Geometry (%s): %s\n", poGFldDefn->GetNameRef(),
OGRGeometryTypeToName(poGFldDefn->GetType()));
}
}
else
{
printf("Geometry: %s\n",
OGRGeometryTypeToName(poLayer->GetGeomType()));
}
if( bFeatureCount )
printf("Feature Count: " CPL_FRMT_GIB "\n",
poLayer->GetFeatureCount());
OGREnvelope oExt;
if( bExtent && nGeomFieldCount > 1 )
{
for( int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ )
{
if( poLayer->GetExtent(iGeom, &oExt, TRUE) == OGRERR_NONE )
{
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom);
CPLprintf("Extent (%s): (%f, %f) - (%f, %f)\n",
poGFldDefn->GetNameRef(),
oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY);
}
}
}
else if( bExtent && poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE )
{
CPLprintf("Extent: (%f, %f) - (%f, %f)\n",
oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY);
}
const auto displayDataAxisMapping = [](const OGRSpatialReference* poSRS) {
const auto mapping = poSRS->GetDataAxisToSRSAxisMapping();
printf("Data axis to CRS axis mapping: ");
for( size_t i = 0; i < mapping.size(); i++ )
{
if( i > 0 )
{
printf(",");
}
printf("%d", mapping[i]);
}
printf("\n");
};
if( nGeomFieldCount > 1 )
{
for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ )
{
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom);
OGRSpatialReference* poSRS = poGFldDefn->GetSpatialRef();
char *pszWKT = nullptr;
if( poSRS == nullptr )
{
pszWKT = CPLStrdup("(unknown)");
}
else
{
CPLString osWKTFormat("FORMAT=");
osWKTFormat += pszWKTFormat;
const char* const apszWKTOptions[] =
{ osWKTFormat.c_str(), "MULTILINE=YES", nullptr };
poSRS->exportToWkt(&pszWKT, apszWKTOptions);
}
printf("SRS WKT (%s):\n%s\n",
poGFldDefn->GetNameRef(), pszWKT);
CPLFree(pszWKT);
if( poSRS )
{
displayDataAxisMapping(poSRS);
}
}
}
else
{
char *pszWKT = nullptr;
auto poSRS = poLayer->GetSpatialRef();
if( poSRS == nullptr )
{
pszWKT = CPLStrdup("(unknown)");
}
else
{
poSRS->exportToPrettyWkt(&pszWKT);
}
printf("Layer SRS WKT:\n%s\n", pszWKT);
CPLFree(pszWKT);
if( poSRS )
{
displayDataAxisMapping(poSRS);
}
}
if( strlen(poLayer->GetFIDColumn()) > 0 )
printf("FID Column = %s\n",
poLayer->GetFIDColumn());
for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ )
{
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom);
if( nGeomFieldCount == 1 &&
EQUAL(poGFldDefn->GetNameRef(), "") &&
poGFldDefn->IsNullable() )
break;
printf("Geometry Column ");
if( nGeomFieldCount > 1 )
printf("%d ", iGeom + 1);
if( !poGFldDefn->IsNullable() )
printf("NOT NULL ");
printf("= %s\n", poGFldDefn->GetNameRef());
}
for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ )
{
OGRFieldDefn *poField = poDefn->GetFieldDefn(iAttr);
const char* pszType = (poField->GetSubType() != OFSTNone)
? CPLSPrintf(
"%s(%s)",
poField->GetFieldTypeName(poField->GetType()),
poField->GetFieldSubTypeName(poField->GetSubType()))
: poField->GetFieldTypeName(poField->GetType());
printf("%s: %s (%d.%d)",
poField->GetNameRef(),
pszType,
poField->GetWidth(),
poField->GetPrecision());
if( !poField->IsNullable() )
printf(" NOT NULL");
if( poField->GetDefault() != nullptr )
printf(" DEFAULT %s", poField->GetDefault());
printf("\n");
}
}
/* -------------------------------------------------------------------- */
/* Read, and dump features. */
/* -------------------------------------------------------------------- */
if( nFetchFID == OGRNullFID && !bSummaryOnly )
{
OGRFeature *poFeature = nullptr;
while( (poFeature = poLayer->GetNextFeature()) != nullptr )
{
if( !bSuperQuiet )
poFeature->DumpReadable(nullptr, papszOptions);
OGRFeature::DestroyFeature(poFeature);
}
}
else if( nFetchFID != OGRNullFID )
{
OGRFeature *poFeature = poLayer->GetFeature(nFetchFID);
if( poFeature == nullptr )
{
printf("Unable to locate feature id " CPL_FRMT_GIB
" on this layer.\n",
nFetchFID);
}
else
{
poFeature->DumpReadable(nullptr, papszOptions);
OGRFeature::DestroyFeature(poFeature);
}
}
}