bool wxGxOpenFileGDB::Move(const CPLString &szDestPath, ITrackCancel* const pTrackCancel)
{
wxGISDataset* pDSet = GetDatasetFast();
if (NULL != pDSet)
{
pDSet->Close();
wsDELETE(pDSet);
}
if (pTrackCancel)
pTrackCancel->PutMessage(wxString::Format(_("%s %s %s"), _("Move"), GetCategory().c_str(), m_sName.c_str()), wxNOT_FOUND, enumGISMessageInfo);
//CPLString szFullDestPath = CPLFormFilename(szDestPath, CPLGetFilename(m_sPath), NULL);
CPLString szFullDestPath = CheckUniqPath(szDestPath, CPLGetFilename(m_sPath), true, " ");
bool bRet = MoveDir(m_sPath, szFullDestPath, 777, pTrackCancel);
if (!bRet)
{
const char* err = CPLGetLastErrorMsg();
wxString sErr = wxString::Format(_("Operation '%s' failed! GDAL error: %s, %s '%s'"), _("Move"), GetCategory().c_str(), wxString(err, wxConvUTF8).c_str(), wxString(m_sPath, wxConvUTF8).c_str());
wxLogError(sErr);
if (pTrackCancel)
pTrackCancel->PutMessage(sErr, wxNOT_FOUND, enumGISMessageErr);
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;
}
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 explicitely passed */
const char* pszFilename = CPLGetFilename(poOpenInfo->pszFilename);
if ((EQUAL(pszFilename, "grid_cell.gz") ||
EQUAL(pszFilename, "grid_cell1.gz") ||
EQUAL(pszFilename, "grid_cell2.gz")) &&
!EQUALN(poOpenInfo->pszFilename, "/vsigzip/", 9))
{
osFilename = "/vsigzip/";
osFilename += poOpenInfo->pszFilename;
poOpenInfo = poOpenInfoToDelete =
new GDALOpenInfo(osFilename.c_str(), GA_ReadOnly,
poOpenInfo->papszSiblingFiles);
}
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;
int i;
for(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;
}
void OGRCSVDataSource::CreateForSingleFile( const char* pszDirname,
const char *pszFilename )
{
pszName = CPLStrdup( pszDirname );
bUpdate = true;
osDefaultCSVName = CPLGetFilename(pszFilename);
}
int TSXDataset::Identify( GDALOpenInfo *poOpenInfo )
{
if (poOpenInfo->fpL == NULL || poOpenInfo->nHeaderBytes < 260)
{
if( poOpenInfo->bIsDirectory )
{
CPLString osFilename =
CPLFormCIFilename( poOpenInfo->pszFilename, CPLGetFilename( poOpenInfo->pszFilename ), "xml" );
/* Check if the filename contains TSX1_SAR (TerraSAR-X) or TDX1_SAR (TanDEM-X) */
if (!(EQUALN(CPLGetBasename( osFilename ), "TSX1_SAR", 8) ||
EQUALN(CPLGetBasename( osFilename ), "TDX1_SAR", 8)))
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 (!(EQUALN(CPLGetBasename( poOpenInfo->pszFilename ), "TSX1_SAR", 8) ||
EQUALN(CPLGetBasename( poOpenInfo->pszFilename ), "TDX1_SAR", 8)))
return 0;
/* finally look for the <level1Product tag */
if (!EQUALN((char *)poOpenInfo->pabyHeader, "<level1Product", 14))
return 0;
return 1;
}
OGRErr OGRMILayerAttrIndex::SaveConfigToXML()
{
if( nIndexCount == 0 )
return OGRERR_NONE;
/* -------------------------------------------------------------------- */
/* Create the XML tree corresponding to this layer. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRoot;
psRoot = CPLCreateXMLNode( NULL, CXT_Element, "OGRMILayerAttrIndex" );
CPLCreateXMLElementAndValue( psRoot, "MIIDFilename",
CPLGetFilename( pszMIINDFilename ) );
for( int i = 0; i < nIndexCount; i++ )
{
OGRMIAttrIndex *poAI = papoIndexList[i];
CPLXMLNode *psIndex;
psIndex = CPLCreateXMLNode( psRoot, CXT_Element, "OGRMIAttrIndex" );
CPLCreateXMLElementAndValue( psIndex, "FieldIndex",
CPLSPrintf( "%d", poAI->iField ) );
CPLCreateXMLElementAndValue( psIndex, "FieldName",
poLayer->GetLayerDefn()->GetFieldDefn(poAI->iField)->GetNameRef() );
CPLCreateXMLElementAndValue( psIndex, "IndexIndex",
CPLSPrintf( "%d", poAI->iIndex ) );
}
/* -------------------------------------------------------------------- */
/* Save it. */
/* -------------------------------------------------------------------- */
char *pszRawXML = CPLSerializeXMLTree( psRoot );
FILE *fp;
CPLDestroyXMLNode( psRoot );
fp = VSIFOpen( pszMetadataFilename, "wb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to pen `%s' for write.",
pszMetadataFilename );
CPLFree( pszRawXML );
return OGRERR_FAILURE;
}
VSIFWrite( pszRawXML, 1, strlen(pszRawXML), fp );
VSIFClose( fp );
CPLFree( pszRawXML );
return OGRERR_NONE;
}
int SRTMHGTDataset::Identify( GDALOpenInfo * poOpenInfo )
{
const char* fileName = CPLGetFilename(poOpenInfo->pszFilename);
if( strlen(fileName) < 11 || fileName[7] != '.' )
return FALSE;
CPLString osLCFilename(CPLString(fileName).tolower());
if( (osLCFilename[0] != 'n' && osLCFilename[0] != 's') ||
(osLCFilename[3] != 'e' && osLCFilename[3] != 'w') )
return FALSE;
if( !STARTS_WITH(fileName, "/vsizip/") &&
osLCFilename.endsWith(".hgt.zip") )
{
CPLString osNewName("/vsizip/");
osNewName += poOpenInfo->pszFilename;
osNewName += "/";
osNewName += CPLString(fileName).substr(0, 7);
osNewName += ".hgt";
GDALOpenInfo oOpenInfo(osNewName, GA_ReadOnly);
return Identify(&oOpenInfo);
}
if( !STARTS_WITH(fileName, "/vsizip/") &&
osLCFilename.endsWith(".srtmswbd.raw.zip") )
{
CPLString osNewName("/vsizip/");
osNewName += poOpenInfo->pszFilename;
osNewName += "/";
osNewName += CPLString(fileName).substr(0, 7);
osNewName += ".raw";
GDALOpenInfo oOpenInfo(osNewName, GA_ReadOnly);
return Identify(&oOpenInfo);
}
if( !osLCFilename.endsWith(".hgt") &&
!osLCFilename.endsWith(".raw") &&
!osLCFilename.endsWith(".hgt.gz") )
return FALSE;
/* -------------------------------------------------------------------- */
/* We check the file size to see if it is */
/* SRTM1 (below or above lat 50) or SRTM 3 */
/* -------------------------------------------------------------------- */
VSIStatBufL fileStat;
if(VSIStatL(poOpenInfo->pszFilename, &fileStat) != 0)
return FALSE;
if(fileStat.st_size != 3601 * 3601 &&
fileStat.st_size != 3601 * 3601 * 2 &&
fileStat.st_size != 1801 * 3601 * 2 &&
fileStat.st_size != 1201 * 1201 * 2 )
return FALSE;
return TRUE;
}
int OGROpenFileGDBDataSource::FileExists(const char* pszFilename)
{
if( m_papszFiles )
return CSLFindString(m_papszFiles, CPLGetFilename(pszFilename)) >= 0;
else
{
VSIStatBufL sStat;
return VSIStatExL(pszFilename, &sStat, VSI_STAT_EXISTS_FLAG) == 0;
}
}
/**
* GDALMDReaderSpot()
*/
GDALMDReaderSpot::GDALMDReaderSpot(const char *pszPath,
char **papszSiblingFiles) : GDALMDReaderPleiades(pszPath, papszSiblingFiles)
{
const char* pszIMDSourceFilename;
const char* pszDirName = CPLGetDirname(pszPath);
if(m_osIMDSourceFilename.empty())
{
pszIMDSourceFilename = CPLFormFilename( pszDirName, "METADATA.DIM", NULL );
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
else
{
pszIMDSourceFilename = CPLFormFilename( pszDirName, "metadata.dim", NULL );
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
}
}
// if the file name ended on METADATA.DIM
// Linux specific
// example: R2_CAT_091028105025131_1\METADATA.DIM
if(m_osIMDSourceFilename.empty())
{
if(EQUAL(CPLGetFilename(pszPath), "IMAGERY.TIF"))
{
pszIMDSourceFilename = CPLSPrintf( "%s\\METADATA.DIM",
CPLGetPath(pszPath));
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
else
{
pszIMDSourceFilename = CPLSPrintf( "%s\\metadata.dim",
CPLGetPath(pszPath));
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
}
}
}
if(m_osIMDSourceFilename.size())
CPLDebug( "MDReaderSpot", "IMD Filename: %s",
m_osIMDSourceFilename.c_str() );
}
int OGRXPlaneDataSource::Open( const char * pszFilename, int bReadWholeFile )
{
Reset();
this->bReadWholeFile = bReadWholeFile;
const char* pszShortFilename = CPLGetFilename(pszFilename);
if (EQUAL(pszShortFilename, "nav.dat") ||
EQUAL(pszShortFilename, "earth_nav.dat"))
{
poReader = OGRXPlaneCreateNavFileReader(this);
}
else if (EQUAL(pszShortFilename, "apt.dat"))
{
poReader = OGRXPlaneCreateAptFileReader(this);
}
else if (EQUAL(pszShortFilename, "fix.dat") ||
EQUAL(pszShortFilename, "earth_fix.dat"))
{
poReader = OGRXPlaneCreateFixFileReader(this);
}
else if (EQUAL(pszShortFilename, "awy.dat") ||
EQUAL(pszShortFilename, "earth_awy.dat"))
{
poReader = OGRXPlaneCreateAwyFileReader(this);
}
int bRet;
if (poReader && poReader->StartParsing(pszFilename) == FALSE)
{
delete poReader;
poReader = NULL;
}
if (poReader)
{
pszName = CPLStrdup(pszFilename);
if ( !bReadWholeFile )
{
for( int i = 0; i < nLayers; i++ )
papoLayers[i]->SetReader(poReader->CloneForLayer(papoLayers[i]));
}
bRet = TRUE;
}
else
bRet = FALSE;
return bRet;
}
CPLErr
GDALDefaultOverviews::BuildOverviewsSubDataset(
const char * pszPhysicalFile,
const char * pszResampling,
int nOverviews, int * panOverviewList,
int nBands, int * panBandList,
GDALProgressFunc pfnProgress, void * pProgressData)
{
if( osOvrFilename.length() == 0 && nOverviews > 0 )
{
VSIStatBufL sStatBuf;
int iSequence = 0; // Used after for.
for( iSequence = 0; iSequence < 100; iSequence++ )
{
osOvrFilename.Printf( "%s_%d.ovr", pszPhysicalFile, iSequence );
if( VSIStatExL( osOvrFilename, &sStatBuf,
VSI_STAT_EXISTS_FLAG ) != 0 )
{
CPLString osAdjustedOvrFilename;
if( poDS->GetMOFlags() & GMO_PAM_CLASS )
{
osAdjustedOvrFilename.Printf(
":::BASE:::%s_%d.ovr",
CPLGetFilename(pszPhysicalFile),
iSequence );
}
else
{
osAdjustedOvrFilename = osOvrFilename;
}
poDS->SetMetadataItem( "OVERVIEW_FILE",
osAdjustedOvrFilename,
"OVERVIEWS" );
break;
}
}
if( iSequence == 100 )
osOvrFilename = "";
}
return BuildOverviews( NULL, pszResampling, nOverviews, panOverviewList,
nBands, panBandList, pfnProgress, pProgressData );
}
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;
}
bool wxGISDataset::Move(const CPLString &szDestPath, ITrackCancel* const pTrackCancel)
{
wxCriticalSectionLocker locker(m_CritSect);
Close();
char** papszFileList = GetFileList();
papszFileList = CSLAddString( papszFileList, m_sPath );
if(!papszFileList)
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("No files to move"), wxNOT_FOUND, enumGISMessageErr);
return false;
}
CPLString szFileName = CPLGetBasename(GetUniqPath(m_sPath, szDestPath, CPLGetBasename(m_sPath)));
char** papszMovedFileList = NULL;
for(int i = 0; papszFileList[i] != NULL; ++i )
{
CPLString szNewDestFileName(CPLFormFilename(szDestPath, szFileName, GetExtension(papszFileList[i], szFileName)));
papszMovedFileList = CSLAddString(papszMovedFileList, szNewDestFileName);
if(!MoveFile(szNewDestFileName, papszFileList[i], pTrackCancel))
{
// Try to put the ones we moved back.
pTrackCancel->Reset();
for( --i; i >= 0; i-- )
MoveFile( papszFileList[i], papszMovedFileList[i]);
CSLDestroy( papszFileList );
CSLDestroy( papszMovedFileList );
return false;
}
}
m_sPath = CPLFormFilename(szDestPath, CPLGetFilename(m_sPath), NULL);
CSLDestroy( papszFileList );
CSLDestroy( papszMovedFileList );
return true;
}
int SRTMHGTDataset::Identify( GDALOpenInfo * poOpenInfo )
{
const char* fileName = CPLGetFilename(poOpenInfo->pszFilename);
if( strlen(fileName) < 11 || !EQUALN(&fileName[7], ".hgt", 4) )
return FALSE;
/* -------------------------------------------------------------------- */
/* We check the file size to see if it is 25,934,402 bytes */
/* (SRTM 1) or 2,884,802 bytes (SRTM 3) */
/* -------------------------------------------------------------------- */
VSIStatBufL fileStat;
if(VSIStatL(poOpenInfo->pszFilename, &fileStat) != 0)
return FALSE;
if(fileStat.st_size != 25934402 && fileStat.st_size != 2884802)
return FALSE;
return TRUE;
}
static GDALDataset *OGRTABDriverOpen( GDALOpenInfo* poOpenInfo )
{
OGRTABDataSource *poDS;
if( OGRTABDriverIdentify(poOpenInfo) == FALSE )
{
return NULL;
}
if (EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "MIF") ||
EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "MID") )
{
if( poOpenInfo->eAccess == GA_Update )
return NULL;
}
#ifdef DEBUG
/* For AFL, so that .cur_input is detected as the archive filename */
if( poOpenInfo->fpL != NULL &&
!STARTS_WITH(poOpenInfo->pszFilename, "/vsitar/") &&
EQUAL(CPLGetFilename(poOpenInfo->pszFilename), ".cur_input") )
{
GDALOpenInfo oOpenInfo( (CPLString("/vsitar/") + poOpenInfo->pszFilename).c_str(),
poOpenInfo->nOpenFlags );
oOpenInfo.papszOpenOptions = poOpenInfo->papszOpenOptions;
return OGRTABDriverOpen(&oOpenInfo);
}
#endif
poDS = new OGRTABDataSource();
if( poDS->Open( poOpenInfo, TRUE ) )
return poDS;
else
{
delete poDS;
return NULL;
}
}
bool wxGxLocalDBFactory::GetChildren(wxGxObject* pParent, char** &pFileNames, wxArrayLong & pChildrenIds)
{
wxGxCatalogBase* pCatalog = GetGxCatalog();
bool bCheckNames = CSLCount(pFileNames) < CHECK_DUBLES_MAX_COUNT;
for(int i = CSLCount(pFileNames) - 1; i >= 0; i-- )
{
VSIStatBufL BufL;
int ret = VSIStatL(pFileNames[i], &BufL);
if(ret == 0)
{
if (VSI_ISDIR(BufL.st_mode) && wxGISEQUAL(CPLGetExtension(pFileNames[i]), "gdb"))
{
wxGxObject* pObj = GetGxObject(pParent, wxString(CPLGetFilename(pFileNames[i]), wxConvUTF8), pFileNames[i], enumContGDBFolder, bCheckNames);
if(pObj)
pChildrenIds.Add(pObj->GetId());
pFileNames = CSLRemoveStrings( pFileNames, i, 1, NULL );
}
//TODO: mdb, sqlite, db extensions
}
}
return true;
}
static int OGRTABDriverIdentify( GDALOpenInfo* poOpenInfo )
{
/* Files not ending with .tab, .mif or .mid are not handled by this driver */
if( !poOpenInfo->bStatOK )
return FALSE;
if( poOpenInfo->bIsDirectory )
return -1; /* unsure */
if( poOpenInfo->fpL == NULL )
return FALSE;
if (EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "MIF") ||
EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "MID") )
{
return TRUE;
}
if (EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "TAB") )
{
for( int i = 0; i < poOpenInfo->nHeaderBytes; i++)
{
const char* pszLine = (const char*)poOpenInfo->pabyHeader + i;
if (STARTS_WITH_CI(pszLine, "Fields"))
return TRUE;
else if (STARTS_WITH_CI(pszLine, "create view"))
return TRUE;
else if (STARTS_WITH_CI(pszLine, "\"\\IsSeamless\" = \"TRUE\""))
return TRUE;
}
}
#ifdef DEBUG
/* For AFL, so that .cur_input is detected as the archive filename */
if( !STARTS_WITH(poOpenInfo->pszFilename, "/vsitar/") &&
EQUAL(CPLGetFilename(poOpenInfo->pszFilename), ".cur_input") )
{
return -1;
}
#endif
return FALSE;
}
static CPLString getRscFilename( GDALOpenInfo *poOpenInfo )
{
CPLString osRscFilename;
char **papszSiblingFiles = poOpenInfo->GetSiblingFiles();
if ( papszSiblingFiles == NULL )
{
osRscFilename = CPLFormFilename( NULL, poOpenInfo->pszFilename,
"rsc" );
VSIStatBufL psRscStatBuf;
if ( VSIStatL( osRscFilename, &psRscStatBuf ) != 0 )
{
osRscFilename = "";
}
}
else
{
/* ------------------------------------------------------------ */
/* We need to tear apart the filename to form a .rsc */
/* filename. */
/* ------------------------------------------------------------ */
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
CPLString osName = CPLGetFilename( poOpenInfo->pszFilename );
int iFile = CSLFindString( papszSiblingFiles,
CPLFormFilename( NULL, osName, "rsc" ) );
if( iFile >= 0 )
{
osRscFilename = CPLFormFilename( osPath,
papszSiblingFiles[iFile],
NULL );
}
}
return osRscFilename;
}
int OGRCSVDataSource::Open( const char * pszFilename, int bUpdateIn,
int bForceOpen, char** papszOpenOptions )
{
pszName = CPLStrdup( pszFilename );
bUpdate = bUpdateIn;
if (bUpdateIn && bForceOpen && EQUAL(pszFilename, "/vsistdout/"))
return TRUE;
/* For writable /vsizip/, do nothing more */
if (bUpdateIn && bForceOpen && strncmp(pszFilename, "/vsizip/", 8) == 0)
return TRUE;
CPLString osFilename(pszFilename);
CPLString osBaseFilename = CPLGetFilename(pszFilename);
CPLString osExt = GetRealExtension(osFilename);
pszFilename = NULL;
int bIgnoreExtension = EQUALN(osFilename, "CSV:", 4);
int bUSGeonamesFile = FALSE;
/* int bGeonamesOrgFile = FALSE; */
if (bIgnoreExtension)
{
osFilename = osFilename + 4;
}
/* Those are *not* real .XLS files, but text file with tab as column separator */
if (EQUAL(osBaseFilename, "NfdcFacilities.xls") ||
EQUAL(osBaseFilename, "NfdcRunways.xls") ||
EQUAL(osBaseFilename, "NfdcRemarks.xls") ||
EQUAL(osBaseFilename, "NfdcSchedules.xls"))
{
if (bUpdateIn)
return FALSE;
bIgnoreExtension = TRUE;
}
else if ((EQUALN(osBaseFilename, "NationalFile_", 13) ||
EQUALN(osBaseFilename, "POP_PLACES_", 11) ||
EQUALN(osBaseFilename, "HIST_FEATURES_", 14) ||
EQUALN(osBaseFilename, "US_CONCISE_", 11) ||
EQUALN(osBaseFilename, "AllNames_", 9) ||
EQUALN(osBaseFilename, "Feature_Description_History_", 28) ||
EQUALN(osBaseFilename, "ANTARCTICA_", 11) ||
EQUALN(osBaseFilename, "GOVT_UNITS_", 11) ||
EQUALN(osBaseFilename, "NationalFedCodes_", 17) ||
EQUALN(osBaseFilename, "AllStates_", 10) ||
EQUALN(osBaseFilename, "AllStatesFedCodes_", 18) ||
(strlen(osBaseFilename) > 2 && EQUALN(osBaseFilename+2, "_Features_", 10)) ||
(strlen(osBaseFilename) > 2 && EQUALN(osBaseFilename+2, "_FedCodes_", 10))) &&
(EQUAL(osExt, "txt") || EQUAL(osExt, "zip")) )
{
if (bUpdateIn)
return FALSE;
bIgnoreExtension = TRUE;
bUSGeonamesFile = TRUE;
if (EQUAL(osExt, "zip") &&
strstr(osFilename, "/vsizip/") == NULL )
{
osFilename = "/vsizip/" + osFilename;
}
}
else if (EQUAL(osBaseFilename, "allCountries.txt") ||
EQUAL(osBaseFilename, "allCountries.zip"))
{
if (bUpdateIn)
return FALSE;
bIgnoreExtension = TRUE;
/* bGeonamesOrgFile = TRUE; */
if (EQUAL(osExt, "zip") &&
strstr(osFilename, "/vsizip/") == NULL )
{
osFilename = "/vsizip/" + osFilename;
}
}
/* -------------------------------------------------------------------- */
/* Determine what sort of object this is. */
/* -------------------------------------------------------------------- */
VSIStatBufL sStatBuf;
if( VSIStatExL( osFilename, &sStatBuf, VSI_STAT_NATURE_FLAG ) != 0 )
return FALSE;
/* -------------------------------------------------------------------- */
/* Is this a single CSV file? */
/* -------------------------------------------------------------------- */
if( VSI_ISREG(sStatBuf.st_mode)
&& (bIgnoreExtension || EQUAL(osExt,"csv") || EQUAL(osExt,"tsv")) )
{
if (EQUAL(CPLGetFilename(osFilename), "NfdcFacilities.xls"))
{
return OpenTable( osFilename, papszOpenOptions, "ARP");
}
else if (EQUAL(CPLGetFilename(osFilename), "NfdcRunways.xls"))
{
OpenTable( osFilename, papszOpenOptions, "BaseEndPhysical");
OpenTable( osFilename, papszOpenOptions, "BaseEndDisplaced");
OpenTable( osFilename, papszOpenOptions, "ReciprocalEndPhysical");
OpenTable( osFilename, papszOpenOptions, "ReciprocalEndDisplaced");
return nLayers != 0;
}
else if (bUSGeonamesFile)
{
/* GNIS specific */
if (EQUALN(osBaseFilename, "NationalFedCodes_", 17) ||
EQUALN(osBaseFilename, "AllStatesFedCodes_", 18) ||
EQUALN(osBaseFilename, "ANTARCTICA_", 11) ||
(strlen(osBaseFilename) > 2 && EQUALN(osBaseFilename+2, "_FedCodes_", 10)))
{
OpenTable( osFilename, papszOpenOptions, NULL, "PRIMARY");
}
else if (EQUALN(osBaseFilename, "GOVT_UNITS_", 11) ||
EQUALN(osBaseFilename, "Feature_Description_History_", 28))
{
OpenTable( osFilename, papszOpenOptions, NULL, "");
}
else
{
OpenTable( osFilename, papszOpenOptions, NULL, "PRIM");
OpenTable( osFilename, papszOpenOptions, NULL, "SOURCE");
}
return nLayers != 0;
}
return OpenTable( osFilename, papszOpenOptions );
}
/* -------------------------------------------------------------------- */
/* Is this a single a ZIP file with only a CSV file inside ? */
/* -------------------------------------------------------------------- */
if( strncmp(osFilename, "/vsizip/", 8) == 0 &&
EQUAL(osExt, "zip") &&
VSI_ISREG(sStatBuf.st_mode) )
{
char** papszFiles = VSIReadDir(osFilename);
if (CSLCount(papszFiles) != 1 ||
!EQUAL(CPLGetExtension(papszFiles[0]), "CSV"))
{
CSLDestroy(papszFiles);
return FALSE;
}
osFilename = CPLFormFilename(osFilename, papszFiles[0], NULL);
CSLDestroy(papszFiles);
return OpenTable( osFilename, papszOpenOptions );
}
/* -------------------------------------------------------------------- */
/* Otherwise it has to be a directory. */
/* -------------------------------------------------------------------- */
if( !VSI_ISDIR(sStatBuf.st_mode) )
return FALSE;
/* -------------------------------------------------------------------- */
/* Scan through for entries ending in .csv. */
/* -------------------------------------------------------------------- */
int nNotCSVCount = 0, i;
char **papszNames = CPLReadDir( osFilename );
for( i = 0; papszNames != NULL && papszNames[i] != NULL; i++ )
{
CPLString oSubFilename =
CPLFormFilename( osFilename, papszNames[i], NULL );
if( EQUAL(papszNames[i],".") || EQUAL(papszNames[i],"..") )
continue;
if (EQUAL(CPLGetExtension(oSubFilename),"csvt"))
continue;
if( VSIStatL( oSubFilename, &sStatBuf ) != 0
|| !VSI_ISREG(sStatBuf.st_mode) )
{
nNotCSVCount++;
continue;
}
if (EQUAL(CPLGetExtension(oSubFilename),"csv"))
{
if( !OpenTable( oSubFilename, papszOpenOptions ) )
{
CPLDebug("CSV", "Cannot open %s", oSubFilename.c_str());
nNotCSVCount++;
continue;
}
}
/* GNIS specific */
else if ( strlen(papszNames[i]) > 2 &&
EQUALN(papszNames[i]+2, "_Features_", 10) &&
EQUAL(CPLGetExtension(papszNames[i]), "txt") )
{
int bRet = OpenTable( oSubFilename, papszOpenOptions, NULL, "PRIM");
bRet |= OpenTable( oSubFilename, papszOpenOptions, NULL, "SOURCE");
if ( !bRet )
{
CPLDebug("CSV", "Cannot open %s", oSubFilename.c_str());
nNotCSVCount++;
continue;
}
}
/* GNIS specific */
else if ( strlen(papszNames[i]) > 2 &&
EQUALN(papszNames[i]+2, "_FedCodes_", 10) &&
EQUAL(CPLGetExtension(papszNames[i]), "txt") )
{
if ( !OpenTable( oSubFilename, papszOpenOptions, NULL, "PRIMARY") )
{
CPLDebug("CSV", "Cannot open %s", oSubFilename.c_str());
nNotCSVCount++;
continue;
}
}
else
{
nNotCSVCount++;
continue;
}
}
CSLDestroy( papszNames );
/* -------------------------------------------------------------------- */
/* We presume that this is indeed intended to be a CSV */
/* datasource if over half the files were .csv files. */
/* -------------------------------------------------------------------- */
return bForceOpen || nNotCSVCount < nLayers;
}
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 OGRSelafinDataSource::Open(const char * pszFilename, int bUpdateIn, int bCreate) {
// Check if a range is set and extract it and the filename
const char *pszc=pszFilename;
if (*pszFilename==0) return FALSE;
while (*pszc) ++pszc;
if (*(pszc-1)==']') {
--pszc;
while (pszc!=pszFilename && *pszc!='[') pszc--;
if (pszc==pszFilename) return FALSE;
poRange.setRange(pszc);
}
pszName = CPLStrdup( pszFilename );
pszName[pszc-pszFilename]=0;
bUpdate = bUpdateIn;
if (bCreate && EQUAL(pszName, "/vsistdout/")) return TRUE;
/* For writable /vsizip/, do nothing more */
if (bCreate && STARTS_WITH(pszName, "/vsizip/")) return TRUE;
CPLString osFilename(pszName);
CPLString osBaseFilename = CPLGetFilename(pszName);
// Determine what sort of object this is.
VSIStatBufL sStatBuf;
if (VSIStatExL( osFilename, &sStatBuf, VSI_STAT_NATURE_FLAG ) != 0) return FALSE;
// Is this a single Selafin file?
if (VSI_ISREG(sStatBuf.st_mode)) return OpenTable( pszName );
// Is this a single a ZIP file with only a Selafin file inside ?
if( STARTS_WITH(osFilename, "/vsizip/") && VSI_ISREG(sStatBuf.st_mode) ) {
char** papszFiles = VSIReadDir(osFilename);
if (CSLCount(papszFiles) != 1) {
CSLDestroy(papszFiles);
return FALSE;
}
osFilename = CPLFormFilename(osFilename, papszFiles[0], NULL);
CSLDestroy(papszFiles);
return OpenTable( osFilename );
}
#ifdef notdef
// Otherwise it has to be a directory.
if( !VSI_ISDIR(sStatBuf.st_mode) ) return FALSE;
// Scan through for entries which look like Selafin files
int nNotSelafinCount = 0, i;
char **papszNames = VSIReadDir( osFilename );
for( i = 0; papszNames != NULL && papszNames[i] != NULL; i++ ) {
CPLString oSubFilename = CPLFormFilename( osFilename, papszNames[i], NULL );
if( EQUAL(papszNames[i],".") || EQUAL(papszNames[i],"..") ) continue;
if( VSIStatL( oSubFilename, &sStatBuf ) != 0 || !VSI_ISREG(sStatBuf.st_mode) ) {
nNotSelafinCount++;
continue;
}
if( !OpenTable( oSubFilename ) ) {
CPLDebug("Selafin", "Cannot open %s", oSubFilename.c_str());
nNotSelafinCount++;
continue;
}
}
CSLDestroy( papszNames );
// We presume that this is indeed intended to be a Selafin datasource if over half the files were Selafin files.
return nNotSelafinCount < nLayers;
#else
return FALSE;
#endif
}
GDALDataset *DTEDDataset::Open( GDALOpenInfo * poOpenInfo )
{
int i;
DTEDInfo *psDTED;
if (!Identify(poOpenInfo) || poOpenInfo->fpL == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Try opening the dataset. */
/* -------------------------------------------------------------------- */
VSILFILE* fp = poOpenInfo->fpL;
poOpenInfo->fpL = NULL;
psDTED = DTEDOpenEx( fp, poOpenInfo->pszFilename,
(poOpenInfo->eAccess == GA_Update) ? "rb+" : "rb", TRUE );
if( psDTED == NULL )
return( NULL );
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
DTEDDataset *poDS;
poDS = new DTEDDataset();
poDS->SetFileName(poOpenInfo->pszFilename);
poDS->eAccess = poOpenInfo->eAccess;
poDS->psDTED = psDTED;
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = psDTED->nXSize;
poDS->nRasterYSize = psDTED->nYSize;
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize))
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->nBands = 1;
for( i = 0; i < poDS->nBands; i++ )
poDS->SetBand( i+1, new DTEDRasterBand( poDS, i+1 ) );
/* -------------------------------------------------------------------- */
/* Collect any metadata available. */
/* -------------------------------------------------------------------- */
char *pszValue;
pszValue = DTEDGetMetadata( psDTED, DTEDMD_VERTACCURACY_UHL );
poDS->SetMetadataItem( "DTED_VerticalAccuracy_UHL", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_VERTACCURACY_ACC );
poDS->SetMetadataItem( "DTED_VerticalAccuracy_ACC", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_SECURITYCODE_UHL );
poDS->SetMetadataItem( "DTED_SecurityCode_UHL", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_SECURITYCODE_DSI );
poDS->SetMetadataItem( "DTED_SecurityCode_DSI", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_UNIQUEREF_UHL );
poDS->SetMetadataItem( "DTED_UniqueRef_UHL", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_UNIQUEREF_DSI );
poDS->SetMetadataItem( "DTED_UniqueRef_DSI", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_DATA_EDITION );
poDS->SetMetadataItem( "DTED_DataEdition", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_MATCHMERGE_VERSION );
poDS->SetMetadataItem( "DTED_MatchMergeVersion", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_MAINT_DATE );
poDS->SetMetadataItem( "DTED_MaintenanceDate", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_MATCHMERGE_DATE );
poDS->SetMetadataItem( "DTED_MatchMergeDate", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_MAINT_DESCRIPTION );
poDS->SetMetadataItem( "DTED_MaintenanceDescription", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_PRODUCER );
poDS->SetMetadataItem( "DTED_Producer", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_VERTDATUM );
poDS->SetMetadataItem( "DTED_VerticalDatum", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_HORIZDATUM );
poDS->SetMetadataItem( "DTED_HorizontalDatum", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_DIGITIZING_SYS );
poDS->SetMetadataItem( "DTED_DigitizingSystem", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_COMPILATION_DATE );
poDS->SetMetadataItem( "DTED_CompilationDate", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_HORIZACCURACY );
poDS->SetMetadataItem( "DTED_HorizontalAccuracy", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_REL_HORIZACCURACY );
poDS->SetMetadataItem( "DTED_RelHorizontalAccuracy", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_REL_VERTACCURACY );
poDS->SetMetadataItem( "DTED_RelVerticalAccuracy", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_ORIGINLAT );
poDS->SetMetadataItem( "DTED_OriginLatitude", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_ORIGINLONG );
poDS->SetMetadataItem( "DTED_OriginLongitude", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_NIMA_DESIGNATOR );
poDS->SetMetadataItem( "DTED_NimaDesignator", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_PARTIALCELL_DSI );
poDS->SetMetadataItem( "DTED_PartialCellIndicator", pszValue );
CPLFree( pszValue );
poDS->SetMetadataItem( GDALMD_AREA_OR_POINT, GDALMD_AOP_POINT );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML( poOpenInfo->GetSiblingFiles() );
// if no SR in xml, try aux
const char* pszPrj = poDS->GDALPamDataset::GetProjectionRef();
if( !pszPrj || strlen(pszPrj) == 0 )
{
int bTryAux = TRUE;
if( poOpenInfo->GetSiblingFiles() != NULL &&
CSLFindString(poOpenInfo->GetSiblingFiles(), CPLResetExtension(CPLGetFilename(poOpenInfo->pszFilename), "aux")) < 0 &&
CSLFindString(poOpenInfo->GetSiblingFiles(), CPLSPrintf("%s.aux", CPLGetFilename(poOpenInfo->pszFilename))) < 0 )
bTryAux = FALSE;
if( bTryAux )
{
GDALDataset* poAuxDS = GDALFindAssociatedAuxFile( poOpenInfo->pszFilename, GA_ReadOnly, poDS );
if( poAuxDS )
{
pszPrj = poAuxDS->GetProjectionRef();
if( pszPrj && strlen(pszPrj) > 0 )
{
CPLFree( poDS->pszProjection );
poDS->pszProjection = CPLStrdup(pszPrj);
}
GDALClose( poAuxDS );
}
}
}
/* -------------------------------------------------------------------- */
/* Support overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename,
poOpenInfo->GetSiblingFiles() );
return( poDS );
}
CPLErr HFAAuxBuildOverviews( const char *pszOvrFilename,
GDALDataset *poParentDS,
GDALDataset **ppoODS,
int nBands, int *panBandList,
int nNewOverviews, int *panNewOverviewList,
const char *pszResampling,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
/* ==================================================================== */
/* If the .aux file doesn't exist yet then create it now. */
/* ==================================================================== */
if( *ppoODS == NULL )
{
GDALDataType eDT = GDT_Unknown;
/* -------------------------------------------------------------------- */
/* Determine the band datatype, and verify that all bands are */
/* the same. */
/* -------------------------------------------------------------------- */
int iBand;
for( iBand = 0; iBand < nBands; iBand++ )
{
GDALRasterBand *poBand =
poParentDS->GetRasterBand( panBandList[iBand] );
if( iBand == 0 )
eDT = poBand->GetRasterDataType();
else
{
if( eDT != poBand->GetRasterDataType() )
{
CPLError( CE_Failure, CPLE_NotSupported,
"HFAAuxBuildOverviews() doesn't support a mixture of band"
" data types." );
return CE_Failure;
}
}
}
/* -------------------------------------------------------------------- */
/* Create the HFA (.aux) file. We create it with */
/* COMPRESSED=YES so that no space will be allocated for the */
/* base band. */
/* -------------------------------------------------------------------- */
GDALDriver *poHFADriver = (GDALDriver *) GDALGetDriverByName("HFA");
if (poHFADriver == NULL)
{
CPLError( CE_Failure, CPLE_AppDefined,
"HFA driver is unavailable." );
return CE_Failure;
}
const char *apszOptions[4] = { "COMPRESSED=YES", "AUX=YES",
NULL, NULL };
CPLString osDepFileOpt = "DEPENDENT_FILE=";
osDepFileOpt += CPLGetFilename(poParentDS->GetDescription());
apszOptions[2] = osDepFileOpt.c_str();
*ppoODS =
poHFADriver->Create( pszOvrFilename,
poParentDS->GetRasterXSize(),
poParentDS->GetRasterYSize(),
poParentDS->GetRasterCount(), eDT, (char **)apszOptions );
if( *ppoODS == NULL )
return CE_Failure;
}
/* ==================================================================== */
/* Create the layers. We depend on the normal buildoverviews */
/* support for HFA to do this. But we disable the internal */
/* computation of the imagery for these layers. */
/* */
/* We avoid regenerating the new layers here, because if we did */
/* it would use the base layer from the .aux file as the source */
/* data, and that is fake (all invalid tiles). */
/* ==================================================================== */
CPLString oAdjustedResampling = "NO_REGEN:";
oAdjustedResampling += pszResampling;
CPLErr eErr =
(*ppoODS)->BuildOverviews( oAdjustedResampling,
nNewOverviews, panNewOverviewList,
nBands, panBandList,
pfnProgress, pProgressData );
return eErr;
}
void GDALPamProxyDB::SaveDB()
{
/* -------------------------------------------------------------------- */
/* Open the database relating original names to proxy .aux.xml */
/* file names. */
/* -------------------------------------------------------------------- */
CPLString osDBName =
CPLFormFilename( osProxyDBDir, "gdal_pam_proxy", "dat" );
void *hLock = CPLLockFile( osDBName, 1.0 );
// proceed even if lock fails - we need CPLBreakLockFile()!
if( hLock == NULL )
{
CPLError( CE_Warning, CPLE_AppDefined,
"GDALPamProxyDB::SaveDB() - Failed to lock %s file, proceeding anyways.",
osDBName.c_str() );
}
FILE *fpDB = VSIFOpenL( osDBName, "w" );
if( fpDB == NULL )
{
if( hLock )
CPLUnlockFile( hLock );
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to save %s Pam Proxy DB.\n%s",
osDBName.c_str(),
VSIStrerror( errno ) );
return;
}
/* -------------------------------------------------------------------- */
/* Write header. */
/* -------------------------------------------------------------------- */
GByte abyHeader[100];
memset( abyHeader, ' ', sizeof(abyHeader) );
strncpy( (char *) abyHeader, "GDAL_PROXY", 10 );
sprintf( (char *) abyHeader + 10, "%9d", nUpdateCounter );
VSIFWriteL( abyHeader, 1, 100, fpDB );
/* -------------------------------------------------------------------- */
/* Write names. */
/* -------------------------------------------------------------------- */
unsigned int i;
for( i = 0; i < aosOriginalFiles.size(); i++ )
{
size_t nBytesWritten;
const char *pszProxyFile;
VSIFWriteL( aosOriginalFiles[i].c_str(), 1,
strlen(aosOriginalFiles[i].c_str())+1, fpDB );
pszProxyFile = CPLGetFilename(aosProxyFiles[i]);
nBytesWritten = VSIFWriteL( pszProxyFile, 1,
strlen(pszProxyFile)+1, fpDB );
if( nBytesWritten != strlen(pszProxyFile)+1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to write complete %s Pam Proxy DB.\n%s",
osDBName.c_str(),
VSIStrerror( errno ) );
VSIFCloseL( fpDB );
VSIUnlink( osDBName );
return;
}
}
VSIFCloseL( fpDB );
if( hLock )
CPLUnlockFile( hLock );
}
GDALDataset *TSXDataset::Open( GDALOpenInfo *poOpenInfo ) {
/* -------------------------------------------------------------------- */
/* Is this a TerraSAR-X product file? */
/* -------------------------------------------------------------------- */
if (!TSXDataset::Identify( poOpenInfo ))
{
return NULL; /* nope */
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The TSX driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
CPLString osFilename;
if( poOpenInfo->bIsDirectory )
{
osFilename =
CPLFormCIFilename( poOpenInfo->pszFilename,
CPLGetFilename( poOpenInfo->pszFilename ),
"xml" );
}
else
osFilename = poOpenInfo->pszFilename;
/* Ingest the XML */
CPLXMLNode *psData = CPLParseXMLFile( osFilename );
if (psData == NULL)
return NULL;
/* find the product components */
CPLXMLNode *psComponents
= CPLGetXMLNode( psData, "=level1Product.productComponents" );
if (psComponents == NULL) {
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to find <productComponents> tag in file.\n" );
CPLDestroyXMLNode(psData);
return NULL;
}
/* find the product info tag */
CPLXMLNode *psProductInfo
= CPLGetXMLNode( psData, "=level1Product.productInfo" );
if (psProductInfo == NULL) {
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to find <productInfo> tag in file.\n" );
CPLDestroyXMLNode(psData);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
TSXDataset *poDS = new TSXDataset();
/* -------------------------------------------------------------------- */
/* Read in product info. */
/* -------------------------------------------------------------------- */
poDS->SetMetadataItem( "SCENE_CENTRE_TIME", CPLGetXMLValue( psProductInfo,
"sceneInfo.sceneCenterCoord.azimuthTimeUTC", "unknown" ) );
poDS->SetMetadataItem( "OPERATIONAL_MODE", CPLGetXMLValue( psProductInfo,
"generationInfo.groundOperationsType", "unknown" ) );
poDS->SetMetadataItem( "ORBIT_CYCLE", CPLGetXMLValue( psProductInfo,
"missionInfo.orbitCycle", "unknown" ) );
poDS->SetMetadataItem( "ABSOLUTE_ORBIT", CPLGetXMLValue( psProductInfo,
"missionInfo.absOrbit", "unknown" ) );
poDS->SetMetadataItem( "ORBIT_DIRECTION", CPLGetXMLValue( psProductInfo,
"missionInfo.orbitDirection", "unknown" ) );
poDS->SetMetadataItem( "IMAGING_MODE", CPLGetXMLValue( psProductInfo,
"acquisitionInfo.imagingMode", "unknown" ) );
poDS->SetMetadataItem( "PRODUCT_VARIANT", CPLGetXMLValue( psProductInfo,
"productVariantInfo.productVariant", "unknown" ) );
char *pszDataType = CPLStrdup( CPLGetXMLValue( psProductInfo,
"imageDataInfo.imageDataType", "unknown" ) );
poDS->SetMetadataItem( "IMAGE_TYPE", pszDataType );
/* Get raster information */
int nRows = atoi( CPLGetXMLValue( psProductInfo,
"imageDataInfo.imageRaster.numberOfRows", "" ) );
int nCols = atoi( CPLGetXMLValue( psProductInfo,
"imageDataInfo.imageRaster.numberOfColumns", "" ) );
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
poDS->SetMetadataItem( "ROW_SPACING", CPLGetXMLValue( psProductInfo,
"imageDataInfo.imageRaster.rowSpacing", "unknown" ) );
poDS->SetMetadataItem( "COL_SPACING", CPLGetXMLValue( psProductInfo,
"imageDataInfo.imageRaster.columnSpacing", "unknown" ) );
poDS->SetMetadataItem( "COL_SPACING_UNITS", CPLGetXMLValue( psProductInfo,
"imageDataInfo.imageRaster.columnSpacing.units", "unknown" ) );
/* Get equivalent number of looks */
poDS->SetMetadataItem( "AZIMUTH_LOOKS", CPLGetXMLValue( psProductInfo,
"imageDataInfo.imageRaster.azimuthLooks", "unknown" ) );
poDS->SetMetadataItem( "RANGE_LOOKS", CPLGetXMLValue( psProductInfo,
"imageDataInfo.imageRaster.rangeLooks", "unknown" ) );
const char *pszProductVariant = CPLGetXMLValue( psProductInfo,
"productVariantInfo.productVariant", "unknown" );
poDS->SetMetadataItem( "PRODUCT_VARIANT", pszProductVariant );
/* Determine what product variant this is */
if (STARTS_WITH_CI(pszProductVariant, "SSC"))
poDS->nProduct = eSSC;
else if (STARTS_WITH_CI(pszProductVariant, "MGD"))
poDS->nProduct = eMGD;
else if (STARTS_WITH_CI(pszProductVariant, "EEC"))
poDS->nProduct = eEEC;
else if (STARTS_WITH_CI(pszProductVariant, "GEC"))
poDS->nProduct = eGEC;
else
poDS->nProduct = eUnknown;
/* Start reading in the product components */
char *pszGeorefFile = NULL;
CPLErr geoTransformErr=CE_Failure;
for ( CPLXMLNode *psComponent = psComponents->psChild;
psComponent != NULL;
psComponent = psComponent->psNext)
{
const char *pszType = NULL;
const char *pszPath = CPLFormFilename(
CPLGetDirname( osFilename ),
GetFilePath(psComponent, &pszType),
"" );
const char *pszPolLayer = CPLGetXMLValue(psComponent, "polLayer", " ");
if ( !STARTS_WITH_CI(pszType, " ") ) {
if (STARTS_WITH_CI(pszType, "MAPPING_GRID") ) {
/* the mapping grid... save as a metadata item this path */
poDS->SetMetadataItem( "MAPPING_GRID", pszPath );
}
else if (STARTS_WITH_CI(pszType, "GEOREF")) {
/* save the path to the georef data for later use */
CPLFree( pszGeorefFile );
pszGeorefFile = CPLStrdup( pszPath );
}
}
else if( !STARTS_WITH_CI(pszPolLayer, " ") &&
STARTS_WITH_CI(psComponent->pszValue, "imageData") ) {
/* determine the polarization of this band */
ePolarization ePol;
if ( STARTS_WITH_CI(pszPolLayer, "HH") ) {
ePol = HH;
}
else if ( STARTS_WITH_CI(pszPolLayer, "HV") ) {
ePol = HV;
}
else if ( STARTS_WITH_CI(pszPolLayer, "VH") ) {
ePol = VH;
}
else {
ePol = VV;
}
GDALDataType eDataType = STARTS_WITH_CI(pszDataType, "COMPLEX") ?
GDT_CInt16 : GDT_UInt16;
/* try opening the file that represents that band */
GDALDataset *poBandData = reinterpret_cast<GDALDataset *>(
GDALOpen( pszPath, GA_ReadOnly ) );
if ( poBandData != NULL ) {
TSXRasterBand *poBand
= new TSXRasterBand( poDS, eDataType, ePol, poBandData );
poDS->SetBand( poDS->GetRasterCount() + 1, poBand );
//copy georeferencing info from the band
//need error checking??
//it will just save the info from the last band
CPLFree( poDS->pszProjection );
poDS->pszProjection = CPLStrdup(poBandData->GetProjectionRef());
geoTransformErr = poBandData->GetGeoTransform(poDS->adfGeoTransform);
}
}
}
//now check if there is a geotransform
if ( strcmp(poDS->pszProjection, "") && geoTransformErr==CE_None)
{
poDS->bHaveGeoTransform = TRUE;
}
else
{
poDS->bHaveGeoTransform = FALSE;
CPLFree( poDS->pszProjection );
poDS->pszProjection = CPLStrdup("");
poDS->adfGeoTransform[0] = 0.0;
poDS->adfGeoTransform[1] = 1.0;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = 0.0;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = 1.0;
}
CPLFree(pszDataType);
/* -------------------------------------------------------------------- */
/* Check and set matrix representation. */
/* -------------------------------------------------------------------- */
if (poDS->GetRasterCount() == 4) {
poDS->SetMetadataItem( "MATRIX_REPRESENTATION", "SCATTERING" );
}
/* -------------------------------------------------------------------- */
/* Read the four corners and centre GCPs in */
/* -------------------------------------------------------------------- */
CPLXMLNode *psSceneInfo = CPLGetXMLNode( psData,
"=level1Product.productInfo.sceneInfo" );
if (psSceneInfo != NULL)
{
/* extract the GCPs from the provided file */
bool success = false;
if (pszGeorefFile != NULL)
success = poDS->getGCPsFromGEOREF_XML(pszGeorefFile);
//if the gcp's cannot be extracted from the georef file, try to get the corner coordinates
//for now just SSC because the others don't have refColumn and refRow
if (!success && poDS->nProduct == eSSC)
{
int nGCP = 0;
double dfAvgHeight = CPLAtof(CPLGetXMLValue(psSceneInfo,
"sceneAverageHeight", "0.0"));
//count and allocate gcps - there should be five - 4 corners and a centre
poDS->nGCPCount = 0;
CPLXMLNode *psNode = psSceneInfo->psChild;
for ( ; psNode != NULL; psNode = psNode->psNext )
{
if (!EQUAL(psNode->pszValue, "sceneCenterCoord") &&
!EQUAL(psNode->pszValue, "sceneCornerCoord"))
continue;
poDS->nGCPCount++;
}
if (poDS->nGCPCount > 0)
{
poDS->pasGCPList = (GDAL_GCP *)CPLCalloc(sizeof(GDAL_GCP), poDS->nGCPCount);
/* iterate over GCPs */
for (psNode = psSceneInfo->psChild; psNode != NULL; psNode = psNode->psNext )
{
GDAL_GCP *psGCP = poDS->pasGCPList + nGCP;
if (!EQUAL(psNode->pszValue, "sceneCenterCoord") &&
!EQUAL(psNode->pszValue, "sceneCornerCoord"))
continue;
psGCP->dfGCPPixel = CPLAtof(CPLGetXMLValue(psNode, "refColumn",
"0.0"));
psGCP->dfGCPLine = CPLAtof(CPLGetXMLValue(psNode, "refRow", "0.0"));
psGCP->dfGCPX = CPLAtof(CPLGetXMLValue(psNode, "lon", "0.0"));
psGCP->dfGCPY = CPLAtof(CPLGetXMLValue(psNode, "lat", "0.0"));
psGCP->dfGCPZ = dfAvgHeight;
psGCP->pszId = CPLStrdup( CPLSPrintf( "%d", nGCP ) );
psGCP->pszInfo = CPLStrdup("");
nGCP++;
}
//set the projection string - the fields are lat/long - seems to be WGS84 datum
OGRSpatialReference osr;
osr.SetWellKnownGeogCS( "WGS84" );
CPLFree(poDS->pszGCPProjection);
osr.exportToWkt( &(poDS->pszGCPProjection) );
}
}
//gcps override geotransform - does it make sense to have both??
if (poDS->nGCPCount>0)
{
poDS->bHaveGeoTransform = FALSE;
CPLFree( poDS->pszProjection );
poDS->pszProjection = CPLStrdup("");
poDS->adfGeoTransform[0] = 0.0;
poDS->adfGeoTransform[1] = 1.0;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = 0.0;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = 1.0;
}
}
else {
CPLError(CE_Warning, CPLE_AppDefined,
"Unable to find sceneInfo tag in XML document. "
"Proceeding with caution.");
}
CPLFree(pszGeorefFile);
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
CPLDestroyXMLNode(psData);
return poDS;
}
GDALDataset *ERSDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* We assume the user selects the .ers file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes > 15
&& EQUALN((const char *) poOpenInfo->pabyHeader,"Algorithm Begin",15) )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"%s appears to be an algorithm ERS file, which is not currently supported.",
poOpenInfo->pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* We assume the user selects the .ers file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 15
|| !EQUALN((const char *) poOpenInfo->pabyHeader,"DatasetHeader ",14) )
return NULL;
/* -------------------------------------------------------------------- */
/* Open the .ers file, and read the first line. */
/* -------------------------------------------------------------------- */
VSILFILE *fpERS = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( fpERS == NULL )
return NULL;
CPLReadLineL( fpERS );
/* -------------------------------------------------------------------- */
/* Now ingest the rest of the file as a tree of header nodes. */
/* -------------------------------------------------------------------- */
ERSHdrNode *poHeader = new ERSHdrNode();
if( !poHeader->ParseChildren( fpERS ) )
{
delete poHeader;
VSIFCloseL( fpERS );
return NULL;
}
VSIFCloseL( fpERS );
/* -------------------------------------------------------------------- */
/* Do we have the minimum required information from this header? */
/* -------------------------------------------------------------------- */
if( poHeader->Find( "RasterInfo.NrOfLines" ) == NULL
|| poHeader->Find( "RasterInfo.NrOfCellsPerLine" ) == NULL
|| poHeader->Find( "RasterInfo.NrOfBands" ) == NULL )
{
if( poHeader->FindNode( "Algorithm" ) != NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"%s appears to be an algorithm ERS file, which is not currently supported.",
poOpenInfo->pszFilename );
}
delete poHeader;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
ERSDataset *poDS;
poDS = new ERSDataset();
poDS->poHeader = poHeader;
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
int nBands = atoi(poHeader->Find( "RasterInfo.NrOfBands" ));
poDS->nRasterXSize = atoi(poHeader->Find( "RasterInfo.NrOfCellsPerLine" ));
poDS->nRasterYSize = atoi(poHeader->Find( "RasterInfo.NrOfLines" ));
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) ||
!GDALCheckBandCount(nBands, FALSE))
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Get the HeaderOffset if it exists in the header */
/* -------------------------------------------------------------------- */
GIntBig nHeaderOffset = 0;
if( poHeader->Find( "HeaderOffset" ) != NULL )
{
nHeaderOffset = atoi(poHeader->Find( "HeaderOffset" ));
}
/* -------------------------------------------------------------------- */
/* Establish the data type. */
/* -------------------------------------------------------------------- */
GDALDataType eType;
CPLString osCellType = poHeader->Find( "RasterInfo.CellType",
"Unsigned8BitInteger" );
if( EQUAL(osCellType,"Unsigned8BitInteger") )
eType = GDT_Byte;
else if( EQUAL(osCellType,"Signed8BitInteger") )
eType = GDT_Byte;
else if( EQUAL(osCellType,"Unsigned16BitInteger") )
eType = GDT_UInt16;
else if( EQUAL(osCellType,"Signed16BitInteger") )
eType = GDT_Int16;
else if( EQUAL(osCellType,"Unsigned32BitInteger") )
eType = GDT_UInt32;
else if( EQUAL(osCellType,"Signed32BitInteger") )
eType = GDT_Int32;
else if( EQUAL(osCellType,"IEEE4ByteReal") )
eType = GDT_Float32;
else if( EQUAL(osCellType,"IEEE8ByteReal") )
eType = GDT_Float64;
else
{
CPLDebug( "ERS", "Unknown CellType '%s'", osCellType.c_str() );
eType = GDT_Byte;
}
/* -------------------------------------------------------------------- */
/* Pick up the word order. */
/* -------------------------------------------------------------------- */
int bNative;
#ifdef CPL_LSB
bNative = EQUAL(poHeader->Find( "ByteOrder", "LSBFirst" ),
"LSBFirst");
#else
bNative = EQUAL(poHeader->Find( "ByteOrder", "MSBFirst" ),
"MSBFirst");
#endif
/* -------------------------------------------------------------------- */
/* Figure out the name of the target file. */
/* -------------------------------------------------------------------- */
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
CPLString osDataFile = poHeader->Find( "DataFile", "" );
CPLString osDataFilePath;
if( osDataFile.length() == 0 ) // just strip off extension.
{
osDataFile = CPLGetFilename( poOpenInfo->pszFilename );
osDataFile = osDataFile.substr( 0, osDataFile.find_last_of('.') );
}
osDataFilePath = CPLFormFilename( osPath, osDataFile, NULL );
/* -------------------------------------------------------------------- */
/* DataSetType = Translated files are links to things like ecw */
/* files. */
/* -------------------------------------------------------------------- */
if( EQUAL(poHeader->Find("DataSetType",""),"Translated") )
{
poDS->poDepFile = (GDALDataset *)
GDALOpenShared( osDataFilePath, poOpenInfo->eAccess );
if( poDS->poDepFile != NULL
&& poDS->poDepFile->GetRasterCount() >= nBands )
{
int iBand;
for( iBand = 0; iBand < nBands; iBand++ )
{
// Assume pixel interleaved.
poDS->SetBand( iBand+1,
poDS->poDepFile->GetRasterBand( iBand+1 ) );
}
}
}
/* ==================================================================== */
/* While ERStorage indicates a raw file. */
/* ==================================================================== */
else if( EQUAL(poHeader->Find("DataSetType",""),"ERStorage") )
{
// Open data file.
if( poOpenInfo->eAccess == GA_Update )
poDS->fpImage = VSIFOpenL( osDataFilePath, "r+" );
else
poDS->fpImage = VSIFOpenL( osDataFilePath, "r" );
poDS->osRawFilename = osDataFilePath;
if( poDS->fpImage != NULL )
{
int iWordSize = GDALGetDataTypeSize(eType) / 8;
int iBand;
for( iBand = 0; iBand < nBands; iBand++ )
{
// Assume pixel interleaved.
poDS->SetBand(
iBand+1,
new RawRasterBand( poDS, iBand+1, poDS->fpImage,
nHeaderOffset
+ iWordSize * iBand * poDS->nRasterXSize,
iWordSize,
iWordSize * nBands * poDS->nRasterXSize,
eType, bNative, TRUE ));
if( EQUAL(osCellType,"Signed8BitInteger") )
poDS->GetRasterBand(iBand+1)->
SetMetadataItem( "PIXELTYPE", "SIGNEDBYTE",
"IMAGE_STRUCTURE" );
}
}
}
/* -------------------------------------------------------------------- */
/* Otherwise we have an error! */
/* -------------------------------------------------------------------- */
if( poDS->nBands == 0 )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Look for band descriptions. */
/* -------------------------------------------------------------------- */
int iChild, iBand = 0;
ERSHdrNode *poRI = poHeader->FindNode( "RasterInfo" );
for( iChild = 0;
poRI != NULL && iChild < poRI->nItemCount && iBand < poDS->nBands;
iChild++ )
{
if( poRI->papoItemChild[iChild] != NULL
&& EQUAL(poRI->papszItemName[iChild],"BandId") )
{
const char *pszValue =
poRI->papoItemChild[iChild]->Find( "Value", NULL );
iBand++;
if( pszValue )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
poDS->GetRasterBand( iBand )->SetDescription( pszValue );
CPLPopErrorHandler();
}
pszValue = poRI->papoItemChild[iChild]->Find( "Units", NULL );
if ( pszValue )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
poDS->GetRasterBand( iBand )->SetUnitType( pszValue );
CPLPopErrorHandler();
}
}
}
/* -------------------------------------------------------------------- */
/* Look for projection. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
CPLString osProjection = poHeader->Find( "CoordinateSpace.Projection",
"RAW" );
CPLString osDatum = poHeader->Find( "CoordinateSpace.Datum", "WGS84" );
CPLString osUnits = poHeader->Find( "CoordinateSpace.Units", "METERS" );
oSRS.importFromERM( osProjection, osDatum, osUnits );
CPLFree( poDS->pszProjection );
oSRS.exportToWkt( &(poDS->pszProjection) );
/* -------------------------------------------------------------------- */
/* Look for the geotransform. */
/* -------------------------------------------------------------------- */
if( poHeader->Find( "RasterInfo.RegistrationCoord.Eastings", NULL )
&& poHeader->Find( "RasterInfo.CellInfo.Xdimension", NULL ) )
{
poDS->bGotTransform = TRUE;
poDS->adfGeoTransform[0] = CPLAtof(
poHeader->Find( "RasterInfo.RegistrationCoord.Eastings", "" ));
poDS->adfGeoTransform[1] = CPLAtof(
poHeader->Find( "RasterInfo.CellInfo.Xdimension", "" ));
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = CPLAtof(
poHeader->Find( "RasterInfo.RegistrationCoord.Northings", "" ));
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = -CPLAtof(
poHeader->Find( "RasterInfo.CellInfo.Ydimension", "" ));
}
else if( poHeader->Find( "RasterInfo.RegistrationCoord.Latitude", NULL )
&& poHeader->Find( "RasterInfo.CellInfo.Xdimension", NULL ) )
{
poDS->bGotTransform = TRUE;
poDS->adfGeoTransform[0] = ERSDMS2Dec(
poHeader->Find( "RasterInfo.RegistrationCoord.Longitude", "" ));
poDS->adfGeoTransform[1] = CPLAtof(
poHeader->Find( "RasterInfo.CellInfo.Xdimension", "" ));
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = ERSDMS2Dec(
poHeader->Find( "RasterInfo.RegistrationCoord.Latitude", "" ));
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = -CPLAtof(
poHeader->Find( "RasterInfo.CellInfo.Ydimension", "" ));
}
/* -------------------------------------------------------------------- */
/* Adjust if we have a registration cell. */
/* -------------------------------------------------------------------- */
int iCellX = atoi(poHeader->Find("RasterInfo.RegistrationCellX", "1"));
int iCellY = atoi(poHeader->Find("RasterInfo.RegistrationCellY", "1"));
if( poDS->bGotTransform )
{
poDS->adfGeoTransform[0] -=
(iCellX-1) * poDS->adfGeoTransform[1]
+ (iCellY-1) * poDS->adfGeoTransform[2];
poDS->adfGeoTransform[3] -=
(iCellX-1) * poDS->adfGeoTransform[4]
+ (iCellY-1) * poDS->adfGeoTransform[5];
}
/* -------------------------------------------------------------------- */
/* Check for null values. */
/* -------------------------------------------------------------------- */
if( poHeader->Find( "RasterInfo.NullCellValue", NULL ) )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
for( iBand = 1; iBand <= poDS->nBands; iBand++ )
poDS->GetRasterBand(iBand)->SetNoDataValue(
CPLAtofM(poHeader->Find( "RasterInfo.NullCellValue" )) );
CPLPopErrorHandler();
}
/* -------------------------------------------------------------------- */
/* Do we have an "All" region? */
/* -------------------------------------------------------------------- */
ERSHdrNode *poAll = NULL;
for( iChild = 0;
poRI != NULL && iChild < poRI->nItemCount;
iChild++ )
{
if( poRI->papoItemChild[iChild] != NULL
&& EQUAL(poRI->papszItemName[iChild],"RegionInfo") )
{
if( EQUAL(poRI->papoItemChild[iChild]->Find("RegionName",""),
"All") )
poAll = poRI->papoItemChild[iChild];
}
}
/* -------------------------------------------------------------------- */
/* Do we have statistics? */
/* -------------------------------------------------------------------- */
if( poAll && poAll->FindNode( "Stats" ) )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
for( iBand = 1; iBand <= poDS->nBands; iBand++ )
{
const char *pszValue =
poAll->FindElem( "Stats.MinimumValue", iBand-1 );
if( pszValue )
poDS->GetRasterBand(iBand)->SetMetadataItem(
"STATISTICS_MINIMUM", pszValue );
pszValue = poAll->FindElem( "Stats.MaximumValue", iBand-1 );
if( pszValue )
poDS->GetRasterBand(iBand)->SetMetadataItem(
"STATISTICS_MAXIMUM", pszValue );
pszValue = poAll->FindElem( "Stats.MeanValue", iBand-1 );
if( pszValue )
poDS->GetRasterBand(iBand)->SetMetadataItem(
"STATISTICS_MEAN", pszValue );
pszValue = poAll->FindElem( "Stats.MedianValue", iBand-1 );
if( pszValue )
poDS->GetRasterBand(iBand)->SetMetadataItem(
"STATISTICS_MEDIAN", pszValue );
}
CPLPopErrorHandler();
}
/* -------------------------------------------------------------------- */
/* Do we have GCPs. */
/* -------------------------------------------------------------------- */
if( poHeader->FindNode( "RasterInfo.WarpControl" ) )
poDS->ReadGCPs();
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
// if no SR in xml, try aux
const char* pszPrj = poDS->GDALPamDataset::GetProjectionRef();
if( !pszPrj || strlen(pszPrj) == 0 )
{
// try aux
GDALDataset* poAuxDS = GDALFindAssociatedAuxFile( poOpenInfo->pszFilename, GA_ReadOnly, poDS );
if( poAuxDS )
{
pszPrj = poAuxDS->GetProjectionRef();
if( pszPrj && strlen(pszPrj) > 0 )
{
CPLFree( poDS->pszProjection );
poDS->pszProjection = CPLStrdup(pszPrj);
}
GDALClose( poAuxDS );
}
}
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
void GDALDefaultOverviews::OverviewScan()
{
if( bCheckedForOverviews || poDS == NULL )
return;
bCheckedForOverviews = true;
CPLDebug( "GDAL", "GDALDefaultOverviews::OverviewScan()" );
/* -------------------------------------------------------------------- */
/* Open overview dataset if it exists. */
/* -------------------------------------------------------------------- */
if( pszInitName == NULL )
pszInitName = CPLStrdup(poDS->GetDescription());
if( !EQUAL(pszInitName,":::VIRTUAL:::") &&
GDALCanFileAcceptSidecarFile(pszInitName) )
{
if( bInitNameIsOVR )
osOvrFilename = pszInitName;
else
osOvrFilename.Printf( "%s.ovr", pszInitName );
std::vector<char> achOvrFilename;
achOvrFilename.resize(osOvrFilename.size() + 1);
memcpy(&(achOvrFilename[0]),
osOvrFilename.c_str(),
osOvrFilename.size() + 1);
bool bExists = CPL_TO_BOOL(
CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) );
osOvrFilename = &achOvrFilename[0];
#if !defined(WIN32)
if( !bInitNameIsOVR && !bExists && !papszInitSiblingFiles )
{
osOvrFilename.Printf( "%s.OVR", pszInitName );
memcpy(&(achOvrFilename[0]),
osOvrFilename.c_str(),
osOvrFilename.size() + 1);
bExists = CPL_TO_BOOL(
CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) );
osOvrFilename = &achOvrFilename[0];
if( !bExists )
osOvrFilename.Printf( "%s.ovr", pszInitName );
}
#endif
if( bExists )
{
poODS = static_cast<GDALDataset *>( GDALOpenEx(
osOvrFilename,
GDAL_OF_RASTER |
(poDS->GetAccess() == GA_Update ? GDAL_OF_UPDATE : 0),
NULL, NULL, papszInitSiblingFiles ) );
}
}
/* -------------------------------------------------------------------- */
/* We didn't find that, so try and find a corresponding aux */
/* file. Check that we are the dependent file of the aux */
/* file. */
/* */
/* We only use the .aux file for overviews if they already have */
/* overviews existing, or if USE_RRD is set true. */
/* -------------------------------------------------------------------- */
if( !poODS && !EQUAL(pszInitName,":::VIRTUAL:::") &&
GDALCanFileAcceptSidecarFile(pszInitName) )
{
bool bTryFindAssociatedAuxFile = true;
if( papszInitSiblingFiles )
{
CPLString osAuxFilename = CPLResetExtension( pszInitName, "aux");
int iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
{
osAuxFilename = pszInitName;
osAuxFilename += ".aux";
iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
bTryFindAssociatedAuxFile = false;
}
}
if( bTryFindAssociatedAuxFile )
{
poODS = GDALFindAssociatedAuxFile( pszInitName, poDS->GetAccess(),
poDS );
}
if( poODS )
{
const bool bUseRRD = CPLTestBool(CPLGetConfigOption("USE_RRD","NO"));
bOvrIsAux = true;
if( GetOverviewCount(1) == 0 && !bUseRRD )
{
bOvrIsAux = false;
GDALClose( poODS );
poODS = NULL;
}
else
{
osOvrFilename = poODS->GetDescription();
}
}
}
/* -------------------------------------------------------------------- */
/* If we still don't have an overview, check to see if we have */
/* overview metadata referencing a remote (i.e. proxy) or local */
/* subdataset overview dataset. */
/* -------------------------------------------------------------------- */
if( poODS == NULL )
{
const char *pszProxyOvrFilename =
poDS->GetMetadataItem( "OVERVIEW_FILE", "OVERVIEWS" );
if( pszProxyOvrFilename != NULL )
{
if( STARTS_WITH_CI(pszProxyOvrFilename, ":::BASE:::") )
{
const CPLString osPath = CPLGetPath(poDS->GetDescription());
osOvrFilename =
CPLFormFilename( osPath, pszProxyOvrFilename+10, NULL );
}
else
{
osOvrFilename = pszProxyOvrFilename;
}
CPLPushErrorHandler(CPLQuietErrorHandler);
poODS = static_cast<GDALDataset *>(GDALOpen(osOvrFilename, poDS->GetAccess()));
CPLPopErrorHandler();
}
}
/* -------------------------------------------------------------------- */
/* If we have an overview dataset, then mark all the overviews */
/* with the base dataset Used later for finding overviews */
/* masks. Uggg. */
/* -------------------------------------------------------------------- */
if( poODS )
{
const int nOverviewCount = GetOverviewCount(1);
for( int iOver = 0; iOver < nOverviewCount; iOver++ )
{
GDALRasterBand * const poBand = GetOverview( 1, iOver );
GDALDataset * const poOverDS = poBand != NULL ?
poBand->GetDataset() : NULL;
if( poOverDS != NULL )
{
poOverDS->oOvManager.poBaseDS = poDS;
poOverDS->oOvManager.poDS = poOverDS;
}
}
}
}
int ISIS2Dataset::WriteLabel(
CPLString osFilename, CPLString osRasterFile, CPLString sObjectTag,
unsigned int nXSize, unsigned int nYSize, unsigned int nBands,
GDALDataType eType,
GUIntBig iRecords, const char * pszInterleaving,
GUIntBig &iLabelRecords, bool bRelaunch)
{
CPLDebug("ISIS2", "Write Label filename = %s, rasterfile = %s",osFilename.c_str(),osRasterFile.c_str());
bool bAttachedLabel = EQUAL(osRasterFile, "");
VSILFILE *fpLabel = VSIFOpenL( osFilename, "w" );
if( fpLabel == NULL ) {
CPLError( CE_Failure, CPLE_FileIO,
"Failed to create %s:\n%s",
osFilename.c_str(), VSIStrerror( errno ) );
return FALSE;
}
unsigned int iLevel(0);
unsigned int nWritingBytes(0);
/* write common header */
nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "PDS_VERSION_ID", "PDS3" );
nWritingBytes += ISIS2Dataset::WriteFormatting( fpLabel, "");
nWritingBytes += ISIS2Dataset::WriteFormatting( fpLabel, "/* File identification and structure */");
nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "RECORD_TYPE", "FIXED_LENGTH" );
nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "RECORD_BYTES", CPLString().Printf("%d",RECORD_SIZE));
nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "FILE_RECORDS", CPLString().Printf(CPL_FRMT_GUIB,iRecords));
nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "LABEL_RECORDS", CPLString().Printf(CPL_FRMT_GUIB,iLabelRecords));
if(!bAttachedLabel) {
nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "FILE_NAME", CPLGetFilename(osRasterFile));
}
nWritingBytes += ISIS2Dataset::WriteFormatting( fpLabel, "");
nWritingBytes += ISIS2Dataset::WriteFormatting( fpLabel, "/* Pointers to Data Objects */");
if(bAttachedLabel) {
nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, CPLString().Printf("^%s",sObjectTag.c_str()), CPLString().Printf(CPL_FRMT_GUIB,iLabelRecords+1));
} else {
nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, CPLString().Printf("^%s",sObjectTag.c_str()), CPLString().Printf("(\"%s\",1)",CPLGetFilename(osRasterFile)));
}
if(EQUAL(sObjectTag, "QUBE")) {
ISIS2Dataset::WriteQUBE_Information(fpLabel, iLevel, nWritingBytes, nXSize, nYSize, nBands, eType, pszInterleaving);
}
nWritingBytes += ISIS2Dataset::WriteFormatting( fpLabel, "END");
// check if file record is correct
unsigned int q = nWritingBytes/RECORD_SIZE;
if( q <= iLabelRecords) {
// correct we add space after the label end for complete from iLabelRecords
unsigned int nSpaceBytesToWrite = (unsigned int) (iLabelRecords * RECORD_SIZE - nWritingBytes);
VSIFPrintfL(fpLabel,"%*c", nSpaceBytesToWrite, ' ');
} else {
iLabelRecords = q+1;
ISIS2Dataset::WriteLabel(osFilename, osRasterFile, sObjectTag, nXSize, nYSize, nBands, eType, iRecords, pszInterleaving, iLabelRecords);
}
VSIFCloseL( fpLabel );
return TRUE;
}
GDALDataset * SRTMHGTDataset::CreateCopy( const char * pszFilename,
GDALDataset *poSrcDS,
int bStrict,
char ** /* papszOptions*/,
GDALProgressFunc pfnProgress,
void * pProgressData )
{
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
const int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"SRTMHGT driver does not support source dataset with zero band.\n");
return nullptr;
}
else if (nBands != 1)
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"SRTMHGT driver only uses the first band of the dataset.\n");
if (bStrict)
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Checks the input SRS */
/* -------------------------------------------------------------------- */
OGRSpatialReference ogrsr_input;
ogrsr_input.importFromWkt(poSrcDS->GetProjectionRef());
OGRSpatialReference ogrsr_wgs84;
ogrsr_wgs84.SetWellKnownGeogCS( "WGS84" );
if ( ogrsr_input.IsSameGeogCS(&ogrsr_wgs84) == FALSE)
{
CPLError( CE_Warning, CPLE_AppDefined,
"The source projection coordinate system is %s. Only WGS 84 "
"is supported.\nThe SRTMHGT driver will generate a file as "
"if the source was WGS 84 projection coordinate system.",
poSrcDS->GetProjectionRef() );
}
/* -------------------------------------------------------------------- */
/* Work out the LL origin. */
/* -------------------------------------------------------------------- */
double adfGeoTransform[6];
if (poSrcDS->GetGeoTransform( adfGeoTransform ) != CE_None)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Source image must have a geo transform matrix.");
return nullptr;
}
const int nLLOriginLat = static_cast<int>(
std::floor(adfGeoTransform[3]
+ poSrcDS->GetRasterYSize() * adfGeoTransform[5] + 0.5) );
int nLLOriginLong = static_cast<int>(
std::floor(adfGeoTransform[0] + 0.5) );
if (std::abs(nLLOriginLat - (
adfGeoTransform[3] + (poSrcDS->GetRasterYSize() - 0.5 )
* adfGeoTransform[5] ) ) > 1e-10 ||
std::abs(nLLOriginLong - (
adfGeoTransform[0] + 0.5 * adfGeoTransform[1])) > 1e-10 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"The corner coordinates of the source are not properly "
"aligned on plain latitude/longitude boundaries.");
}
/* -------------------------------------------------------------------- */
/* Check image dimensions. */
/* -------------------------------------------------------------------- */
const int nXSize = poSrcDS->GetRasterXSize();
const int nYSize = poSrcDS->GetRasterYSize();
if (!((nXSize == 1201 && nYSize == 1201) ||
(nXSize == 3601 && nYSize == 3601) ||
(nXSize == 1801 && nYSize == 3601)))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Image dimensions should be 1201x1201, 3601x3601 or 1801x3601.");
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Check filename. */
/* -------------------------------------------------------------------- */
char expectedFileName[12];
CPLsnprintf(expectedFileName, sizeof(expectedFileName), "%c%02d%c%03d.HGT",
(nLLOriginLat >= 0) ? 'N' : 'S',
(nLLOriginLat >= 0) ? nLLOriginLat : -nLLOriginLat,
(nLLOriginLong >= 0) ? 'E' : 'W',
(nLLOriginLong >= 0) ? nLLOriginLong : -nLLOriginLong);
if (!EQUAL(expectedFileName, CPLGetFilename(pszFilename)))
{
CPLError( CE_Warning, CPLE_AppDefined,
"Expected output filename is %s.", expectedFileName);
}
/* -------------------------------------------------------------------- */
/* Write output file. */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(pszFilename, "wb");
if (fp == nullptr)
{
CPLError( CE_Failure, CPLE_FileIO,
"Cannot create file %s", pszFilename );
return nullptr;
}
GInt16* panData
= reinterpret_cast<GInt16 *>( CPLMalloc(sizeof(GInt16) * nXSize) );
GDALRasterBand* poSrcBand = poSrcDS->GetRasterBand(1);
int bSrcBandHasNoData;
double srcBandNoData = poSrcBand->GetNoDataValue(&bSrcBandHasNoData);
for( int iY = 0; iY < nYSize; iY++ )
{
if( poSrcBand->RasterIO( GF_Read, 0, iY, nXSize, 1,
reinterpret_cast<void *>( panData ), nXSize, 1,
GDT_Int16, 0, 0, nullptr ) != CE_None )
{
VSIFCloseL(fp);
CPLFree( panData );
return nullptr;
}
/* Translate nodata values */
if (bSrcBandHasNoData && srcBandNoData != SRTMHG_NODATA_VALUE)
{
for( int iX = 0; iX < nXSize; iX++ )
{
if (panData[iX] == srcBandNoData)
panData[iX] = SRTMHG_NODATA_VALUE;
}
}
#ifdef CPL_LSB
GDALSwapWords(panData, 2, nXSize, 2);
#endif
if( VSIFWriteL( panData,sizeof(GInt16) * nXSize,1,fp ) != 1)
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to write line %d in SRTMHGT dataset.\n",
iY );
VSIFCloseL(fp);
CPLFree( panData );
return nullptr;
}
if( pfnProgress && !pfnProgress( (iY+1) / static_cast<double>( nYSize ),
nullptr, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt,
"User terminated CreateCopy()" );
VSIFCloseL(fp);
CPLFree( panData );
return nullptr;
}
}
CPLFree( panData );
VSIFCloseL(fp);
/* -------------------------------------------------------------------- */
/* Reopen and copy missing information into a PAM file. */
/* -------------------------------------------------------------------- */
GDALPamDataset *poDS = reinterpret_cast<GDALPamDataset *>(
GDALOpen( pszFilename, GA_ReadOnly ) );
if( poDS )
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT);
return poDS;
}
GDALDataset* SRTMHGTDataset::Open(GDALOpenInfo* poOpenInfo)
{
if (!Identify(poOpenInfo))
return nullptr;
const char* fileName = CPLGetFilename(poOpenInfo->pszFilename);
CPLString osLCFilename(CPLString(fileName).tolower());
if( !STARTS_WITH(fileName, "/vsizip/") &&
osLCFilename.endsWith(".hgt.zip") )
{
CPLString osFilename ("/vsizip/");
osFilename += poOpenInfo->pszFilename;
osFilename += "/";
osFilename += CPLString(fileName).substr(0, 7);
osFilename += ".hgt";
GDALOpenInfo oOpenInfo(osFilename, poOpenInfo->eAccess);
GDALDataset* poDS = Open(&oOpenInfo);
if( poDS != nullptr )
{
// override description with the main one
poDS->SetDescription(poOpenInfo->pszFilename);
}
return poDS;
}
if( !STARTS_WITH(fileName, "/vsizip/") &&
osLCFilename.endsWith(".srtmswbd.raw.zip") )
{
CPLString osFilename("/vsizip/");
osFilename += poOpenInfo->pszFilename;
osFilename += "/";
osFilename += CPLString(fileName).substr(0, 7);
osFilename += ".raw";
GDALOpenInfo oOpenInfo(osFilename, poOpenInfo->eAccess);
GDALDataset* poDS = Open(&oOpenInfo);
if( poDS != nullptr )
{
// override description with the main one
poDS->SetDescription(poOpenInfo->pszFilename);
}
return poDS;
}
char latLonValueString[4];
memset(latLonValueString, 0, 4);
strncpy(latLonValueString, &fileName[1], 2);
int southWestLat = atoi(latLonValueString);
memset(latLonValueString, 0, 4);
// cppcheck-suppress redundantCopy
strncpy(latLonValueString, &fileName[4], 3);
int southWestLon = atoi(latLonValueString);
if(fileName[0] == 'N' || fileName[0] == 'n')
/*southWestLat = southWestLat */;
else if(fileName[0] == 'S' || fileName[0] == 's')
southWestLat = southWestLat * -1;
else
return nullptr;
if(fileName[3] == 'E' || fileName[3] == 'e')
/*southWestLon = southWestLon */;
else if(fileName[3] == 'W' || fileName[3] == 'w')
southWestLon = southWestLon * -1;
else
return nullptr;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
SRTMHGTDataset* poDS = new SRTMHGTDataset();
poDS->fpImage = poOpenInfo->fpL;
poOpenInfo->fpL = nullptr;
VSIStatBufL fileStat;
if(VSIStatL(poOpenInfo->pszFilename, &fileStat) != 0)
{
delete poDS;
return nullptr;
}
int numPixels_x, numPixels_y;
GDALDataType eDT = GDT_Int16;
switch (fileStat.st_size) {
case 3601 * 3601:
numPixels_x = numPixels_y = 3601;
eDT = GDT_Byte;
break;
case 3601 * 3601 * 2:
numPixels_x = numPixels_y = 3601;
break;
case 1801 * 3601 * 2:
numPixels_x = 1801;
numPixels_y = 3601;
break;
case 1201 * 1201 * 2:
numPixels_x = numPixels_y = 1201;
break;
default:
numPixels_x = numPixels_y = 0;
break;
}
poDS->eAccess = poOpenInfo->eAccess;
#ifdef CPL_LSB
if(poDS->eAccess == GA_Update && eDT == GDT_Int16)
{
poDS->panBuffer
= reinterpret_cast<GInt16 *>( CPLMalloc(numPixels_x * sizeof(GInt16)) );
}
#endif
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = numPixels_x;
poDS->nRasterYSize = numPixels_y;
poDS->nBands = 1;
poDS->adfGeoTransform[0] = southWestLon - 0.5 / (numPixels_x - 1);
poDS->adfGeoTransform[1] = 1.0 / (numPixels_x-1);
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = southWestLat + 1 + 0.5 / (numPixels_y - 1);
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = -1.0 / (numPixels_y-1);
poDS->SetMetadataItem( GDALMD_AREA_OR_POINT, GDALMD_AOP_POINT );
/* -------------------------------------------------------------------- */
/* Create band information object. */
/* -------------------------------------------------------------------- */
SRTMHGTRasterBand* tmpBand = new SRTMHGTRasterBand(poDS, 1, eDT);
poDS->SetBand(1, tmpBand);
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription(poOpenInfo->pszFilename);
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Support overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}