static int OGRPGDriverIdentify( GDALOpenInfo* poOpenInfo )
{
if( !STARTS_WITH_CI(poOpenInfo->pszFilename, "PGB:") &&
!STARTS_WITH_CI(poOpenInfo->pszFilename, "PG:") )
return FALSE;
return TRUE;
}
int DTEDDataset::Identify( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Does the file start with one of the possible DTED header */
/* record types, and do we have a UHL marker? */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 240 )
return FALSE;
if( !STARTS_WITH_CI((const char *)poOpenInfo->pabyHeader, "VOL")
&& !STARTS_WITH_CI((const char *)poOpenInfo->pabyHeader, "HDR")
&& !STARTS_WITH_CI((const char *)poOpenInfo->pabyHeader, "UHL") )
{
return FALSE;
}
bool bFoundUHL = false;
for(int i=0;i<poOpenInfo->nHeaderBytes-3 && !bFoundUHL ;i += DTED_UHL_SIZE)
{
if( STARTS_WITH_CI((const char *)poOpenInfo->pabyHeader + i, "UHL") )
{
bFoundUHL = true;
}
}
if (!bFoundUHL)
return FALSE;
return TRUE;
}
int TSXDataset::Identify( GDALOpenInfo *poOpenInfo )
{
if (poOpenInfo->fpL == NULL || poOpenInfo->nHeaderBytes < 260)
{
if( poOpenInfo->bIsDirectory )
{
const CPLString osFilename =
CPLFormCIFilename( poOpenInfo->pszFilename, CPLGetFilename( poOpenInfo->pszFilename ), "xml" );
/* Check if the filename contains TSX1_SAR (TerraSAR-X) or TDX1_SAR (TanDEM-X) */
if (!(STARTS_WITH_CI(CPLGetBasename( osFilename ), "TSX1_SAR") ||
STARTS_WITH_CI(CPLGetBasename( osFilename ), "TDX1_SAR")))
return 0;
VSIStatBufL sStat;
if( VSIStatL( osFilename, &sStat ) == 0 )
return 1;
}
return 0;
}
/* Check if the filename contains TSX1_SAR (TerraSAR-X) or TDX1_SAR (TanDEM-X) */
if (!(STARTS_WITH_CI(CPLGetBasename( poOpenInfo->pszFilename ), "TSX1_SAR") ||
STARTS_WITH_CI(CPLGetBasename( poOpenInfo->pszFilename ), "TDX1_SAR")))
return 0;
/* finally look for the <level1Product tag */
if (!STARTS_WITH_CI(reinterpret_cast<char *>( poOpenInfo->pabyHeader ),
"<level1Product") )
return 0;
return 1;
}
static GDALDataset *OGRBNADriverOpen( GDALOpenInfo* poOpenInfo )
{
// --------------------------------------------------------------------
// Does this appear to be a .bna file?
// --------------------------------------------------------------------
const char* pszFilename = poOpenInfo->pszFilename;
if( STARTS_WITH_CI(pszFilename, "BNA:") )
{
pszFilename += 4;
}
else if( poOpenInfo->fpL == nullptr ||
!(EQUAL( CPLGetExtension(pszFilename), "bna" )
|| ((STARTS_WITH_CI(pszFilename, "/vsigzip/") ||
STARTS_WITH_CI(pszFilename, "/vsizip/")) &&
(strstr( pszFilename, ".bna") ||
strstr( pszFilename, ".BNA")))) )
{
return nullptr;
}
OGRBNADataSource *poDS = new OGRBNADataSource();
if( !poDS->Open( pszFilename, poOpenInfo->eAccess == GA_Update ) )
{
delete poDS;
poDS = nullptr;
}
return poDS;
}
static GDALDataset* OGRGeoJSONDriverOpen( GDALOpenInfo* poOpenInfo )
{
GeoJSONSourceType nSrcType;
if( OGRGeoJSONDriverIdentifyInternal(poOpenInfo, nSrcType) == FALSE )
return NULL;
OGRGeoJSONDataSource* poDS
= new OGRGeoJSONDataSource();
/* -------------------------------------------------------------------- */
/* Processing configuration options. */
/* -------------------------------------------------------------------- */
// TODO: Currently, options are based on environment variables.
// This is workaround for not yet implemented Andrey's concept
// described in document 'RFC 10: OGR Open Parameters'.
poDS->SetGeometryTranslation( OGRGeoJSONDataSource::eGeometryPreserve );
const char* pszOpt = CPLGetConfigOption("GEOMETRY_AS_COLLECTION", NULL);
if( NULL != pszOpt && STARTS_WITH_CI(pszOpt, "YES") )
{
poDS->SetGeometryTranslation(
OGRGeoJSONDataSource::eGeometryAsCollection );
}
poDS->SetAttributesTranslation( OGRGeoJSONDataSource::eAttributesPreserve );
pszOpt = CPLGetConfigOption("ATTRIBUTES_SKIP", NULL);
if( NULL != pszOpt && STARTS_WITH_CI(pszOpt, "YES") )
{
poDS->SetAttributesTranslation(
OGRGeoJSONDataSource::eAttributesSkip );
}
/* -------------------------------------------------------------------- */
/* Open and start processing GeoJSON datasource to OGR objects. */
/* -------------------------------------------------------------------- */
if( !poDS->Open( poOpenInfo, nSrcType ) )
{
delete poDS;
poDS = NULL;
}
if( poDS != NULL && poDS->HasOtherPages() )
{
const char* pszFSP = CSLFetchNameValue(poOpenInfo->papszOpenOptions,
"FEATURE_SERVER_PAGING");
bool bHasResultOffset = CPLURLGetValue( poOpenInfo->pszFilename,
"resultOffset").size() > 0;
if( (!bHasResultOffset && (pszFSP == NULL || CPLTestBool(pszFSP))) ||
(bHasResultOffset && pszFSP != NULL && CPLTestBool(pszFSP)) )
{
return new OGRESRIFeatureServiceDataset(poOpenInfo->pszFilename,
poDS);
}
}
return poDS;
}
int NDFDataset::Identify( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* The user must select the header file (i.e. .H1). */
/* -------------------------------------------------------------------- */
return poOpenInfo->nHeaderBytes >= 50 &&
(STARTS_WITH_CI(reinterpret_cast<const char *>( poOpenInfo->pabyHeader ), "NDF_REVISION=2")
|| STARTS_WITH_CI(reinterpret_cast<const char *>( poOpenInfo->pabyHeader ), "NDF_REVISION=0")) ;
}
/*
* ExecuteSQL()
*/
OGRLayer *OGRNGWDataset::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter, const char *pszDialect )
{
// Clean statement string.
CPLString osStatement(pszStatement);
osStatement = osStatement.Trim().replaceAll(" ", " ");
if( STARTS_WITH_CI(osStatement.c_str(), "DELLAYER:") )
{
CPLString osLayerName = osStatement.substr(9);
if( osLayerName.endsWith(";") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 1);
osLayerName.Trim();
}
CPLDebug("NGW", "Delete layer with name %s.", osLayerName.c_str());
for( int iLayer = 0; iLayer < nLayers; ++iLayer )
{
if( EQUAL(papoLayers[iLayer]->GetName(), osLayerName.c_str() ) )
{
DeleteLayer( iLayer );
break;
}
}
return nullptr;
}
if( STARTS_WITH_CI(osStatement.c_str(), "DELETE FROM") )
{
// Get layer name from pszStatement DELETE FROM layer;.
CPLString osLayerName = osStatement.substr(12);
if( osLayerName.endsWith(";") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 1);
osLayerName.Trim();
}
CPLDebug("NGW", "Delete features from layer with name %s.", osLayerName.c_str());
OGRNGWLayer *poLayer = static_cast<OGRNGWLayer*>(GetLayerByName(osLayerName));
if( poLayer )
{
poLayer->DeleteAllFeatures();
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "Unknown layer : %s",
osLayerName.c_str());
}
return nullptr;
}
return GDALDataset::ExecuteSQL(pszStatement, poSpatialFilter, pszDialect);
}
int TABIDFile::Open(const char *pszFname, const char* pszAccess)
{
if( STARTS_WITH_CI(pszAccess, "r") )
return Open(pszFname, TABRead);
else if( STARTS_WITH_CI(pszAccess, "w") )
return Open(pszFname, TABWrite);
else
{
CPLError(CE_Failure, CPLE_FileIO,
"Open() failed: access mode \"%s\" not supported", pszAccess);
return -1;
}
}
static int GNMDBDriverIdentify( GDALOpenInfo* poOpenInfo )
{
if( !STARTS_WITH_CI(poOpenInfo->pszFilename, "PGB:") &&
!STARTS_WITH_CI(poOpenInfo->pszFilename, "PG:") )
return FALSE;
if( (poOpenInfo->nOpenFlags & GDAL_OF_GNM) == 0 )
return FALSE;
// TODO: do we need to open datasource end check tables/layer exist?
return TRUE;
}
GeoJSONProtocolType GeoJSONGetProtocolType( const char* pszSource )
{
GeoJSONProtocolType ptclType = eGeoJSONProtocolUnknown;
if( STARTS_WITH_CI(pszSource, "http:") )
ptclType = eGeoJSONProtocolHTTP;
else if( STARTS_WITH_CI(pszSource, "https:") )
ptclType = eGeoJSONProtocolHTTPS;
else if( STARTS_WITH_CI(pszSource, "ftp:") )
ptclType = eGeoJSONProtocolFTP;
return ptclType;
}
int IMapInfoFile::Open(const char *pszFname, const char* pszAccess,
GBool bTestOpenNoError)
{
if( STARTS_WITH_CI(pszAccess, "r") )
return Open(pszFname, TABRead, bTestOpenNoError);
else if( STARTS_WITH_CI(pszAccess, "w") )
return Open(pszFname, TABWrite, bTestOpenNoError);
else
{
CPLError(CE_Failure, CPLE_FileIO,
"Open() failed: access mode \"%s\" not supported", pszAccess);
return -1;
}
}
int E00GRIDDataset::Identify( GDALOpenInfo * poOpenInfo )
{
if (poOpenInfo->nHeaderBytes == 0)
return FALSE;
if (!(STARTS_WITH_CI((const char*)poOpenInfo->pabyHeader, "EXP 0") ||
STARTS_WITH_CI((const char*)poOpenInfo->pabyHeader, "EXP 1")))
return FALSE;
/* FIXME: handle GRD 3 if that ever exists ? */
if (strstr((const char*)poOpenInfo->pabyHeader, "GRD 2") == NULL)
return FALSE;
return TRUE;
}
void *MEMDataset::GetInternalHandle( const char * pszRequest )
{
// check for MEMORYnnn string in pszRequest (nnnn can be up to 10
// digits, or even omitted)
if( STARTS_WITH_CI(pszRequest, "MEMORY"))
{
if(int BandNumber = static_cast<int>(CPLScanLong(&pszRequest[6], 10)))
{
MEMRasterBand *RequestedRasterBand =
reinterpret_cast<MEMRasterBand *>( GetRasterBand(BandNumber) );
// we're within a MEMDataset so the only thing a RasterBand
// could be is a MEMRasterBand
if( RequestedRasterBand != NULL )
{
// return the internal band data pointer
return(RequestedRasterBand->GetData());
}
}
}
return NULL;
}
CPLString OGRGFTLayer::PatchSQL(const char* pszSQL)
{
CPLString osSQL;
while(*pszSQL)
{
if (STARTS_WITH_CI(pszSQL, "COUNT(") && strchr(pszSQL, ')'))
{
const char* pszNext = strchr(pszSQL, ')');
osSQL += "COUNT()";
pszSQL = pszNext + 1;
}
else if ((*pszSQL == '<' && pszSQL[1] == '>') ||
(*pszSQL == '!' && pszSQL[1] == '='))
{
osSQL += " NOT EQUAL TO ";
pszSQL += 2;
}
else
{
osSQL += *pszSQL;
pszSQL ++;
}
}
return osSQL;
}
static int OGRDB2DriverIdentify( GDALOpenInfo* poOpenInfo )
{
if( STARTS_WITH_CI(poOpenInfo->pszFilename, DB2ODBC_PREFIX) )
return TRUE;
return FALSE;
}
PAuxRasterBand::PAuxRasterBand( GDALDataset *poDSIn, int nBandIn,
VSILFILE * fpRawIn, vsi_l_offset nImgOffsetIn,
int nPixelOffsetIn, int nLineOffsetIn,
GDALDataType eDataTypeIn, int bNativeOrderIn ) :
RawRasterBand( poDSIn, nBandIn, fpRawIn,
nImgOffsetIn, nPixelOffsetIn, nLineOffsetIn,
eDataTypeIn, bNativeOrderIn, RawRasterBand::OwnFP::NO )
{
PAuxDataset *poPDS = reinterpret_cast<PAuxDataset *>( poDS );
/* -------------------------------------------------------------------- */
/* Does this channel have a description? */
/* -------------------------------------------------------------------- */
char szTarget[128] = { '\0' };
snprintf( szTarget, sizeof(szTarget), "ChanDesc-%d", nBand );
if( CSLFetchNameValue( poPDS->papszAuxLines, szTarget ) != nullptr )
GDALRasterBand::SetDescription(
CSLFetchNameValue( poPDS->papszAuxLines, szTarget ) );
/* -------------------------------------------------------------------- */
/* See if we have colors. Currently we must have color zero, */
/* but this should not really be a limitation. */
/* -------------------------------------------------------------------- */
snprintf( szTarget, sizeof(szTarget),
"METADATA_IMG_%d_Class_%d_Color", nBand, 0 );
if( CSLFetchNameValue( poPDS->papszAuxLines, szTarget ) != nullptr )
{
poCT = new GDALColorTable();
for( int i = 0; i < 256; i++ )
{
snprintf( szTarget, sizeof(szTarget),
"METADATA_IMG_%d_Class_%d_Color", nBand, i );
const char *pszLine
= CSLFetchNameValue( poPDS->papszAuxLines, szTarget );
while( pszLine && *pszLine == ' ' )
pszLine++;
int nRed = 0;
int nGreen = 0;
int nBlue = 0;
// TODO(schwehr): Replace sscanf with something safe.
if( pszLine != nullptr
&& STARTS_WITH_CI(pszLine, "(RGB:")
&& sscanf( pszLine+5, "%d %d %d",
&nRed, &nGreen, &nBlue ) == 3 )
{
GDALColorEntry oColor = {
static_cast<short>(nRed),
static_cast<short>(nGreen),
static_cast<short>(nBlue),
255
};
poCT->SetColorEntry( i, &oColor );
}
}
}
}
int VSISubFileFilesystemHandler::Stat( const char * pszFilename,
VSIStatBufL * psStatBuf,
int nFlags )
{
if( !STARTS_WITH_CI(pszFilename, "/vsisubfile/") )
return -1;
CPLString osSubFilePath;
vsi_l_offset nOff = 0;
vsi_l_offset nSize = 0;
memset( psStatBuf, 0, sizeof(VSIStatBufL) );
if( !DecomposePath( pszFilename, osSubFilePath, nOff, nSize ) )
{
errno = ENOENT;
return -1;
}
const int nResult = VSIStatExL( osSubFilePath, psStatBuf, nFlags );
if( nResult == 0 )
{
if( nSize != 0 )
psStatBuf->st_size = nSize;
else
psStatBuf->st_size -= nOff;
}
return nResult;
}
CPLErr GDALMultiDomainMetadata::SetMetadata( char **papszMetadata,
const char *pszDomain )
{
if( pszDomain == nullptr )
pszDomain = "";
int iDomain = CSLFindString( papszDomainList, pszDomain );
if( iDomain == -1 )
{
papszDomainList = CSLAddString( papszDomainList, pszDomain );
const int nDomainCount = CSLCount( papszDomainList );
papoMetadataLists = static_cast<CPLStringList **>(
CPLRealloc( papoMetadataLists, sizeof(void*)*(nDomainCount+1) ));
papoMetadataLists[nDomainCount] = nullptr;
papoMetadataLists[nDomainCount-1] = new CPLStringList();
iDomain = nDomainCount-1;
}
papoMetadataLists[iDomain]->Assign( CSLDuplicate( papszMetadata ) );
// we want to mark name/value pair domains as being sorted for fast
// access.
if( !STARTS_WITH_CI(pszDomain, "xml:") && !EQUAL(pszDomain, "SUBDATASETS") )
papoMetadataLists[iDomain]->Sort();
return CE_None;
}
int LevellerDataset::Identify( GDALOpenInfo * poOpenInfo )
{
if( poOpenInfo->nHeaderBytes < 4 )
return FALSE;
return STARTS_WITH_CI(reinterpret_cast<const char *>( poOpenInfo->pabyHeader ), "trrn");
}
int HF2Dataset::Identify( GDALOpenInfo * poOpenInfo)
{
GDALOpenInfo* poOpenInfoToDelete = NULL;
/* GZipped .hf2 files are common, so automagically open them */
/* if the /vsigzip/ has not been explicitly passed */
CPLString osFilename(poOpenInfo->pszFilename);
if ((EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "hfz") ||
(strlen(poOpenInfo->pszFilename) > 6 &&
EQUAL(poOpenInfo->pszFilename + strlen(poOpenInfo->pszFilename) - 6, "hf2.gz"))) &&
!STARTS_WITH_CI(poOpenInfo->pszFilename, "/vsigzip/"))
{
osFilename = "/vsigzip/";
osFilename += poOpenInfo->pszFilename;
poOpenInfo = poOpenInfoToDelete =
new GDALOpenInfo(osFilename.c_str(), GA_ReadOnly,
poOpenInfo->GetSiblingFiles());
}
if (poOpenInfo->nHeaderBytes < 28)
{
delete poOpenInfoToDelete;
return FALSE;
}
if (memcmp(poOpenInfo->pabyHeader, "HF2\0\0\0\0", 6) != 0)
{
delete poOpenInfoToDelete;
return FALSE;
}
delete poOpenInfoToDelete;
return TRUE;
}
OGRErr OGRSpatialReference::importFromDict( const char *pszDictFile,
const char *pszCode )
{
/* -------------------------------------------------------------------- */
/* Find and open file. */
/* -------------------------------------------------------------------- */
CPLString osDictFile(pszDictFile);
const char *pszFilename = CPLFindFile( "gdal", pszDictFile );
if( pszFilename == nullptr )
return OGRERR_UNSUPPORTED_SRS;
VSILFILE *fp = VSIFOpenL( pszFilename, "rb" );
if( fp == nullptr )
return OGRERR_UNSUPPORTED_SRS;
/* -------------------------------------------------------------------- */
/* Process lines. */
/* -------------------------------------------------------------------- */
OGRErr eErr = OGRERR_UNSUPPORTED_SRS;
const char *pszLine = nullptr;
while( (pszLine = CPLReadLineL(fp)) != nullptr )
{
if( pszLine[0] == '#' )
continue;
if( STARTS_WITH_CI(pszLine, "include ") )
{
eErr = importFromDict( pszLine + 8, pszCode );
if( eErr != OGRERR_UNSUPPORTED_SRS )
break;
continue;
}
if( strstr(pszLine, ",") == nullptr )
continue;
if( EQUALN(pszLine, pszCode, strlen(pszCode))
&& pszLine[strlen(pszCode)] == ',' )
{
const char *pszWKT = pszLine + strlen(pszCode)+1;
eErr = importFromWkt( pszWKT );
if( eErr == OGRERR_NONE && osDictFile.find("esri_") == 0 )
{
morphFromESRI();
}
break;
}
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
VSIFCloseL( fp );
return eErr;
}
int ECRGTOCDataset::Identify( GDALOpenInfo * poOpenInfo )
{
const char *pszFilename = poOpenInfo->pszFilename;
/* -------------------------------------------------------------------- */
/* Is this a sub-dataset selector? If so, it is obviously ECRGTOC. */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(pszFilename, "ECRG_TOC_ENTRY:"))
return TRUE;
/* -------------------------------------------------------------------- */
/* First we check to see if the file has the expected header */
/* bytes. */
/* -------------------------------------------------------------------- */
const char *pabyHeader
= reinterpret_cast<const char *>( poOpenInfo->pabyHeader );
if( pabyHeader == nullptr )
return FALSE;
if ( strstr(pabyHeader, "<Table_of_Contents") != nullptr &&
strstr(pabyHeader, "<file_header ") != nullptr)
return TRUE;
if ( strstr(pabyHeader, "<!DOCTYPE Table_of_Contents [") != nullptr)
return TRUE;
return FALSE;
}
static CPLErr PAuxDelete( const char * pszBasename )
{
VSILFILE *fp = VSIFOpenL( CPLResetExtension( pszBasename, "aux" ), "r" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a PAux dataset, there is no .aux file.",
pszBasename );
return CE_Failure;
}
const char *pszLine = CPLReadLineL( fp );
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
if( pszLine == NULL || !STARTS_WITH_CI(pszLine, "AuxilaryTarget") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a PAux dataset,\n"
"the .aux file does not start with AuxilaryTarget",
pszBasename );
return CE_Failure;
}
if( VSIUnlink( pszBasename ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"OS unlinking file %s.", pszBasename );
return CE_Failure;
}
VSIUnlink( CPLResetExtension( pszBasename, "aux" ) );
return CE_None;
}
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;
}
int CTGDataset::Identify( GDALOpenInfo * poOpenInfo )
{
CPLString osFilename(poOpenInfo->pszFilename);
GDALOpenInfo* poOpenInfoToDelete = NULL;
/* GZipped grid_cell.gz files are common, so automagically open them */
/* if the /vsigzip/ has not been explicitly passed */
const char* pszFilename = CPLGetFilename(poOpenInfo->pszFilename);
if ((EQUAL(pszFilename, "grid_cell.gz") ||
EQUAL(pszFilename, "grid_cell1.gz") ||
EQUAL(pszFilename, "grid_cell2.gz")) &&
!STARTS_WITH_CI(poOpenInfo->pszFilename, "/vsigzip/"))
{
osFilename = "/vsigzip/";
osFilename += poOpenInfo->pszFilename;
poOpenInfo = poOpenInfoToDelete =
new GDALOpenInfo(osFilename.c_str(), GA_ReadOnly,
poOpenInfo->GetSiblingFiles());
}
if (poOpenInfo->nHeaderBytes < HEADER_LINE_COUNT * 80)
{
delete poOpenInfoToDelete;
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Chech that it looks roughly as a CTG dataset */
/* -------------------------------------------------------------------- */
const char* pszData = (const char*)poOpenInfo->pabyHeader;
for(int i=0;i<4 * 80;i++)
{
if (!((pszData[i] >= '0' && pszData[i] <= '9') ||
pszData[i] == ' ' || pszData[i] == '-'))
{
delete poOpenInfoToDelete;
return FALSE;
}
}
char szField[11];
int nRows = atoi(ExtractField(szField, pszData, 0, 10));
int nCols = atoi(ExtractField(szField, pszData, 20, 10));
int nMinColIndex = atoi(ExtractField(szField, pszData+80, 0, 5));
int nMinRowIndex = atoi(ExtractField(szField, pszData+80, 5, 5));
int nMaxColIndex = atoi(ExtractField(szField, pszData+80, 10, 5));
int nMaxRowIndex = atoi(ExtractField(szField, pszData+80, 15, 5));
if (nRows <= 0 || nCols <= 0 ||
nMinColIndex != 1 || nMinRowIndex != 1 ||
nMaxRowIndex != nRows || nMaxColIndex != nCols)
{
delete poOpenInfoToDelete;
return FALSE;
}
delete poOpenInfoToDelete;
return TRUE;
}
int HDF5ImageDataset::Identify( GDALOpenInfo *poOpenInfo )
{
if(!STARTS_WITH_CI(poOpenInfo->pszFilename, "HDF5:") )
return FALSE;
return TRUE;
}
int SAFEDataset::Identify( GDALOpenInfo *poOpenInfo )
{
/* Check for the case where we're trying to read the calibrated data: */
if (STARTS_WITH_CI(poOpenInfo->pszFilename, "SENTINEL1_CALIB:")) {
return TRUE;
}
/* Check for the case where we're trying to read the subdatasets: */
if (STARTS_WITH_CI(poOpenInfo->pszFilename, "SENTINEL1_DS:")) {
return TRUE;
}
/* Check for directory access when there is a manifest.safe file in the
directory. */
if( poOpenInfo->bIsDirectory )
{
VSIStatBufL sStat;
CPLString osMDFilename =
CPLFormCIFilename( poOpenInfo->pszFilename, "manifest.safe", nullptr );
if( VSIStatL( osMDFilename, &sStat ) == 0 && VSI_ISREG(sStat.st_mode) )
{
GDALOpenInfo oOpenInfo( osMDFilename, GA_ReadOnly, nullptr );
return Identify(&oOpenInfo);
}
return FALSE;
}
/* otherwise, do our normal stuff */
if( !EQUAL(CPLGetFilename(poOpenInfo->pszFilename), "manifest.safe") )
return FALSE;
if( poOpenInfo->nHeaderBytes < 100 )
return FALSE;
if( strstr((const char *) poOpenInfo->pabyHeader, "<xfdu:XFDU" ) == nullptr)
return FALSE;
// This driver doesn't handle Sentinel-2 data
if( strstr((const char *) poOpenInfo->pabyHeader, "sentinel-2" ) != nullptr)
return FALSE;
return TRUE;
}
/**
* Identify if the subdataset has a known product format
* It stores a product identifier in iSubdatasetType,
* UNKNOWN_PRODUCT, if it isn't a recognizable format.
*/
void HDF5ImageDataset::IdentifyProductType()
{
iSubdatasetType = UNKNOWN_PRODUCT;
/************************************************************************/
/* COSMO-SKYMED */
/************************************************************************/
//Get the Mission Id as a char *, because the
//field may not exist
const char * const pszMissionId = HDF5Dataset::GetMetadataItem("Mission_ID");
//If there is a Mission_ID field
if(pszMissionId != NULL && strstr(GetDescription(), "QLK") == NULL)
{
//Check if the mission type is CSK or KMPS
//KMPS: Komsat-5 is Korean mission with a SAR instrument.
if(EQUAL(pszMissionId,"CSK") || EQUAL(pszMissionId,"KMPS"))
{
iSubdatasetType = CSK_PRODUCT;
const char *osMissionLevel = NULL;
if(GetMetadataItem("Product_Type")!=NULL)
{
//Get the format's level
osMissionLevel = HDF5Dataset::GetMetadataItem("Product_Type");
if(STARTS_WITH_CI(osMissionLevel, "RAW"))
iCSKProductType = PROD_CSK_L0;
if(STARTS_WITH_CI(osMissionLevel, "SCS"))
iCSKProductType = PROD_CSK_L1A;
if(STARTS_WITH_CI(osMissionLevel, "DGM"))
iCSKProductType = PROD_CSK_L1B;
if(STARTS_WITH_CI(osMissionLevel, "GEC"))
iCSKProductType = PROD_CSK_L1C;
if(STARTS_WITH_CI(osMissionLevel, "GTC"))
iCSKProductType = PROD_CSK_L1D;
}
}
}
}
int RDataset::Identify( GDALOpenInfo *poOpenInfo )
{
if( poOpenInfo->nHeaderBytes < 50 )
return FALSE;
// If the extension is .rda and the file type is gzip
// compressed we assume it is a gzipped R binary file.
if( memcmp(poOpenInfo->pabyHeader, "\037\213\b", 3) == 0 &&
EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "rda") )
return TRUE;
// Is this an ASCII or XDR binary R file?
if( !STARTS_WITH_CI((const char *)poOpenInfo->pabyHeader, "RDA2\nA\n") &&
!STARTS_WITH_CI((const char *)poOpenInfo->pabyHeader, "RDX2\nX\n") )
return FALSE;
return TRUE;
}
/**
* GDALMDReaderLandsat()
*/
GDALMDReaderLandsat::GDALMDReaderLandsat(const char *pszPath,
char **papszSiblingFiles) : GDALMDReaderBase(pszPath, papszSiblingFiles)
{
const char* pszBaseName = CPLGetBasename(pszPath);
const char* pszDirName = CPLGetDirname(pszPath);
size_t nBaseNameLen = strlen(pszBaseName);
if( nBaseNameLen > 511 )
return;
// split file name by _B or _b
char szMetadataName[512] = {0};
size_t i;
for(i = 0; i < nBaseNameLen; i++)
{
szMetadataName[i] = pszBaseName[i];
if(STARTS_WITH_CI(pszBaseName + i, "_B") || STARTS_WITH_CI(pszBaseName + i, "_b"))
{
break;
}
}
// form metadata file name
CPLStrlcpy(szMetadataName + i, "_MTL.txt", 9);
const char* pszIMDSourceFilename = CPLFormFilename( pszDirName,
szMetadataName, NULL );
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
else
{
CPLStrlcpy(szMetadataName + i, "_MTL.TXT", 9);
pszIMDSourceFilename = CPLFormFilename( pszDirName, szMetadataName, NULL );
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
}
if( !m_osIMDSourceFilename.empty() )
CPLDebug( "MDReaderLandsat", "IMD Filename: %s",
m_osIMDSourceFilename.c_str() );
}
