const char * E00GRIDRasterBand::GetUnitType()
{
E00GRIDDataset *poGDS = (E00GRIDDataset *) poDS;
poGDS->ReadMetadata();
if (poGDS->papszPrj == NULL)
return GDALPamRasterBand::GetUnitType();
char** papszIter = poGDS->papszPrj;
const char* pszRet = "";
while(*papszIter)
{
if (STARTS_WITH_CI(*papszIter, "Zunits"))
{
char** papszTokens = CSLTokenizeString(*papszIter);
if (CSLCount(papszTokens) == 2)
{
if (EQUAL(papszTokens[1], "FEET"))
pszRet = "ft";
else if (EQUAL(papszTokens[1], "METERS"))
pszRet = "m";
}
CSLDestroy(papszTokens);
break;
}
papszIter ++;
}
return pszRet;
}
GBool MIDDATAFile::IsValidFeature(const char *pszString)
{
char **papszToken ;
papszToken = CSLTokenizeString(pszString);
// printf("%s\n",pszString);
if (CSLCount(papszToken) == 0)
{
CSLDestroy(papszToken);
return FALSE;
}
if (EQUAL(papszToken[0],"NONE") || EQUAL(papszToken[0],"POINT") ||
EQUAL(papszToken[0],"LINE") || EQUAL(papszToken[0],"PLINE") ||
EQUAL(papszToken[0],"REGION") || EQUAL(papszToken[0],"ARC") ||
EQUAL(papszToken[0],"TEXT") || EQUAL(papszToken[0],"RECT") ||
EQUAL(papszToken[0],"ROUNDRECT") || EQUAL(papszToken[0],"ELLIPSE") ||
EQUAL(papszToken[0],"MULTIPOINT")|| EQUAL(papszToken[0],"COLLECTION") )
{
CSLDestroy(papszToken);
return TRUE;
}
CSLDestroy(papszToken);
return FALSE;
}
static CPLString OSR_GDS( char **papszNV, const char *pszField,
const char *pszDefaultValue )
{
if( papszNV == nullptr || papszNV[0] == nullptr )
return pszDefaultValue;
int iLine = 0; // Used after for.
for( ;
papszNV[iLine] != nullptr &&
!EQUALN(papszNV[iLine],pszField,strlen(pszField));
iLine++ ) {}
if( papszNV[iLine] == nullptr )
return pszDefaultValue;
else
{
char **papszTokens = CSLTokenizeString(papszNV[iLine]);
CPLString osResult;
if( CSLCount(papszTokens) > 1 )
osResult = papszTokens[1];
else
osResult = pszDefaultValue;
CSLDestroy(papszTokens);
return osResult;
}
}
void CheckExtensionConsistency(const char* pszDestFilename,
const char* pszDriverName)
{
char* pszDestExtension = CPLStrdup(CPLGetExtension(pszDestFilename));
if (pszDestExtension[0] != '\0')
{
int nDriverCount = GDALGetDriverCount();
CPLString osConflictingDriverList;
for(int i=0;i<nDriverCount;i++)
{
GDALDriverH hDriver = GDALGetDriver(i);
const char* pszDriverExtensions =
GDALGetMetadataItem( hDriver, GDAL_DMD_EXTENSIONS, NULL );
if( pszDriverExtensions )
{
char** papszTokens = CSLTokenizeString( pszDriverExtensions );
for(int j=0; papszTokens[j]; j++)
{
const char* pszDriverExtension = papszTokens[j];
if (EQUAL(pszDestExtension, pszDriverExtension))
{
if (GDALGetDriverByName(pszDriverName) != hDriver)
{
if (osConflictingDriverList.size())
osConflictingDriverList += ", ";
osConflictingDriverList += GDALGetDriverShortName(hDriver);
}
else
{
/* If the request driver allows the used extension, then */
/* just stop iterating now */
osConflictingDriverList = "";
break;
}
}
}
CSLDestroy(papszTokens);
}
}
if (osConflictingDriverList.size())
{
fprintf(stderr,
"Warning: The target file has a '%s' extension, which is normally used by the %s driver%s,\n"
"but the requested output driver is %s. Is it really what you want ?\n",
pszDestExtension,
osConflictingDriverList.c_str(),
strchr(osConflictingDriverList.c_str(), ',') ? "s" : "",
pszDriverName);
}
}
CPLFree(pszDestExtension);
}
CPLErr VRTKernelFilteredSource::XMLInit( CPLXMLNode *psTree,
const char *pszVRTPath,
void* pUniqueHandle,
std::map<CPLString, GDALDataset*>& oMapSharedSources )
{
{
const CPLErr eErr = VRTFilteredSource::XMLInit( psTree, pszVRTPath,
pUniqueHandle,
oMapSharedSources );
if( eErr != CE_None )
return eErr;
}
const int nNewKernelSize = atoi(CPLGetXMLValue(psTree,"Kernel.Size","0"));
if( nNewKernelSize == 0 )
return CE_None;
char **papszCoefItems =
CSLTokenizeString( CPLGetXMLValue(psTree,"Kernel.Coefs","") );
const int nCoefs = CSLCount(papszCoefItems);
const bool bSquare = nCoefs == nNewKernelSize * nNewKernelSize;
const bool bSeparable = nCoefs == nNewKernelSize && nCoefs != 1;
if( !bSquare && !bSeparable )
{
CSLDestroy( papszCoefItems );
CPLError( CE_Failure, CPLE_AppDefined,
"Got wrong number of filter kernel coefficients (%s). "
"Expected %d or %d, got %d.",
CPLGetXMLValue(psTree,"Kernel.Coefs",""),
nNewKernelSize * nNewKernelSize, nNewKernelSize, nCoefs );
return CE_Failure;
}
double *padfNewCoefs = static_cast<double *>(
CPLMalloc( sizeof(double) * nCoefs ) );
for( int i = 0; i < nCoefs; i++ )
padfNewCoefs[i] = CPLAtof(papszCoefItems[i]);
const CPLErr eErr = SetKernel( nNewKernelSize, bSeparable, padfNewCoefs );
CPLFree( padfNewCoefs );
CSLDestroy( papszCoefItems );
SetNormalized( atoi(CPLGetXMLValue(psTree,"Kernel.normalized","0")) );
return eErr;
}
std::vector<double>
OGRDXFWriterLayer::PrepareLineTypeDefinition( OGRStylePen *poPen )
{
/* -------------------------------------------------------------------- */
/* Fetch pattern. */
/* -------------------------------------------------------------------- */
GBool bDefault;
const char *pszPattern = poPen->Pattern( bDefault );
if( bDefault || strlen(pszPattern) == 0 )
return std::vector<double>();
/* -------------------------------------------------------------------- */
/* Split into pen up / pen down bits. */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString(pszPattern);
std::vector<double> adfWeightTokens;
for( int i = 0; papszTokens != nullptr && papszTokens[i] != nullptr; i++ )
{
const char *pszToken = papszTokens[i];
CPLString osAmount;
CPLString osDXFEntry;
// Split amount and unit.
const char *pszUnit = pszToken; // Used after for.
for( ;
strchr( "0123456789.", *pszUnit) != nullptr;
pszUnit++ ) {}
osAmount.assign(pszToken,(int) (pszUnit-pszToken));
// If the unit is other than 'g' we really should be trying to
// do some type of transformation - but what to do? Pretty hard.
// Even entries are "pen down" represented as positive in DXF.
// "Pen up" entries (gaps) are represented as negative.
if( i%2 == 0 )
adfWeightTokens.push_back( CPLAtof( osAmount ) );
else
adfWeightTokens.push_back( -CPLAtof( osAmount ) );
}
CSLDestroy( papszTokens );
return adfWeightTokens;
}
void OGRXPlaneNavReader::Read()
{
const char* pszLine = NULL;
while( (pszLine = CPLReadLineL(fp)) != NULL )
{
papszTokens = CSLTokenizeString(pszLine);
nTokens = CSLCount(papszTokens);
nLineNumber++;
if (nTokens == 1 && strcmp(papszTokens[0], "99") == 0)
{
CSLDestroy(papszTokens);
papszTokens = NULL;
bEOF = true;
return;
}
else if( nTokens == 0 || !assertMinCol(9) )
{
CSLDestroy(papszTokens);
papszTokens = NULL;
continue;
}
const int nType = atoi(papszTokens[0]);
if (!((nType >= NAVAID_NDB && nType <= NAVAID_IM) ||
nType == NAVAID_DME_COLOC || nType == NAVAID_DME_STANDALONE))
{
CPLDebug("XPlane", "Line %d : bad feature code '%s'",
nLineNumber, papszTokens[0]);
CSLDestroy(papszTokens);
papszTokens = NULL;
continue;
}
ParseRecord(nType);
CSLDestroy(papszTokens);
papszTokens = NULL;
if( poInterestLayer && !poInterestLayer->IsEmpty() )
return;
}
papszTokens = NULL;
bEOF = true;
}
CPLErr VRTKernelFilteredSource::XMLInit( CPLXMLNode *psTree,
const char *pszVRTPath )
{
CPLErr eErr = VRTFilteredSource::XMLInit( psTree, pszVRTPath );
int nNewKernelSize, i, nCoefs;
double *padfNewCoefs;
if( eErr != CE_None )
return eErr;
nNewKernelSize = atoi(CPLGetXMLValue(psTree,"Kernel.Size","0"));
if( nNewKernelSize == 0 )
return CE_None;
char **papszCoefItems =
CSLTokenizeString( CPLGetXMLValue(psTree,"Kernel.Coefs","") );
nCoefs = CSLCount(papszCoefItems);
if( nCoefs != nNewKernelSize * nNewKernelSize )
{
CSLDestroy( papszCoefItems );
CPLError( CE_Failure, CPLE_AppDefined,
"Got wrong number of filter kernel coefficients (%s).\n"
"Expected %d, got %d.",
CPLGetXMLValue(psTree,"Kernel.Coefs",""),
nNewKernelSize * nNewKernelSize, nCoefs );
return CE_Failure;
}
padfNewCoefs = (double *) CPLMalloc(sizeof(double) * nCoefs);
for( i = 0; i < nCoefs; i++ )
padfNewCoefs[i] = CPLAtof(papszCoefItems[i]);
eErr = SetKernel( nNewKernelSize, padfNewCoefs );
CPLFree( padfNewCoefs );
CSLDestroy( papszCoefItems );
SetNormalized( atoi(CPLGetXMLValue(psTree,"Kernel.normalized","0")) );
return eErr;
}
char *PAuxDataset::PCI2WKT( const char *pszGeosys,
const char *pszProjParms )
{
OGRSpatialReference oSRS;
while( *pszGeosys == ' ' )
pszGeosys++;
/* -------------------------------------------------------------------- */
/* Parse projection parameters array. */
/* -------------------------------------------------------------------- */
double adfProjParms[16];
memset( adfProjParms, 0, sizeof(adfProjParms) );
if( pszProjParms != NULL )
{
char **papszTokens;
int i;
papszTokens = CSLTokenizeString( pszProjParms );
for( i=0; papszTokens != NULL && papszTokens[i] != NULL && i < 16; i++)
adfProjParms[i] = atof(papszTokens[i]);
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Convert to SRS. */
/* -------------------------------------------------------------------- */
if( oSRS.importFromPCI( pszGeosys, NULL, adfProjParms ) == OGRERR_NONE )
{
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
return pszResult;
}
else
return NULL;
}
static bool DoesDriverHandleExtension( GDALDriverH hDriver, const char* pszExt )
{
bool bRet = false;
const char* pszDriverExtensions =
GDALGetMetadataItem( hDriver, GDAL_DMD_EXTENSIONS, NULL );
if( pszDriverExtensions )
{
char** papszTokens = CSLTokenizeString( pszDriverExtensions );
for(int j=0; papszTokens[j]; j++)
{
if( EQUAL(pszExt, papszTokens[j]) )
{
bRet = true;
break;
}
}
CSLDestroy(papszTokens);
}
return bRet;
}
char *PAuxDataset::PCI2WKT( const char *pszGeosys,
const char *pszProjParms )
{
while( *pszGeosys == ' ' )
pszGeosys++;
/* -------------------------------------------------------------------- */
/* Parse projection parameters array. */
/* -------------------------------------------------------------------- */
double adfProjParms[16] = { 0.0 };
if( pszProjParms != nullptr )
{
char **papszTokens = CSLTokenizeString( pszProjParms );
for( int i = 0;
i < 16 && papszTokens != nullptr && papszTokens[i] != nullptr;
i++ )
adfProjParms[i] = CPLAtof(papszTokens[i]);
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Convert to SRS. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
if( oSRS.importFromPCI( pszGeosys, nullptr, adfProjParms ) == OGRERR_NONE )
{
char *pszResult = nullptr;
oSRS.exportToWkt( &pszResult );
return pszResult;
}
return nullptr;
}
OGRLayer* OGRTABDataSource::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
char **papszTokens = CSLTokenizeString(pszStatement);
if( CSLCount(papszTokens) == 6 &&
EQUAL(papszTokens[0], "CREATE") &&
EQUAL(papszTokens[1], "INDEX") &&
EQUAL(papszTokens[2], "ON") &&
EQUAL(papszTokens[4], "USING") )
{
IMapInfoFile* poLayer = dynamic_cast<IMapInfoFile*>(
GetLayerByName(papszTokens[3]));
if( poLayer == nullptr )
{
CPLError(CE_Failure, CPLE_AppDefined,
"`%s' failed failed, no such layer as `%s'.",
pszStatement, papszTokens[3]);
CSLDestroy(papszTokens);
return nullptr;
}
int nFieldIdx = poLayer->GetLayerDefn()->GetFieldIndex(papszTokens[5]);
CSLDestroy(papszTokens);
if( nFieldIdx < 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"`%s' failed, field not found.",
pszStatement);
return nullptr;
}
poLayer->SetFieldIndexed(nFieldIdx);
return nullptr;
}
CSLDestroy(papszTokens);
return GDALDataset::ExecuteSQL(pszStatement, poSpatialFilter, pszDialect);
}
void OGRXPlaneFixReader::Read()
{
const char* pszLine;
while((pszLine = CPLReadLine(fp)) != NULL)
{
papszTokens = CSLTokenizeString(pszLine);
nTokens = CSLCount(papszTokens);
nLineNumber ++;
if (nTokens == 1 && strcmp(papszTokens[0], "99") == 0)
{
CSLDestroy(papszTokens);
papszTokens = NULL;
bEOF = TRUE;
return;
}
else if (nTokens == 0 || assertMinCol(3) == FALSE)
{
CSLDestroy(papszTokens);
papszTokens = NULL;
continue;
}
ParseRecord();
CSLDestroy(papszTokens);
papszTokens = NULL;
if (poInterestLayer && poInterestLayer->IsEmpty() == FALSE)
return;
}
papszTokens = NULL;
bEOF = TRUE;
}
int OGRGPSBabelDataSource::Open( const char * pszDatasourceName,
const char* pszGPSBabelDriverNameIn,
char** papszOpenOptionsIn )
{
if (!STARTS_WITH_CI(pszDatasourceName, "GPSBABEL:"))
{
CPLAssert(pszGPSBabelDriverNameIn);
pszGPSBabelDriverName = CPLStrdup(pszGPSBabelDriverNameIn);
pszFilename = CPLStrdup(pszDatasourceName);
}
else
{
if( CSLFetchNameValue(papszOpenOptionsIn, "FILENAME") )
pszFilename = CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn,
"FILENAME"));
if( CSLFetchNameValue(papszOpenOptionsIn, "GPSBABEL_DRIVER") )
{
if( pszFilename == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined, "Missing FILENAME");
return FALSE;
}
pszGPSBabelDriverName
= CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn, "DRIVER"));
/* A bit of validation to avoid command line injection */
if (!IsValidDriverName(pszGPSBabelDriverName))
return FALSE;
}
}
pszName = CPLStrdup( pszDatasourceName );
bool bExplicitFeatures = false;
bool bWaypoints = true;
bool bTracks = true;
bool bRoutes = true;
if (pszGPSBabelDriverName == NULL)
{
const char* pszSep = strchr(pszDatasourceName + 9, ':');
if (pszSep == NULL)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Wrong syntax. Expected GPSBabel:driver_name:file_name");
return FALSE;
}
pszGPSBabelDriverName = CPLStrdup(pszDatasourceName + 9);
*(strchr(pszGPSBabelDriverName, ':')) = '\0';
/* A bit of validation to avoid command line injection */
if (!IsValidDriverName(pszGPSBabelDriverName))
return FALSE;
/* Parse optional features= option */
if (STARTS_WITH_CI(pszSep+1, "features="))
{
const char* pszNextSep = strchr(pszSep+1, ':');
if (pszNextSep == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Wrong syntax. Expected "
"GPSBabel:driver_name[,options]*:["
"features=waypoints,tracks,routes:]file_name");
return FALSE;
}
char* pszFeatures = CPLStrdup(pszSep+1+9);
*strchr(pszFeatures, ':') = 0;
char** papszTokens = CSLTokenizeString(pszFeatures);
char** papszIter = papszTokens;
bool bErr = false;
bExplicitFeatures = true;
bWaypoints = false;
bTracks = false;
bRoutes = false;
while(papszIter && *papszIter)
{
if (EQUAL(*papszIter, "waypoints"))
bWaypoints = true;
else if (EQUAL(*papszIter, "tracks"))
bTracks = true;
else if (EQUAL(*papszIter, "routes"))
bRoutes = true;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Wrong value for 'features' options");
bErr = true;
}
papszIter++;
}
CSLDestroy(papszTokens);
CPLFree(pszFeatures);
if (bErr)
return FALSE;
pszSep = pszNextSep;
}
if( pszFilename == NULL )
pszFilename = CPLStrdup(pszSep+1);
}
const char* pszOptionUseTempFile = CPLGetConfigOption("USE_TEMPFILE", NULL);
if (pszOptionUseTempFile && CPLTestBool(pszOptionUseTempFile))
osTmpFileName = CPLGenerateTempFilename(NULL);
else
osTmpFileName.Printf("/vsimem/ogrgpsbabeldatasource_%p", this);
bool bRet = false;
if (IsSpecialFile(pszFilename))
{
/* Special file : don't try to open it */
char** argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes,
bTracks, pszGPSBabelDriverName, pszFilename);
VSILFILE* tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb");
bRet = (CPLSpawn(argv, NULL, tmpfp, TRUE) == 0);
VSIFCloseL(tmpfp);
tmpfp = NULL;
CSLDestroy(argv);
argv = NULL;
}
else
{
VSILFILE* fp = VSIFOpenL(pszFilename, "rb");
if (fp == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot open file %s", pszFilename);
return FALSE;
}
char** argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes,
bTracks, pszGPSBabelDriverName, "-");
VSILFILE* tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb");
CPLPushErrorHandler(CPLQuietErrorHandler);
bRet = (CPLSpawn(argv, fp, tmpfp, TRUE) == 0);
CPLPopErrorHandler();
CSLDestroy(argv);
argv = NULL;
CPLErr nLastErrorType = CPLGetLastErrorType();
CPLErrorNum nLastErrorNo = CPLGetLastErrorNo();
CPLString osLastErrorMsg = CPLGetLastErrorMsg();
VSIFCloseL(tmpfp);
tmpfp = NULL;
VSIFCloseL(fp);
fp = NULL;
if (!bRet)
{
if ( strstr(osLastErrorMsg.c_str(),
"This format cannot be used in piped commands") == NULL)
{
CPLError( nLastErrorType, nLastErrorNo, "%s",
osLastErrorMsg.c_str());
}
else
{
VSIStatBuf sStatBuf;
if (VSIStat(pszFilename, &sStatBuf) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Driver %s only supports real (non virtual) "
"files",
pszGPSBabelDriverName );
return FALSE;
}
/* Try without piping in */
argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes,
bTracks, pszGPSBabelDriverName, pszFilename);
tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb");
bRet = (CPLSpawn(argv, NULL, tmpfp, TRUE) == 0);
VSIFCloseL(tmpfp);
tmpfp = NULL;
CSLDestroy(argv);
argv = NULL;
}
}
}
if (bRet)
{
poGPXDS = static_cast<GDALDataset *>(
GDALOpenEx( osTmpFileName.c_str(),
GDAL_OF_VECTOR, NULL, NULL, NULL ) );
if (poGPXDS)
{
if (bWaypoints)
{
OGRLayer* poLayer = poGPXDS->GetLayerByName("waypoints");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
}
if (bRoutes)
{
OGRLayer* poLayer = poGPXDS->GetLayerByName("routes");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
poLayer = poGPXDS->GetLayerByName("route_points");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
}
if (bTracks)
{
OGRLayer* poLayer = poGPXDS->GetLayerByName("tracks");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
poLayer = poGPXDS->GetLayerByName("track_points");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
}
}
}
return nLayers > 0;
}
OGRLayer * OGRShapeDataSource::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* ==================================================================== */
/* Handle command to drop a spatial index. */
/* ==================================================================== */
if( EQUALN(pszStatement, "REPACK ", 7) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 7 );
if( poLayer != NULL )
poLayer->Repack();
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in REPACK.",
pszStatement + 7 );
}
return NULL;
}
/* ==================================================================== */
/* Handle command to drop a spatial index. */
/* ==================================================================== */
if( EQUALN(pszStatement, "DROP SPATIAL INDEX ON ", 22) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 22 );
if( poLayer != NULL )
poLayer->DropSpatialIndex();
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in DROP SPATIAL INDEX.",
pszStatement + 19 );
}
return NULL;
}
/* ==================================================================== */
/* Handle all comands except spatial index creation generically. */
/* ==================================================================== */
if( !EQUALN(pszStatement,"CREATE SPATIAL INDEX ON ",24) )
return OGRDataSource::ExecuteSQL( pszStatement, poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Parse into keywords. */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString( pszStatement );
if( CSLCount(papszTokens) < 5
|| !EQUAL(papszTokens[0],"CREATE")
|| !EQUAL(papszTokens[1],"SPATIAL")
|| !EQUAL(papszTokens[2],"INDEX")
|| !EQUAL(papszTokens[3],"ON")
|| CSLCount(papszTokens) > 7
|| (CSLCount(papszTokens) == 7 && !EQUAL(papszTokens[5],"DEPTH")) )
{
CSLDestroy( papszTokens );
CPLError( CE_Failure, CPLE_AppDefined,
"Syntax error in CREATE SPATIAL INDEX command.\n"
"Was '%s'\n"
"Should be of form 'CREATE SPATIAL INDEX ON <table> [DEPTH <n>]'",
pszStatement );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Get depth if provided. */
/* -------------------------------------------------------------------- */
int nDepth = 0;
if( CSLCount(papszTokens) == 7 )
nDepth = atoi(papszTokens[6]);
/* -------------------------------------------------------------------- */
/* What layer are we operating on. */
/* -------------------------------------------------------------------- */
OGRShapeLayer *poLayer = (OGRShapeLayer *) GetLayerByName(papszTokens[4]);
CSLDestroy( papszTokens );
if( poLayer == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s not recognised.",
papszTokens[4] );
return NULL;
}
poLayer->CreateSpatialIndex( nDepth );
return NULL;
}
int main( int argc, char ** argv )
{
const char *pszSrcFilename = NULL;
const char *pszDstFilename = NULL;
int nOrder = 0;
void *hTransformArg;
GDALTransformerFunc pfnTransformer = NULL;
int nGCPCount = 0;
GDAL_GCP *pasGCPs = NULL;
int bInverse = FALSE;
char **papszTO = 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);
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
int i;
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],"-t_srs") && i < argc-1 )
{
char *pszSRS = SanitizeSRS(argv[++i]);
papszTO = CSLSetNameValue( papszTO, "DST_SRS", pszSRS );
CPLFree( pszSRS );
}
else if( EQUAL(argv[i],"-s_srs") && i < argc-1 )
{
char *pszSRS = SanitizeSRS(argv[++i]);
papszTO = CSLSetNameValue( papszTO, "SRC_SRS", pszSRS );
CPLFree( pszSRS );
}
else if( EQUAL(argv[i],"-order") && i < argc-1 )
{
nOrder = atoi(argv[++i]);
papszTO = CSLSetNameValue( papszTO, "MAX_GCP_ORDER", argv[i] );
}
else if( EQUAL(argv[i],"-tps") )
{
papszTO = CSLSetNameValue( papszTO, "METHOD", "GCP_TPS" );
nOrder = -1;
}
else if( EQUAL(argv[i],"-rpc") )
{
papszTO = CSLSetNameValue( papszTO, "METHOD", "RPC" );
}
else if( EQUAL(argv[i],"-geoloc") )
{
papszTO = CSLSetNameValue( papszTO, "METHOD", "GEOLOC_ARRAY" );
}
else if( EQUAL(argv[i],"-i") )
{
bInverse = TRUE;
}
else if( EQUAL(argv[i],"-to") && i < argc-1 )
{
papszTO = CSLAddString( papszTO, argv[++i] );
}
else if( EQUAL(argv[i],"-gcp") && i < argc - 4 )
{
char* endptr = NULL;
/* -gcp pixel line easting northing [elev] */
nGCPCount++;
pasGCPs = (GDAL_GCP *)
CPLRealloc( pasGCPs, sizeof(GDAL_GCP) * nGCPCount );
GDALInitGCPs( 1, pasGCPs + nGCPCount - 1 );
pasGCPs[nGCPCount-1].dfGCPPixel = atof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPLine = atof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPX = atof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPY = atof(argv[++i]);
if( argv[i+1] != NULL
&& (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 = atof(argv[++i]);
}
/* should set id and info? */
}
else if( argv[i][0] == '-' )
Usage();
else if( pszSrcFilename == NULL )
pszSrcFilename = argv[i];
else if( pszDstFilename == NULL )
pszDstFilename = argv[i];
else
Usage();
}
/* -------------------------------------------------------------------- */
/* Open src and destination file, if appropriate. */
/* -------------------------------------------------------------------- */
GDALDatasetH hSrcDS = NULL, hDstDS = NULL;
if( pszSrcFilename != NULL )
{
hSrcDS = GDALOpen( pszSrcFilename, GA_ReadOnly );
if( hSrcDS == NULL )
exit( 1 );
}
if( pszDstFilename != NULL )
{
hDstDS = GDALOpen( pszDstFilename, GA_ReadOnly );
if( hDstDS == NULL )
exit( 1 );
}
if( hSrcDS != NULL && nGCPCount > 0 )
{
fprintf( stderr, "Commandline 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, papszTO );
}
CSLDestroy( papszTO );
if( hTransformArg == NULL )
{
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Read points from stdin, transform and write to stdout. */
/* -------------------------------------------------------------------- */
while( !feof(stdin) )
{
char szLine[1024];
if( fgets( szLine, sizeof(szLine)-1, stdin ) == NULL )
break;
char **papszTokens = CSLTokenizeString(szLine);
double dfX, dfY, dfZ = 0.0;
int bSuccess = TRUE;
if( CSLCount(papszTokens) < 2 )
{
CSLDestroy(papszTokens);
continue;
}
dfX = atof(papszTokens[0]);
dfY = atof(papszTokens[1]);
if( CSLCount(papszTokens) >= 3 )
dfZ = atof(papszTokens[2]);
if( pfnTransformer( hTransformArg, bInverse, 1,
&dfX, &dfY, &dfZ, &bSuccess )
&& bSuccess )
{
printf( "%.15g %.15g %.15g\n", dfX, dfY, dfZ );
}
else
{
printf( "transformation failed.\n" );
}
CSLDestroy(papszTokens);
}
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;
}
OGRLayer * OGRShapeDataSource::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* ==================================================================== */
/* Handle command to drop a spatial index. */
/* ==================================================================== */
if( EQUALN(pszStatement, "REPACK ", 7) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 7 );
if( poLayer != NULL )
{
if( poLayer->Repack() != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"REPACK of layer '%s' failed.",
pszStatement + 7 );
}
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in REPACK.",
pszStatement + 7 );
}
return NULL;
}
/* ==================================================================== */
/* Handle command to shrink columns to their minimum size. */
/* ==================================================================== */
if( EQUALN(pszStatement, "RESIZE ", 7) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 7 );
if( poLayer != NULL )
poLayer->ResizeDBF();
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in RESIZE.",
pszStatement + 7 );
}
return NULL;
}
/* ==================================================================== */
/* Handle command to recompute extent */
/* ==================================================================== */
if( EQUALN(pszStatement, "RECOMPUTE EXTENT ON ", 20) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 20 );
if( poLayer != NULL )
poLayer->RecomputeExtent();
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in RECOMPUTE EXTENT.",
pszStatement + 20 );
}
return NULL;
}
/* ==================================================================== */
/* Handle command to drop a spatial index. */
/* ==================================================================== */
if( EQUALN(pszStatement, "DROP SPATIAL INDEX ON ", 22) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 22 );
if( poLayer != NULL )
poLayer->DropSpatialIndex();
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in DROP SPATIAL INDEX.",
pszStatement + 22 );
}
return NULL;
}
/* ==================================================================== */
/* Handle all comands except spatial index creation generically. */
/* ==================================================================== */
if( !EQUALN(pszStatement,"CREATE SPATIAL INDEX ON ",24) )
{
char **papszTokens = CSLTokenizeString( pszStatement );
if( CSLCount(papszTokens) >=4
&& (EQUAL(papszTokens[0],"CREATE") || EQUAL(papszTokens[0],"DROP"))
&& EQUAL(papszTokens[1],"INDEX")
&& EQUAL(papszTokens[2],"ON") )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *) GetLayerByName(papszTokens[3]);
if (poLayer != NULL)
poLayer->InitializeIndexSupport( poLayer->GetFullName() );
}
CSLDestroy( papszTokens );
return OGRDataSource::ExecuteSQL( pszStatement, poSpatialFilter,
pszDialect );
}
/* -------------------------------------------------------------------- */
/* Parse into keywords. */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString( pszStatement );
if( CSLCount(papszTokens) < 5
|| !EQUAL(papszTokens[0],"CREATE")
|| !EQUAL(papszTokens[1],"SPATIAL")
|| !EQUAL(papszTokens[2],"INDEX")
|| !EQUAL(papszTokens[3],"ON")
|| CSLCount(papszTokens) > 7
|| (CSLCount(papszTokens) == 7 && !EQUAL(papszTokens[5],"DEPTH")) )
{
CSLDestroy( papszTokens );
CPLError( CE_Failure, CPLE_AppDefined,
"Syntax error in CREATE SPATIAL INDEX command.\n"
"Was '%s'\n"
"Should be of form 'CREATE SPATIAL INDEX ON <table> [DEPTH <n>]'",
pszStatement );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Get depth if provided. */
/* -------------------------------------------------------------------- */
int nDepth = 0;
if( CSLCount(papszTokens) == 7 )
nDepth = atoi(papszTokens[6]);
/* -------------------------------------------------------------------- */
/* What layer are we operating on. */
/* -------------------------------------------------------------------- */
OGRShapeLayer *poLayer = (OGRShapeLayer *) GetLayerByName(papszTokens[4]);
if( poLayer == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s not recognised.",
papszTokens[4] );
CSLDestroy( papszTokens );
return NULL;
}
CSLDestroy( papszTokens );
poLayer->CreateSpatialIndex( nDepth );
return NULL;
}
static void
GDALSimpleWarpRemapping( int nBandCount, GByte **papabySrcData,
int nSrcXSize, int nSrcYSize,
char **papszWarpOptions )
{
/* ==================================================================== */
/* Process any and all single value REMAP commands. */
/* ==================================================================== */
char **papszRemaps = CSLFetchNameValueMultiple( papszWarpOptions,
"REMAP" );
for( int iRemap = 0; iRemap < CSLCount(papszRemaps); iRemap++ )
{
/* -------------------------------------------------------------------- */
/* What are the pixel values to map from and to? */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString( papszRemaps[iRemap] );
if( CSLCount(papszTokens) != 2 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Ill formed REMAP `%s' ignored in GDALSimpleWarpRemapping()",
papszRemaps[iRemap] );
CSLDestroy( papszTokens );
continue;
}
const int nFromValue = atoi(papszTokens[0]);
const int nToValue = atoi(papszTokens[1]);
CSLDestroy( papszTokens );
/* -------------------------------------------------------------------- */
/* Pass over each band searching for matches. */
/* -------------------------------------------------------------------- */
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
GByte *pabyData = papabySrcData[iBand];
int nPixelCount = nSrcXSize * nSrcYSize;
while( nPixelCount != 0 )
{
if( *pabyData == nFromValue )
*pabyData = static_cast<GByte>( nToValue );
pabyData++;
nPixelCount--;
}
}
}
CSLDestroy( papszRemaps );
/* ==================================================================== */
/* Process any and all REMAP_MULTI commands. */
/* ==================================================================== */
papszRemaps = CSLFetchNameValueMultiple( papszWarpOptions,
"REMAP_MULTI" );
for( int iRemap = 0; iRemap < CSLCount(papszRemaps); iRemap++ )
{
/* -------------------------------------------------------------------- */
/* What are the pixel values to map from and to? */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString( papszRemaps[iRemap] );
if( CSLCount(papszTokens) % 2 == 1
|| CSLCount(papszTokens) == 0
|| CSLCount(papszTokens) > nBandCount * 2 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Ill formed REMAP_MULTI `%s' ignored in GDALSimpleWarpRemapping()",
papszRemaps[iRemap] );
CSLDestroy( papszTokens );
continue;
}
const int nMapBandCount = CSLCount(papszTokens) / 2;
int *panFromValue = static_cast<int *>(
CPLMalloc(sizeof(int) * nMapBandCount ) );
int *panToValue = static_cast<int *>(
CPLMalloc(sizeof(int) * nMapBandCount ) );
for( int iBand = 0; iBand < nMapBandCount; iBand++ )
{
panFromValue[iBand] = atoi(papszTokens[iBand]);
panToValue[iBand] = atoi(papszTokens[iBand+nMapBandCount]);
}
CSLDestroy( papszTokens );
/* -------------------------------------------------------------------- */
/* Search for matching values to replace. */
/* -------------------------------------------------------------------- */
const int nPixelCount = nSrcXSize * nSrcYSize;
for( int iPixel = 0; iPixel < nPixelCount; iPixel++ )
{
if( papabySrcData[0][iPixel] != panFromValue[0] )
continue;
bool bMatch = true;
for( int iBand = 1; iBand < nMapBandCount; iBand++ )
{
if( papabySrcData[iBand][iPixel] != panFromValue[iBand] )
bMatch = false;
}
if( !bMatch )
continue;
for( int iBand = 0; iBand < nMapBandCount; iBand++ )
papabySrcData[iBand][iPixel] =
static_cast<GByte>( panToValue[iBand] );
}
CPLFree( panFromValue );
CPLFree( panToValue );
}
CSLDestroy( papszRemaps );
}
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 );
}
GDALDataset *DOQ2Dataset::Open( GDALOpenInfo * poOpenInfo )
{
int nWidth=0, nHeight=0, nBandStorage=0, nBandTypes=0;
/* -------------------------------------------------------------------- */
/* We assume the user is pointing to the binary (ie. .bil) file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 212 )
return NULL;
int nLineCount = 0;
const char *pszLine;
int nBytesPerPixel=0;
const char *pszDatumLong=NULL, *pszDatumShort=NULL;
const char *pszUnits=NULL;
char *pszQuadname = NULL;
char *pszQuadquad = NULL;
char *pszState = NULL;
int nZone=0, nProjType=0;
int nSkipBytes=0, nBytesPerLine, i, nBandCount = 0;
double dfULXMap=0.0, dfULYMap = 0.0;
double dfXDim=0.0, dfYDim=0.0;
char **papszMetadata = NULL;
if(! EQUALN((const char *) poOpenInfo->pabyHeader,
"BEGIN_USGS_DOQ_HEADER", 21) )
return NULL;
VSILFILE* fp = VSIFOpenL(poOpenInfo->pszFilename, "rb");
if (fp == NULL)
return NULL;
/* read and discard the first line */
pszLine = CPLReadLineL( fp );
while( (pszLine = CPLReadLineL( fp )) != NULL )
{
char **papszTokens;
nLineCount++;
if( EQUAL(pszLine,"END_USGS_DOQ_HEADER") )
break;
papszTokens = CSLTokenizeString( pszLine );
if( CSLCount( papszTokens ) < 2 )
{
CSLDestroy( papszTokens );
break;
}
if( EQUAL(papszTokens[0],"SAMPLES_AND_LINES") && CSLCount(papszTokens) >= 3 )
{
nWidth = atoi(papszTokens[1]);
nHeight = atoi(papszTokens[2]);
}
else if( EQUAL(papszTokens[0],"BYTE_COUNT") )
{
nSkipBytes = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"XY_ORIGIN") && CSLCount(papszTokens) >= 3 )
{
dfULXMap = atof(papszTokens[1]);
dfULYMap = atof(papszTokens[2]);
}
else if( EQUAL(papszTokens[0],"HORIZONTAL_RESOLUTION") )
{
dfXDim = dfYDim = atof(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"BAND_ORGANIZATION") )
{
if( EQUAL(papszTokens[1],"SINGLE FILE") )
nBandStorage = 1;
if( EQUAL(papszTokens[1],"BSQ") )
nBandStorage = 1;
if( EQUAL(papszTokens[1],"BIL") )
nBandStorage = 1;
if( EQUAL(papszTokens[1],"BIP") )
nBandStorage = 4;
}
else if( EQUAL(papszTokens[0],"BAND_CONTENT") )
{
if( EQUAL(papszTokens[1],"BLACK&WHITE") )
nBandTypes = 1;
else if( EQUAL(papszTokens[1],"COLOR") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1],"RGB") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1],"RED") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1],"GREEN") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1],"BLUE") )
nBandTypes = 5;
nBandCount++;
}
else if( EQUAL(papszTokens[0],"BITS_PER_PIXEL") )
{
nBytesPerPixel = (atoi(papszTokens[1]) / 8);
}
else if( EQUAL(papszTokens[0],"HORIZONTAL_COORDINATE_SYSTEM") )
{
if( EQUAL(papszTokens[1],"UTM") )
nProjType = 1;
else if( EQUAL(papszTokens[1],"SPCS") )
nProjType = 2;
else if( EQUAL(papszTokens[1],"GEOGRAPHIC") )
nProjType = 0;
}
else if( EQUAL(papszTokens[0],"COORDINATE_ZONE") )
{
nZone = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"HORIZONTAL_UNITS") )
{
if( EQUAL(papszTokens[1],"METERS") )
pszUnits = "UNIT[\"metre\",1]";
else if( EQUAL(papszTokens[1],"FEET") )
pszUnits = "UNIT[\"US survey foot\",0.304800609601219]";
}
else if( EQUAL(papszTokens[0],"HORIZONTAL_DATUM") )
{
if( EQUAL(papszTokens[1],"NAD27") )
{
pszDatumLong = NAD27_DATUM;
pszDatumShort = "NAD 27";
}
else if( EQUAL(papszTokens[1],"WGS72") )
{
pszDatumLong = WGS72_DATUM;
pszDatumShort = "WGS 72";
}
else if( EQUAL(papszTokens[1],"WGS84") )
{
pszDatumLong = WGS84_DATUM;
pszDatumShort = "WGS 84";
}
else if( EQUAL(papszTokens[1],"NAD83") )
{
pszDatumLong = NAD83_DATUM;
pszDatumShort = "NAD 83";
}
else
{
pszDatumLong = "DATUM[\"unknown\"]";
pszDatumShort = "unknown";
}
}
else
{
/* we want to generically capture all the other metadata */
CPLString osMetaDataValue;
int iToken;
for( iToken = 1; papszTokens[iToken] != NULL; iToken++ )
{
if( EQUAL(papszTokens[iToken],"*") )
continue;
if( iToken > 1 )
osMetaDataValue += " " ;
osMetaDataValue += papszTokens[iToken];
}
papszMetadata = CSLAddNameValue( papszMetadata,
papszTokens[0],
osMetaDataValue );
}
CSLDestroy( papszTokens );
}
CPLReadLineL( NULL );
/* -------------------------------------------------------------------- */
/* Do these values look coherent for a DOQ file? It would be */
/* nice to do a more comprehensive test than this! */
/* -------------------------------------------------------------------- */
if( nWidth < 500 || nWidth > 25000
|| nHeight < 500 || nHeight > 25000
|| nBandStorage < 0 || nBandStorage > 4
|| nBandTypes < 1 || nBandTypes > 9 )
{
CSLDestroy( papszMetadata );
VSIFCloseL(fp);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Check the configuration. We don't currently handle all */
/* variations, only the common ones. */
/* -------------------------------------------------------------------- */
if( nBandTypes > 5 )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"DOQ Data Type (%d) is not a supported configuration.\n",
nBandTypes );
CSLDestroy( papszMetadata );
VSIFCloseL(fp);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CSLDestroy( papszMetadata );
CPLError( CE_Failure, CPLE_NotSupported,
"The DOQ2 driver does not support update access to existing"
" datasets.\n" );
VSIFCloseL(fp);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
DOQ2Dataset *poDS;
poDS = new DOQ2Dataset();
poDS->nRasterXSize = nWidth;
poDS->nRasterYSize = nHeight;
poDS->SetMetadata( papszMetadata );
CSLDestroy( papszMetadata );
poDS->fpImage = fp;
/* -------------------------------------------------------------------- */
/* Compute layout of data. */
/* -------------------------------------------------------------------- */
if( nBandCount < 2 )
nBandCount = nBytesPerPixel;
else
nBytesPerPixel *= nBandCount;
nBytesPerLine = nBytesPerPixel * nWidth;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
for( i = 0; i < nBandCount; i++ )
{
poDS->SetBand( i+1,
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + i, nBytesPerPixel, nBytesPerLine,
GDT_Byte, TRUE, TRUE ) );
}
if (nProjType == 1)
{
poDS->pszProjection =
CPLStrdup(CPLSPrintf( UTM_FORMAT, pszDatumShort, nZone,
pszDatumLong, nZone * 6 - 183, pszUnits ));
}
else
{
poDS->pszProjection = CPLStrdup("");
}
poDS->dfULX = dfULXMap;
poDS->dfULY = dfULYMap;
poDS->dfXPixelSize = dfXDim;
poDS->dfYPixelSize = dfYDim;
if ( pszQuadname ) CPLFree( pszQuadname );
if ( pszQuadquad) CPLFree( pszQuadquad );
if ( pszState) CPLFree( pszState );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
CPLErr VRTWarpedDataset::XMLInit( CPLXMLNode *psTree, const char *pszVRTPath )
{
CPLErr eErr;
/* -------------------------------------------------------------------- */
/* Initialize blocksize before calling sub-init so that the */
/* band initializers can get it from the dataset object when */
/* they are created. */
/* -------------------------------------------------------------------- */
nBlockXSize = atoi(CPLGetXMLValue(psTree,"BlockXSize","512"));
nBlockYSize = atoi(CPLGetXMLValue(psTree,"BlockYSize","128"));
/* -------------------------------------------------------------------- */
/* Initialize all the general VRT stuff. This will even */
/* create the VRTWarpedRasterBands and initialize them. */
/* -------------------------------------------------------------------- */
eErr = VRTDataset::XMLInit( psTree, pszVRTPath );
if( eErr != CE_None )
return eErr;
/* -------------------------------------------------------------------- */
/* Find the GDALWarpOptions XML tree. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psOptionsTree;
psOptionsTree = CPLGetXMLNode( psTree, "GDALWarpOptions" );
if( psOptionsTree == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Count not find required GDALWarpOptions in XML." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Adjust the SourceDataset in the warp options to take into */
/* account that it is relative to the VRT if appropriate. */
/* -------------------------------------------------------------------- */
int bRelativeToVRT =
atoi(CPLGetXMLValue(psOptionsTree,
"SourceDataset.relativeToVRT", "0" ));
const char *pszRelativePath = CPLGetXMLValue(psOptionsTree,
"SourceDataset", "" );
char *pszAbsolutePath;
if( bRelativeToVRT )
pszAbsolutePath =
CPLStrdup(CPLProjectRelativeFilename( pszVRTPath,
pszRelativePath ) );
else
pszAbsolutePath = CPLStrdup(pszRelativePath);
CPLSetXMLValue( psOptionsTree, "SourceDataset", pszAbsolutePath );
CPLFree( pszAbsolutePath );
/* -------------------------------------------------------------------- */
/* And instantiate the warp options, and corresponding warp */
/* operation. */
/* -------------------------------------------------------------------- */
GDALWarpOptions *psWO;
psWO = GDALDeserializeWarpOptions( psOptionsTree );
if( psWO == NULL )
return CE_Failure;
this->eAccess = GA_Update;
psWO->hDstDS = this;
/* -------------------------------------------------------------------- */
/* Instantiate the warp operation. */
/* -------------------------------------------------------------------- */
poWarper = new GDALWarpOperation();
eErr = poWarper->Initialize( psWO );
if( eErr != CE_None)
{
/* -------------------------------------------------------------------- */
/* We are responsible for cleaning up the transformer outselves. */
/* -------------------------------------------------------------------- */
if( psWO->pTransformerArg != NULL )
GDALDestroyTransformer( psWO->pTransformerArg );
}
GDALDestroyWarpOptions( psWO );
if( eErr != CE_None )
{
delete poWarper;
poWarper = NULL;
}
/* -------------------------------------------------------------------- */
/* Generate overviews, if appropriate. */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString(
CPLGetXMLValue( psTree, "OverviewList", "" ));
int iOverview;
for( iOverview = 0;
papszTokens != NULL && papszTokens[iOverview] != NULL;
iOverview++ )
{
int nOvFactor = atoi(papszTokens[iOverview]);
if (nOvFactor > 0)
BuildOverviews( "NEAREST", 1, &nOvFactor, 0, NULL, NULL, NULL );
else
CPLError(CE_Failure, CPLE_AppDefined,
"Bad value for overview factor : %s", papszTokens[iOverview]);
}
CSLDestroy( papszTokens );
return eErr;
}
void OGRUKOOAP190Layer::ParseHeaders()
{
while(TRUE)
{
const char* pszLine = CPLReadLine2L(fp,81,NULL);
if (pszLine == NULL || EQUALN(pszLine, "EOF", 3))
{
break;
}
int nLineLen = strlen(pszLine);
while(nLineLen > 0 && pszLine[nLineLen-1] == ' ')
{
((char*)pszLine)[nLineLen-1] = '\0';
nLineLen --;
}
if (pszLine[0] != 'H')
break;
if (nLineLen < 33)
continue;
if (!bUseEastingNorthingAsGeometry &&
strncmp(pszLine, "H1500", 5) == 0 && poSRS == NULL)
{
if (strncmp(pszLine + 33 - 1, "WGS84", 5) == 0 ||
strncmp(pszLine + 33 - 1, "WGS-84", 6) == 0)
{
poSRS = new OGRSpatialReference(SRS_WKT_WGS84);
}
else if (strncmp(pszLine + 33 - 1, "WGS72", 5) == 0)
{
poSRS = new OGRSpatialReference();
poSRS->SetFromUserInput("WGS72");
}
}
else if (!bUseEastingNorthingAsGeometry &&
strncmp(pszLine, "H1501", 5) == 0 && poSRS != NULL &&
nLineLen >= 32 + 6 * 6 + 10)
{
char aszParams[6][6+1];
char szZ[10+1];
int i;
for(i=0;i<6;i++)
{
ExtractField(aszParams[i], pszLine, 33 - 1 + i * 6, 6);
}
ExtractField(szZ, pszLine, 33 - 1 + 6 * 6, 10);
poSRS->SetTOWGS84(CPLAtof(aszParams[0]),
CPLAtof(aszParams[1]),
CPLAtof(aszParams[2]),
CPLAtof(aszParams[3]),
CPLAtof(aszParams[4]),
CPLAtof(aszParams[5]),
CPLAtof(szZ));
}
else if (strncmp(pszLine, "H0200", 5) == 0)
{
char** papszTokens = CSLTokenizeString(pszLine + 33 - 1);
for(int i = 0; papszTokens[i] != NULL; i++)
{
if (strlen(papszTokens[i]) == 4)
{
int nVal = atoi(papszTokens[i]);
if (nVal >= 1900)
{
if (nYear != 0 && nYear != nVal)
{
CPLDebug("SEGUKOOA",
"Several years found in H0200. Ignoring them!");
nYear = 0;
break;
}
nYear = nVal;
}
}
}
CSLDestroy(papszTokens);
}
}
VSIFSeekL( fp, 0, SEEK_SET );
}
OGRErr OGRDataSource::ProcessSQLCreateIndex( const char *pszSQLCommand )
{
char **papszTokens = CSLTokenizeString( pszSQLCommand );
/* -------------------------------------------------------------------- */
/* Do some general syntax checking. */
/* -------------------------------------------------------------------- */
if( CSLCount(papszTokens) != 6
|| !EQUAL(papszTokens[0],"CREATE")
|| !EQUAL(papszTokens[1],"INDEX")
|| !EQUAL(papszTokens[2],"ON")
|| !EQUAL(papszTokens[4],"USING") )
{
CSLDestroy( papszTokens );
CPLError( CE_Failure, CPLE_AppDefined,
"Syntax error in CREATE INDEX command.\n"
"Was '%s'\n"
"Should be of form 'CREATE INDEX ON <table> USING <field>'",
pszSQLCommand );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Find the named layer. */
/* -------------------------------------------------------------------- */
int i;
OGRLayer *poLayer = NULL;
for( i = 0; i < GetLayerCount(); i++ )
{
poLayer = GetLayer(i);
if( EQUAL(poLayer->GetLayerDefn()->GetName(),papszTokens[3]) )
break;
}
if( i >= GetLayerCount() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"CREATE INDEX ON failed, no such layer as `%s'.",
papszTokens[3] );
CSLDestroy( papszTokens );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Does this layer even support attribute indexes? */
/* -------------------------------------------------------------------- */
if( poLayer->GetIndex() == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"CREATE INDEX ON not supported by this driver." );
CSLDestroy( papszTokens );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Find the named field. */
/* -------------------------------------------------------------------- */
for( i = 0; i < poLayer->GetLayerDefn()->GetFieldCount(); i++ )
{
if( EQUAL(papszTokens[5],
poLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef()) )
break;
}
CSLDestroy( papszTokens );
if( i >= poLayer->GetLayerDefn()->GetFieldCount() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"`%s' failed, field not found.",
pszSQLCommand );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Attempt to create the index. */
/* -------------------------------------------------------------------- */
OGRErr eErr;
eErr = poLayer->GetIndex()->CreateIndex( i );
if( eErr == OGRERR_NONE )
eErr = poLayer->GetIndex()->IndexAllFeatures( i );
return eErr;
}
void OGRUKOOAP190Layer::ParseHeaders()
{
while( true )
{
const char* pszLine = CPLReadLine2L(fp,81,nullptr);
if (pszLine == nullptr || STARTS_WITH_CI(pszLine, "EOF"))
{
break;
}
int nLineLen = static_cast<int>(strlen(pszLine));
while(nLineLen > 0 && pszLine[nLineLen-1] == ' ')
{
((char*)pszLine)[nLineLen-1] = '\0';
nLineLen --;
}
if (pszLine[0] != 'H')
break;
if (nLineLen < 33)
continue;
if (!bUseEastingNorthingAsGeometry &&
STARTS_WITH(pszLine, "H1500") && poSRS == nullptr)
{
if (STARTS_WITH(pszLine + 33 - 1, "WGS84") ||
STARTS_WITH(pszLine + 33 - 1, "WGS-84"))
{
poSRS = new OGRSpatialReference(SRS_WKT_WGS84_LAT_LONG);
poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
}
else if (STARTS_WITH(pszLine + 33 - 1, "WGS72"))
{
poSRS = new OGRSpatialReference();
poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
poSRS->SetFromUserInput("WGS72");
}
}
else if (!bUseEastingNorthingAsGeometry &&
STARTS_WITH(pszLine, "H1501") && poSRS != nullptr &&
nLineLen >= 32 + 6 * 6 + 10)
{
char aszParams[6][6+1];
char szZ[10+1];
for( int i = 0; i < 6; i++ )
{
ExtractField(aszParams[i], pszLine, 33 - 1 + i * 6, 6);
}
ExtractField(szZ, pszLine, 33 - 1 + 6 * 6, 10);
poSRS->SetTOWGS84(CPLAtof(aszParams[0]),
CPLAtof(aszParams[1]),
CPLAtof(aszParams[2]),
CPLAtof(aszParams[3]),
CPLAtof(aszParams[4]),
CPLAtof(aszParams[5]),
CPLAtof(szZ));
}
else if (STARTS_WITH(pszLine, "H0200"))
{
char** papszTokens = CSLTokenizeString(pszLine + 33 - 1);
for(int i = 0; papszTokens[i] != nullptr; i++)
{
if (strlen(papszTokens[i]) == 4)
{
int nVal = atoi(papszTokens[i]);
if (nVal >= 1900)
{
if( nYear != 0 && nYear != nVal )
{
CPLDebug("SEGUKOOA",
"Several years found in H0200. Ignoring them!");
nYear = 0;
break;
}
nYear = nVal;
}
}
}
CSLDestroy(papszTokens);
}
}
VSIFSeekL( fp, 0, SEEK_SET );
}
GDALDataset *PAuxDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( poOpenInfo->nHeaderBytes < 1 )
return NULL;
/* -------------------------------------------------------------------- */
/* If this is an .aux file, fetch out and form the name of the */
/* file it references. */
/* -------------------------------------------------------------------- */
CPLString osTarget = poOpenInfo->pszFilename;
if( EQUAL(CPLGetExtension( poOpenInfo->pszFilename ),"aux")
&& STARTS_WITH_CI((const char *) poOpenInfo->pabyHeader, "AuxilaryTarget: "))
{
char szAuxTarget[1024];
const char *pszSrc = reinterpret_cast<const char *>(
poOpenInfo->pabyHeader+16 );
int i = 0;
for( ;
pszSrc[i] != 10 && pszSrc[i] != 13 && pszSrc[i] != '\0'
&& i < static_cast<int>( sizeof(szAuxTarget) ) - 1;
i++ )
{
szAuxTarget[i] = pszSrc[i];
}
szAuxTarget[i] = '\0';
char *pszPath = CPLStrdup(CPLGetPath(poOpenInfo->pszFilename));
osTarget = CPLFormFilename(pszPath, szAuxTarget, NULL);
CPLFree(pszPath);
}
/* -------------------------------------------------------------------- */
/* Now we need to tear apart the filename to form a .aux */
/* filename. */
/* -------------------------------------------------------------------- */
CPLString osAuxFilename = CPLResetExtension(osTarget,"aux");
/* -------------------------------------------------------------------- */
/* Do we have a .aux file? */
/* -------------------------------------------------------------------- */
char** papszSiblingFiles = poOpenInfo->GetSiblingFiles();
if( papszSiblingFiles != NULL
&& CSLFindString( papszSiblingFiles,
CPLGetFilename(osAuxFilename) ) == -1 )
{
return NULL;
}
VSILFILE *fp = VSIFOpenL( osAuxFilename, "r" );
if( fp == NULL )
{
osAuxFilename = CPLResetExtension(osTarget,"AUX");
fp = VSIFOpenL( osAuxFilename, "r" );
}
if( fp == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Is this file a PCI .aux file? Check the first line for the */
/* telltale AuxilaryTarget keyword. */
/* */
/* At this point we should be verifying that it refers to our */
/* binary file, but that is a pretty involved test. */
/* -------------------------------------------------------------------- */
const char *pszLine = CPLReadLineL( fp );
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
if( pszLine == NULL
|| (!STARTS_WITH_CI(pszLine, "AuxilaryTarget")
&& !STARTS_WITH_CI(pszLine, "AuxiliaryTarget")) )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
PAuxDataset *poDS = new PAuxDataset();
/* -------------------------------------------------------------------- */
/* Load the .aux file into a string list suitable to be */
/* searched with CSLFetchNameValue(). */
/* -------------------------------------------------------------------- */
poDS->papszAuxLines = CSLLoad( osAuxFilename );
poDS->pszAuxFilename = CPLStrdup(osAuxFilename);
/* -------------------------------------------------------------------- */
/* Find the RawDefinition line to establish overall parameters. */
/* -------------------------------------------------------------------- */
pszLine = CSLFetchNameValue(poDS->papszAuxLines, "RawDefinition");
// It seems PCI now writes out .aux files without RawDefinition in
// some cases. See bug 947.
if( pszLine == NULL )
{
delete poDS;
return NULL;
}
char **papszTokens = CSLTokenizeString(pszLine);
if( CSLCount(papszTokens) < 3 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"RawDefinition missing or corrupt in %s.",
poOpenInfo->pszFilename );
delete poDS;
CSLDestroy( papszTokens );
return NULL;
}
poDS->nRasterXSize = atoi(papszTokens[0]);
poDS->nRasterYSize = atoi(papszTokens[1]);
poDS->nBands = atoi(papszTokens[2]);
poDS->eAccess = poOpenInfo->eAccess;
CSLDestroy( papszTokens );
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) ||
!GDALCheckBandCount(poDS->nBands, FALSE))
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
poDS->fpImage = VSIFOpenL( osTarget, "rb+" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File %s is missing or read-only, check permissions.",
osTarget.c_str() );
delete poDS;
return NULL;
}
}
else
{
poDS->fpImage = VSIFOpenL( osTarget, "rb" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File %s is missing or unreadable.",
osTarget.c_str() );
delete poDS;
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Collect raw definitions of each channel and create */
/* corresponding bands. */
/* -------------------------------------------------------------------- */
int iBand = 0;
for( int i = 0; i < poDS->nBands; i++ )
{
char szDefnName[32];
snprintf( szDefnName, sizeof(szDefnName), "ChanDefinition-%d", i+1 );
pszLine = CSLFetchNameValue(poDS->papszAuxLines, szDefnName);
if (pszLine == NULL)
{
continue;
}
papszTokens = CSLTokenizeString(pszLine);
if( CSLCount(papszTokens) < 4 )
{
// Skip the band with broken description
CSLDestroy( papszTokens );
continue;
}
GDALDataType eType;
if( EQUAL(papszTokens[0],"16U") )
eType = GDT_UInt16;
else if( EQUAL(papszTokens[0],"16S") )
eType = GDT_Int16;
else if( EQUAL(papszTokens[0],"32R") )
eType = GDT_Float32;
else
eType = GDT_Byte;
int bNative = TRUE;
if( CSLCount(papszTokens) > 4 )
{
#ifdef CPL_LSB
bNative = EQUAL(papszTokens[4],"Swapped");
#else
bNative = EQUAL(papszTokens[4],"Unswapped");
#endif
}
const vsi_l_offset nBandOffset = CPLScanUIntBig(papszTokens[1],
static_cast<int>(strlen(papszTokens[1])));
const int nPixelOffset = atoi(papszTokens[2]);
const int nLineOffset = atoi(papszTokens[3]);
if (nPixelOffset <= 0 || nLineOffset <= 0)
{
// Skip the band with broken offsets
CSLDestroy( papszTokens );
continue;
}
poDS->SetBand( iBand+1,
new PAuxRasterBand( poDS, iBand+1, poDS->fpImage,
nBandOffset,
nPixelOffset,
nLineOffset, eType, bNative ) );
iBand++;
CSLDestroy( papszTokens );
}
poDS->nBands = iBand;
/* -------------------------------------------------------------------- */
/* Get the projection. */
/* -------------------------------------------------------------------- */
const char *pszMapUnits = CSLFetchNameValue( poDS->papszAuxLines, "MapUnits" );
const char *pszProjParms = CSLFetchNameValue( poDS->papszAuxLines, "ProjParms" );
if( pszMapUnits != NULL )
poDS->pszProjection = poDS->PCI2WKT( pszMapUnits, pszProjParms );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( osTarget );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, osTarget );
poDS->ScanForGCPs();
poDS->bAuxUpdated = FALSE;
return( poDS );
}
int OGRGeneralCmdLineProcessor( int nArgc, char ***ppapszArgv, int nOptions )
{
char **papszReturn = NULL;
int iArg;
char **papszArgv = *ppapszArgv;
(void) nOptions;
/* -------------------------------------------------------------------- */
/* Preserve the program name. */
/* -------------------------------------------------------------------- */
papszReturn = CSLAddString( papszReturn, papszArgv[0] );
/* ==================================================================== */
/* Loop over all arguments. */
/* ==================================================================== */
for( iArg = 1; iArg < nArgc; iArg++ )
{
/* -------------------------------------------------------------------- */
/* --version */
/* -------------------------------------------------------------------- */
if( EQUAL(papszArgv[iArg],"--version") )
{
printf( "%s\n", GDALVersionInfo( "--version" ) );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* --license */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--license") )
{
printf( "%s\n", GDALVersionInfo( "LICENSE" ) );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* --config */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--config") )
{
if( iArg + 2 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--config option given without a key and value argument." );
CSLDestroy( papszReturn );
return -1;
}
CPLSetConfigOption( papszArgv[iArg+1], papszArgv[iArg+2] );
iArg += 2;
}
/* -------------------------------------------------------------------- */
/* --mempreload */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--mempreload") )
{
int i;
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--mempreload option given without directory path.");
CSLDestroy( papszReturn );
return -1;
}
char **papszFiles = CPLReadDir( papszArgv[iArg+1] );
if( CSLCount(papszFiles) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--mempreload given invalid or empty directory.");
CSLDestroy( papszReturn );
return -1;
}
for( i = 0; papszFiles[i] != NULL; i++ )
{
CPLString osOldPath, osNewPath;
if( EQUAL(papszFiles[i],".") || EQUAL(papszFiles[i],"..") )
continue;
osOldPath = CPLFormFilename( papszArgv[iArg+1],
papszFiles[i], NULL );
osNewPath.Printf( "/vsimem/%s", papszFiles[i] );
CPLDebug( "VSI", "Preloading %s to %s.",
osOldPath.c_str(), osNewPath.c_str() );
if( CPLCopyFile( osNewPath, osOldPath ) != 0 )
return -1;
}
CSLDestroy( papszFiles );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --debug */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--debug") )
{
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--debug option given without debug level." );
CSLDestroy( papszReturn );
return -1;
}
CPLSetConfigOption( "CPL_DEBUG", papszArgv[iArg+1] );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --optfile */
/* */
/* Annoyingly the options inserted by --optfile will *not* be */
/* processed properly if they are general options. */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--optfile") )
{
const char *pszLine;
FILE *fpOptFile;
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--optfile option given without filename." );
CSLDestroy( papszReturn );
return -1;
}
fpOptFile = VSIFOpen( papszArgv[iArg+1], "rb" );
if( fpOptFile == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to open optfile '%s'.\n%s",
papszArgv[iArg+1], VSIStrerror( errno ) );
CSLDestroy( papszReturn );
return -1;
}
while( (pszLine = CPLReadLine( fpOptFile )) != NULL )
{
char **papszTokens;
int i;
if( pszLine[0] == '#' || strlen(pszLine) == 0 )
continue;
papszTokens = CSLTokenizeString( pszLine );
for( i = 0; papszTokens != NULL && papszTokens[i] != NULL; i++)
papszReturn = CSLAddString( papszReturn, papszTokens[i] );
CSLDestroy( papszTokens );
}
VSIFClose( fpOptFile );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --formats */
/* -------------------------------------------------------------------- */
#ifdef OGR_ENABLED
else if( EQUAL(papszArgv[iArg], "--formats") )
{
int iDr;
printf( "Supported Formats:\n" );
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
for( iDr = 0; iDr < poR->GetDriverCount(); iDr++ )
{
OGRSFDriver *poDriver = poR->GetDriver(iDr);
if( poDriver->TestCapability( ODrCCreateDataSource ) )
printf( " -> \"%s\" (read/write)\n",
poDriver->GetName() );
else
printf( " -> \"%s\" (readonly)\n",
poDriver->GetName() );
}
CSLDestroy( papszReturn );
return 0;
}
#endif /* OGR_ENABLED */
/* -------------------------------------------------------------------- */
/* --locale */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--locale") && iArg < nArgc-1 )
{
setlocale( LC_ALL, papszArgv[++iArg] );
}
/* -------------------------------------------------------------------- */
/* --pause - "hit enter" pause useful to connect a debugger. */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--pause") )
{
char szLine[81];
printf( "Hit <ENTER> to continue.\n" );
fgets( szLine, sizeof(szLine), stdin );
}
/* -------------------------------------------------------------------- */
/* --help-general */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--help-general") )
{
printf( "Generic GDAL/OGR utility command options:\n" );
printf( " --version: report version of GDAL/OGR in use.\n" );
printf( " --license: report GDAL/OGR license info.\n" );
#ifdef OGR_ENABLED
printf( " --formats: report all configured format drivers.\n" );
#endif /* OGR_ENABLED */
printf( " --optfile filename: expand an option file into the argument list.\n" );
printf( " --config key value: set system configuration option.\n" );
printf( " --debug [on/off/value]: set debug level.\n" );
printf( " --help-general: report detailed help on general options.\n" );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* carry through unrecognised options. */
/* -------------------------------------------------------------------- */
else
{
papszReturn = CSLAddString( papszReturn, papszArgv[iArg] );
}
}
*ppapszArgv = papszReturn;
return CSLCount( *ppapszArgv );
}
OGRFeature *OGRHTFPolygonLayer::GetNextRawFeature()
{
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
const char* pszLine;
OGRLinearRing oLR;
int bHastFirstCoord = FALSE;
double dfFirstEasting = 0, dfFirstNorthing = 0;
double dfIslandEasting = 0, dfIslandNorthing = 0;
int bInIsland = FALSE;
OGRPolygon* poPoly = new OGRPolygon();
while( (pszLine = CPLReadLine2L(fpHTF, 1024, NULL)) != NULL)
{
if (pszLine[0] == ';')
{
/* comment */ ;
}
else if (pszLine[0] == 0)
{
/* end of polygon is marked by a blank line */
break;
}
else if (strncmp(pszLine, "POLYGON DESCRIPTION: ",
strlen("POLYGON DESCRIPTION: ")) == 0)
{
poFeature->SetField(0, pszLine + strlen("POLYGON DESCRIPTION: "));
}
else if (strncmp(pszLine, "POLYGON IDENTIFIER: ",
strlen("POLYGON IDENTIFIER: ")) == 0)
{
poFeature->SetField(1, pszLine + strlen("POLYGON IDENTIFIER: "));
}
else if (strncmp(pszLine, "SEAFLOOR COVERAGE: ",
strlen("SEAFLOOR COVERAGE:")) == 0)
{
const char* pszVal = pszLine + strlen("SEAFLOOR COVERAGE: ");
if (*pszVal != '*')
poFeature->SetField(2, pszVal);
}
else if (strncmp(pszLine, "POSITION ACCURACY: ",
strlen("POSITION ACCURACY:")) == 0)
{
const char* pszVal = pszLine + strlen("POSITION ACCURACY: ");
if (*pszVal != '*')
poFeature->SetField(3, pszVal);
}
else if (strncmp(pszLine, "DEPTH ACCURACY: ",
strlen("DEPTH ACCURACY:")) == 0)
{
const char* pszVal = pszLine + strlen("DEPTH ACCURACY: ");
if (*pszVal != '*')
poFeature->SetField(4, pszVal);
}
else if (strcmp(pszLine, "END OF POLYGON DATA") == 0)
{
bEOF = TRUE;
break;
}
else
{
char** papszTokens = CSLTokenizeString(pszLine);
if (CSLCount(papszTokens) == 4)
{
double dfEasting = atof(papszTokens[2]);
double dfNorthing = atof(papszTokens[3]);
if (!bHastFirstCoord)
{
bHastFirstCoord = TRUE;
dfFirstEasting = dfEasting;
dfFirstNorthing = dfNorthing;
oLR.addPoint(dfEasting, dfNorthing);
}
else if (dfFirstEasting == dfEasting &&
dfFirstNorthing == dfNorthing)
{
if (!bInIsland)
{
oLR.addPoint(dfEasting, dfNorthing);
poPoly->addRing(&oLR);
oLR.empty();
bInIsland = TRUE;
}
}
else if (bInIsland && oLR.getNumPoints() == 0)
{
dfIslandEasting = dfEasting;
dfIslandNorthing = dfNorthing;
oLR.addPoint(dfEasting, dfNorthing);
}
else if (bInIsland && dfIslandEasting == dfEasting &&
dfIslandNorthing == dfNorthing)
{
oLR.addPoint(dfEasting, dfNorthing);
poPoly->addRing(&oLR);
oLR.empty();
}
else
{
oLR.addPoint(dfEasting, dfNorthing);
}
}
CSLDestroy(papszTokens);
}
}
if (pszLine == NULL)
bEOF = TRUE;
if (oLR.getNumPoints() >= 3)
{
oLR.closeRings();
poPoly->addRing(&oLR);
}
poPoly->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poPoly);
poFeature->SetFID(nNextFID++);
return poFeature;
}
GDALRasterizeOptions *GDALRasterizeOptionsNew(char** papszArgv,
GDALRasterizeOptionsForBinary* psOptionsForBinary)
{
GDALRasterizeOptions *psOptions = new GDALRasterizeOptions;
psOptions->pszFormat = CPLStrdup("GTiff");
psOptions->pfnProgress = GDALDummyProgress;
psOptions->pProgressData = NULL;
psOptions->bCreateOutput = FALSE;
psOptions->b3D = FALSE;
psOptions->bInverse = FALSE;
memset(&(psOptions->sEnvelop), 0, sizeof(psOptions->sEnvelop));
psOptions->papszCreationOptions = NULL;
psOptions->papszLayers = NULL;
psOptions->pszSQL = NULL;
psOptions->pszDialect = NULL;
psOptions->pszBurnAttribute = NULL;
psOptions->pszWHERE = NULL;
psOptions->papszRasterizeOptions = NULL;
psOptions->dfXRes = 0;
psOptions->dfYRes = 0;
psOptions->bCreateOutput = FALSE;
psOptions->eOutputType = GDT_Float64;
psOptions->bNoDataSet = FALSE;
psOptions->dfNoData = 0;
psOptions->bGotBounds = FALSE;
psOptions->nXSize = 0;
psOptions->nYSize = 0;
psOptions->hSRS = NULL;
psOptions->bTargetAlignedPixels = FALSE;
/* -------------------------------------------------------------------- */
/* Handle command line arguments. */
/* -------------------------------------------------------------------- */
int argc = CSLCount(papszArgv);
for( int i = 0; i < argc; i++ )
{
if( EQUAL(papszArgv[i],"-of") && i < argc-1 )
{
++i;
CPLFree(psOptions->pszFormat);
psOptions->pszFormat = CPLStrdup(papszArgv[i]);
psOptions->bCreateOutput = TRUE;
if( psOptionsForBinary )
{
psOptionsForBinary->bFormatExplicitlySet = TRUE;
}
}
else if( EQUAL(papszArgv[i],"-q") || EQUAL(papszArgv[i],"-quiet") )
{
if( psOptionsForBinary )
psOptionsForBinary->bQuiet = TRUE;
}
else if( EQUAL(papszArgv[i],"-a") && i < argc-1 )
{
CPLFree(psOptions->pszBurnAttribute);
psOptions->pszBurnAttribute = CPLStrdup(papszArgv[++i]);
}
else if( EQUAL(papszArgv[i],"-b") && i < argc-1 )
{
if (strchr(papszArgv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( papszArgv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
psOptions->anBandList.push_back(atoi(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(papszArgv[i+1]))
{
psOptions->anBandList.push_back(atoi(papszArgv[i+1]));
i += 1;
}
}
}
else if( EQUAL(papszArgv[i],"-3d") )
{
psOptions->b3D = TRUE;
psOptions->papszRasterizeOptions =
CSLSetNameValue( psOptions->papszRasterizeOptions, "BURN_VALUE_FROM", "Z");
}
else if( EQUAL(papszArgv[i],"-add") )
{
psOptions->papszRasterizeOptions =
CSLSetNameValue( psOptions->papszRasterizeOptions, "MERGE_ALG", "ADD");
}
else if( EQUAL(papszArgv[i],"-chunkysize") && i < argc-1 )
{
psOptions->papszRasterizeOptions =
CSLSetNameValue( psOptions->papszRasterizeOptions, "CHUNKYSIZE",
papszArgv[++i] );
}
else if( EQUAL(papszArgv[i],"-i") )
{
psOptions->bInverse = TRUE;
}
else if( EQUAL(papszArgv[i],"-at") )
{
psOptions->papszRasterizeOptions =
CSLSetNameValue( psOptions->papszRasterizeOptions, "ALL_TOUCHED", "TRUE" );
}
else if( EQUAL(papszArgv[i],"-burn") && i < argc-1 )
{
if (strchr(papszArgv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( papszArgv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
psOptions->adfBurnValues.push_back(CPLAtof(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(papszArgv[i+1]))
{
psOptions->adfBurnValues.push_back(CPLAtof(papszArgv[i+1]));
i += 1;
}
}
}
else if( EQUAL(papszArgv[i],"-where") && i < argc-1 )
{
CPLFree(psOptions->pszWHERE);
psOptions->pszWHERE = CPLStrdup(papszArgv[++i]);
}
else if( EQUAL(papszArgv[i],"-l") && i < argc-1 )
{
psOptions->papszLayers = CSLAddString( psOptions->papszLayers, papszArgv[++i] );
}
else if( EQUAL(papszArgv[i],"-sql") && i < argc-1 )
{
CPLFree(psOptions->pszSQL);
psOptions->pszSQL = CPLStrdup(papszArgv[++i]);
}
else if( EQUAL(papszArgv[i],"-dialect") && i < argc-1 )
{
CPLFree(psOptions->pszDialect);
psOptions->pszDialect = CPLStrdup(papszArgv[++i]);
}
else if( EQUAL(papszArgv[i],"-init") && i < argc - 1 )
{
if (strchr(papszArgv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( papszArgv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
psOptions->adfInitVals.push_back(CPLAtof(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(papszArgv[i+1]))
{
psOptions->adfInitVals.push_back(CPLAtof(papszArgv[i+1]));
i += 1;
}
}
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-a_nodata") && i < argc - 1 )
{
psOptions->dfNoData = CPLAtof(papszArgv[i+1]);
psOptions->bNoDataSet = TRUE;
i += 1;
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-a_srs") && i < argc-1 )
{
OSRDestroySpatialReference(psOptions->hSRS);
psOptions->hSRS = OSRNewSpatialReference( NULL );
if( OSRSetFromUserInput(psOptions->hSRS, papszArgv[i+1]) != OGRERR_NONE )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Failed to process SRS definition: %s",
papszArgv[i+1] );
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
i++;
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-te") && i < argc - 4 )
{
psOptions->sEnvelop.MinX = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MinY = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MaxX = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MaxY = CPLAtof(papszArgv[++i]);
psOptions->bGotBounds = TRUE;
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-a_ullr") && i < argc - 4 )
{
psOptions->sEnvelop.MinX = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MaxY = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MaxX = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MinY = CPLAtof(papszArgv[++i]);
psOptions->bGotBounds = TRUE;
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-co") && i < argc-1 )
{
psOptions->papszCreationOptions = CSLAddString( psOptions->papszCreationOptions, papszArgv[++i] );
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-ot") && i < argc-1 )
{
int iType;
for( iType = 1; iType < GDT_TypeCount; iType++ )
{
if( GDALGetDataTypeName((GDALDataType)iType) != NULL
&& EQUAL(GDALGetDataTypeName((GDALDataType)iType),
papszArgv[i+1]) )
{
psOptions->eOutputType = (GDALDataType) iType;
}
}
if( psOptions->eOutputType == GDT_Unknown )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unknown output pixel type: %s", papszArgv[i+1] );
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
i++;
psOptions->bCreateOutput = TRUE;
}
else if( (EQUAL(papszArgv[i],"-ts") || EQUAL(papszArgv[i],"-outsize")) && i < argc-2 )
{
psOptions->nXSize = atoi(papszArgv[++i]);
psOptions->nYSize = atoi(papszArgv[++i]);
if (psOptions->nXSize <= 0 || psOptions->nYSize <= 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Wrong value for -outsize parameter.");
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-tr") && i < argc-2 )
{
psOptions->dfXRes = CPLAtof(papszArgv[++i]);
psOptions->dfYRes = fabs(CPLAtof(papszArgv[++i]));
if( psOptions->dfXRes == 0 || psOptions->dfYRes == 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Wrong value for -tr parameter.");
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-tap") )
{
psOptions->bTargetAlignedPixels = TRUE;
psOptions->bCreateOutput = TRUE;
}
else if( papszArgv[i][0] == '-' )
{
CPLError(CE_Failure, CPLE_NotSupported,
"Unknown option name '%s'", papszArgv[i]);
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
else if( psOptionsForBinary && psOptionsForBinary->pszSource == NULL )
{
psOptionsForBinary->pszSource = CPLStrdup(papszArgv[i]);
}
else if( psOptionsForBinary && psOptionsForBinary->pszDest == NULL )
{
psOptionsForBinary->pszDest = CPLStrdup(papszArgv[i]);
}
else
{
CPLError(CE_Failure, CPLE_NotSupported,
"Too many command options '%s'", papszArgv[i]);
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
}
if( psOptions->adfBurnValues.size() == 0 &&
psOptions->pszBurnAttribute == NULL && !(psOptions->b3D) )
{
if( psOptionsForBinary == NULL )
psOptions->adfBurnValues.push_back(255);
else
{
CPLError(CE_Failure, CPLE_NotSupported, "At least one of -3d, -burn or -a required." );
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
}
if( psOptions->bCreateOutput )
{
if( psOptions->dfXRes == 0 && psOptions->dfYRes == 0 && psOptions->nXSize == 0 && psOptions->nYSize == 0 )
{
CPLError(CE_Failure, CPLE_NotSupported, "'-tr xres yres' or '-ts xsize ysize' is required." );
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
if (psOptions->bTargetAlignedPixels && psOptions->dfXRes == 0 && psOptions->dfYRes == 0)
{
CPLError(CE_Failure, CPLE_NotSupported, "-tap option cannot be used without using -tr.");
GDALRasterizeOptionsFree(psOptions);
return NULL;;
}
if( psOptions->anBandList.size() != 0 )
{
CPLError(CE_Failure, CPLE_NotSupported, "-b option cannot be used when creating a GDAL dataset." );
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
int nBandCount = 1;
if (psOptions->adfBurnValues.size() != 0)
nBandCount = static_cast<int>(psOptions->adfBurnValues.size());
if ((int)psOptions->adfInitVals.size() > nBandCount)
nBandCount = static_cast<int>(psOptions->adfInitVals.size());
if (psOptions->adfInitVals.size() == 1)
{
for(int i=1;i<=nBandCount - 1;i++)
psOptions->adfInitVals.push_back( psOptions->adfInitVals[0] );
}
int i;
for(i=1;i<=nBandCount;i++)
psOptions->anBandList.push_back( i );
}
else
{
if( psOptions->anBandList.size() == 0 )
psOptions->anBandList.push_back( 1 );
}
if( psOptions->pszDialect != NULL && psOptions->pszWHERE != NULL && psOptions->pszSQL == NULL )
{
CPLError( CE_Warning, CPLE_AppDefined,
"-dialect is ignored with -where. Use -sql instead" );
}
if( psOptionsForBinary )
{
psOptionsForBinary->bCreateOutput = psOptions->bCreateOutput;
psOptionsForBinary->pszFormat = CPLStrdup(psOptions->pszFormat);
}
return psOptions;
}
void E00GRIDDataset::ReadMetadata()
{
if (bHasReadMetadata)
return;
bHasReadMetadata = TRUE;
if (e00ReadPtr == NULL)
{
const int nRoundedBlockXSize = ((nRasterXSize + VALS_PER_LINE - 1) /
VALS_PER_LINE) * VALS_PER_LINE;
const vsi_l_offset nValsToSkip =
(vsi_l_offset)nRasterYSize * nRoundedBlockXSize;
const vsi_l_offset nLinesToSkip = nValsToSkip / VALS_PER_LINE;
const int nBytesPerLine = VALS_PER_LINE * E00_FLOAT_SIZE + nBytesEOL;
const vsi_l_offset nPos = nDataStart + nLinesToSkip * nBytesPerLine;
VSIFSeekL(fp, nPos, SEEK_SET);
}
else
{
nLastYOff = -1;
const unsigned int BUFFER_SIZE = 65536;
const unsigned int NEEDLE_SIZE = 3*5;
const unsigned int nToRead = BUFFER_SIZE - NEEDLE_SIZE;
char* pabyBuffer = (char*)CPLCalloc(1, BUFFER_SIZE+NEEDLE_SIZE);
int nRead;
int bEOGFound = FALSE;
VSIFSeekL(fp, 0, SEEK_END);
vsi_l_offset nEndPos = VSIFTellL(fp);
if (nEndPos > BUFFER_SIZE)
nEndPos -= BUFFER_SIZE;
else
nEndPos = 0;
VSIFSeekL(fp, nEndPos, SEEK_SET);
#define GOTO_NEXT_CHAR() \
i ++; \
if (pabyBuffer[i] == 13 || pabyBuffer[i] == 10) \
{ \
i++; \
if (pabyBuffer[i] == 10) \
i++; \
} \
while ((nRead = static_cast<int>(VSIFReadL(pabyBuffer, 1, nToRead, fp))) != 0)
{
int i;
for(i = 0; i < nRead; i++)
{
if (pabyBuffer[i] == 'E')
{
GOTO_NEXT_CHAR();
if (pabyBuffer[i] == 'O')
{
GOTO_NEXT_CHAR();
if (pabyBuffer[i] == 'G')
{
GOTO_NEXT_CHAR();
if (pabyBuffer[i] == '~')
{
GOTO_NEXT_CHAR();
if (pabyBuffer[i] == '}')
{
bEOGFound = TRUE;
break;
}
}
}
}
}
}
if (bEOGFound)
{
VSIFSeekL(fp, VSIFTellL(fp) - nRead + i + 1, SEEK_SET);
e00ReadPtr->iInBufPtr = 0;
e00ReadPtr->szInBuf[0] = '\0';
break;
}
if (nEndPos == 0)
break;
if ((unsigned int)nRead == nToRead)
{
memmove(pabyBuffer + nToRead, pabyBuffer, NEEDLE_SIZE);
if (nEndPos >= (vsi_l_offset)nToRead)
nEndPos -= nToRead;
else
nEndPos = 0;
VSIFSeekL(fp, nEndPos, SEEK_SET);
}
else
break;
}
CPLFree(pabyBuffer);
if (!bEOGFound)
return;
}
const char* pszLine = NULL;
bool bPRJFound = false;
bool bStatsFound = false;
while((pszLine = ReadLine()) != NULL)
{
if (STARTS_WITH_CI(pszLine, "PRJ 2"))
{
bPRJFound = true;
while((pszLine = ReadLine()) != NULL)
{
if (EQUAL(pszLine, "EOP"))
{
break;
}
papszPrj = CSLAddString(papszPrj, pszLine);
}
OGRSpatialReference oSRS;
if( oSRS.importFromESRI( papszPrj ) != OGRERR_NONE )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Failed to parse PRJ section, ignoring." );
}
else
{
char* pszWKT = NULL;
if (oSRS.exportToWkt(&pszWKT) == OGRERR_NONE && pszWKT != NULL)
osProjection = pszWKT;
CPLFree(pszWKT);
}
if (bStatsFound)
break;
}
else if (strcmp(pszLine, "STDV 8-1 254-1 15 3 60-1 -1 -1-1 4-") == 0)
{
bStatsFound = true;
pszLine = ReadLine();
if (pszLine)
{
CPLString osStats = pszLine;
pszLine = ReadLine();
if (pszLine)
{
osStats += pszLine;
char** papszTokens = CSLTokenizeString(osStats);
if (CSLCount(papszTokens) == 4)
{
dfMin = CPLAtof(papszTokens[0]);
dfMax = CPLAtof(papszTokens[1]);
dfMean = CPLAtof(papszTokens[2]);
dfStddev = CPLAtof(papszTokens[3]);
bHasStats = TRUE;
}
CSLDestroy(papszTokens);
}
}
if (bPRJFound)
break;
}
}
}
OGRErr OGRDataSource::ProcessSQLDropIndex( const char *pszSQLCommand )
{
char **papszTokens = CSLTokenizeString( pszSQLCommand );
/* -------------------------------------------------------------------- */
/* Do some general syntax checking. */
/* -------------------------------------------------------------------- */
if( (CSLCount(papszTokens) != 4 && CSLCount(papszTokens) != 6)
|| !EQUAL(papszTokens[0],"DROP")
|| !EQUAL(papszTokens[1],"INDEX")
|| !EQUAL(papszTokens[2],"ON")
|| (CSLCount(papszTokens) == 6 && !EQUAL(papszTokens[4],"USING")) )
{
CSLDestroy( papszTokens );
CPLError( CE_Failure, CPLE_AppDefined,
"Syntax error in DROP INDEX command.\n"
"Was '%s'\n"
"Should be of form 'DROP INDEX ON <table> [USING <field>]'",
pszSQLCommand );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Find the named layer. */
/* -------------------------------------------------------------------- */
int i;
OGRLayer *poLayer=NULL;
for( i = 0; i < GetLayerCount(); i++ )
{
poLayer = GetLayer(i);
if( EQUAL(poLayer->GetLayerDefn()->GetName(),papszTokens[3]) )
break;
}
if( i >= GetLayerCount() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"CREATE INDEX ON failed, no such layer as `%s'.",
papszTokens[3] );
CSLDestroy( papszTokens );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Does this layer even support attribute indexes? */
/* -------------------------------------------------------------------- */
if( poLayer->GetIndex() == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Indexes not supported by this driver." );
CSLDestroy( papszTokens );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* If we weren't given a field name, drop all indexes. */
/* -------------------------------------------------------------------- */
OGRErr eErr;
if( CSLCount(papszTokens) == 4 )
{
for( i = 0; i < poLayer->GetLayerDefn()->GetFieldCount(); i++ )
{
OGRAttrIndex *poAttrIndex;
poAttrIndex = poLayer->GetIndex()->GetFieldIndex(i);
if( poAttrIndex != NULL )
{
eErr = poLayer->GetIndex()->DropIndex( i );
if( eErr != OGRERR_NONE )
return eErr;
}
}
CSLDestroy(papszTokens);
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* Find the named field. */
/* -------------------------------------------------------------------- */
for( i = 0; i < poLayer->GetLayerDefn()->GetFieldCount(); i++ )
{
if( EQUAL(papszTokens[5],
poLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef()) )
break;
}
CSLDestroy( papszTokens );
if( i >= poLayer->GetLayerDefn()->GetFieldCount() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"`%s' failed, field not found.",
pszSQLCommand );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Attempt to drop the index. */
/* -------------------------------------------------------------------- */
eErr = poLayer->GetIndex()->DropIndex( i );
return eErr;
}
