ossimErrorCode ossimVpfDatabaseHeader::open(const ossimFilename& databaseHeaderTable)
{
vpf_table_type tableTypeData;
if( is_vpf_table( databaseHeaderTable.c_str() ) )
{
tableTypeData = vpf_open_table(databaseHeaderTable.c_str(),
(storage_type)DISK,
"rb",
NULL);
if(isDatabaseHeaderTable(tableTypeData))
{
}
else
{
return ossimErrorCodes::OSSIM_ERROR;
}
}
else
{
return ossimErrorCodes::OSSIM_ERROR;
}
return ossimErrorCodes::OSSIM_OK;
}
std::shared_ptr<ossim::ifstream> ossimStreamFactoryRegistry::createIFStream(
const ossimFilename& file, std::ios_base::openmode openMode) const
{
std::shared_ptr<ossim::ifstream>result(0);
for(ossim_uint32 idx = 0; ((idx < theFactoryList.size())&&(!result)); ++idx)
{
result = theFactoryList[idx]->createIFStream(file, openMode);
}
if(!result)
{
if(file.exists())
{
// there is a bug in gcc < 5.0 and we can't use constructors in the
// C++11 build. Will refactor to do a new ifstream then use open
//
result = std::make_shared<ossim::ifstream>();
result->open(file.c_str(), openMode);
if(!result->is_open())
{
result.reset();
}
}
}
return result;
}
bool ossimVpfTable::openTable(const ossimFilename& tableName)
{
closeTable();
if(is_vpf_table(const_cast<char*>(tableName.c_str())))
{
if(theTableInformation)
{
delete theTableInformation;
theTableInformation = NULL;
}
theTableInformation = new vpf_table_type;
memset(theTableInformation, 0, sizeof(vpf_table_type));
theTableName = tableName;
*theTableInformation = vpf_open_table(const_cast<char*>(tableName.c_str()),
disk,
"rb",
NULL);
}
else
{
delete theTableInformation;
theTableInformation = NULL;
return false;
}
return true;
}
bool ossimImageUtil::isFiltered(const ossimFilename& file) const
{
bool result = false;
if ( file.size() )
{
// Strip full path to base name.
std::string baseName = file.file().string();
if ( baseName.size() )
{
std::vector<std::string>::const_iterator i = m_filteredImages.begin();
while ( i != m_filteredImages.end() )
{
if ( baseName == (*i) )
{
result = true;
break;
}
++i;
}
}
}
#if 0 /* Please leave for debug. (drb) */
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimFileWalker::isFiltered file " << (result?"filtered: ":"not filtered: ")
<< file << "\n";
}
#endif
return result;
}
// Note: throws ossimException on error.
void ossimRpfUtil::writeDotRpfFiles( const ossimFilename& aDotTocFile,
const ossimFilename& outputDir )
{
static const char MODULE[] = "ossimRpfUtil::writeDotRpfFiles";
if ( traceDebug() )
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< MODULE << " entered..."
<< "\na.toc file: " << aDotTocFile
<< "\noutput directory: " << outputDir
<< "\n";
}
// Parse the a.toc file:
ossimRefPtr<ossimRpfToc> toc = new ossimRpfToc();
if ( toc->parseFile(aDotTocFile) != ossimErrorCodes::OSSIM_OK )
{
std::string e = MODULE;
e += " ERROR:\nCould not open: ";
e+= aDotTocFile.string();
throw ossimException(e);
}
if ( outputDir.expand().exists() == false )
{
if ( !outputDir.createDirectory(true, 0775) )
{
std::string e = MODULE;
e += " ERROR:\nCould not create directory: ";
e+= outputDir.c_str();
throw ossimException(e);
}
}
//---
// Go through the entries...
//---
ossim_uint32 entries = toc->getNumberOfEntries();
for (ossim_uint32 entry = 0; entry < entries; ++entry)
{
const ossimRpfTocEntry* tocEntry = toc->getTocEntry(entry);
if (tocEntry)
{
if ( tocEntry->isEmpty() == false )
{
writeDotRpfFile(toc.get(), tocEntry, outputDir, entry);
}
}
else
{
std::string e = MODULE;
e += " ERROR: Null entry: ";
e += ossimString::toString(entry).string();
throw ossimException(e);
}
}
} // End: ossimRpfUtil::writeDotRpfFiles
bool ossimplugins::ossimRadarSat2TiffReader::open(const ossimFilename& file)
{
static const char MODULE[] = "ossimplugins::ossimRadarSat2TiffReader::open";
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< MODULE << " entered...\n"
<< "file: " << file << "\n";
}
bool result = false;
if ( isOpen() )
{
close();
}
// Check extension to see if it's xml.
if ( file.ext().downcase() == "xml" )
{
ossimXmlDocument* xdoc = new ossimXmlDocument();
if ( xdoc->openFile(file) )
{
// See if it's a TerraSAR-X product xml file.
if ( isRadarSat2ProductFile(xdoc) )
{
ossimString s;
ossimRadarSat2ProductDoc helper;
if ( helper.getImageFile(xdoc, s) )
{
ossimFilename imageFile = file.expand().path();
imageFile = imageFile.dirCat(s);
setFilename(imageFile);
result = ossimTiffTileSource::open();
if (result)
{
theProductXmlFile = file;
completeOpen();
}
}
}
}
delete xdoc;
xdoc = 0;
} // matches: if ( file.ext().downcase() == "xml" )
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< MODULE << " exit status = " << (result?"true":"false\n")
<< std::endl;
}
return result;
}
void ossimIndexToRgbLutFilter::setLut(const ossimFilename& file)
{
theLutFile = file;
if(file.exists())
{
ossimKeywordlist kwl(file.c_str());
loadState(kwl);
}
}
bool ossimMultiResLevelHistogram::importHistogram(const ossimFilename& file)
{
if( file.fileSize() > 0 )
{
theHistogramFile = file;
ifstream input(file.c_str());
return importHistogram(input);
}
return false;
}
void ossimQtSingleImageWindow::displayImage(const ossimFilename& file)
{
ossimRefPtr<ossimImageHandler> ih = ossimImageHandlerRegistry::instance()->open(file);
if (!ih)
{
QString caption = "Sorry:";
QString text = "Could not find the image handler for file:\n";
text += file.c_str();
QMessageBox::information( this,
caption,
text,
QMessageBox::Ok );
return;
}
if (ih->getNumberOfDecimationLevels() == 1)
{
QString caption("Question:");
QString text = "Would you like to build reduced resolution data sets?\n";
text += "Note:\n";
text += "This can take some time depending on the size of your image.";
text += "\nAlternatively use the command line application: \"img2rr\"";
int answer = QMessageBox::question( this,
caption,
text,
QMessageBox::Yes,
QMessageBox::No);
if (answer == QMessageBox::Yes)
{
//---
// We need to listen for the open overview signal to rebuild the
// theResolutionLevelMenu.
//---
ih->addListener(this);
buildOverViews( ih.get() );
}
}
createImageChain( ih.get() );
// Build the resolution level menu.
buildResolutionLevelMenu();
// Give it to the widget.
theImageWidget->connectMyInputTo(theImageChain.get());
theImageWidget->refresh();
connectMyInputTo(theImageChain.get());
QString caption = "iview : ";
caption += file.file().c_str();
setCaption(caption);
}
bool ossimH5Info::open(const ossimFilename& file)
{
bool result = false;
// Check for empty filename.
if (file.size())
{
try
{
//--
// Turn off the auto-printing when failure occurs so that we can
// handle the errors appropriately
//---
H5::Exception::dontPrint();
if ( H5::H5File::isHdf5( file.string() ) )
{
m_file = file;
result = true;
}
}
catch( const H5::FileIException& error )
{
error.printError();
}
// catch failure caused by the DataSet operations
catch( const H5::DataSetIException& error )
{
error.printError();
}
// catch failure caused by the DataSpace operations
catch( const H5::DataSpaceIException& error )
{
error.printError();
}
// catch failure caused by the DataSpace operations
catch( const H5::DataTypeIException& error )
{
error.printError();
}
catch( ... )
{
}
}
return result;
}
bool ossimNitfInfo::open(const ossimFilename& file)
{
bool result = false;
std::string connectionString = file.c_str();
std::shared_ptr<ossim::istream> str = ossim::StreamFactoryRegistry::instance()->
createIstream( file.c_str(), std::ios_base::in|std::ios_base::binary);
if ( str )
{
result = open(str, connectionString);
}
return result;
}
//**************************************************************************
// CONSTRUCTOR
//**************************************************************************
ossimDtedUhl::ossimDtedUhl(const ossimFilename& dted_file, ossim_int32 offset)
:
theRecSen(),
theField2(),
theLonOrigin(),
theLatOrigin(),
theLonInterval(),
theLatInterval(),
theAbsoluteLE(),
theSecurityCode(),
theNumLonLines(),
theNumLatPoints(),
theMultipleAccuracy(),
theStartOffset(0),
theStopOffset(0)
{
if(!dted_file.empty())
{
// Check to see that dted file exists.
if(!dted_file.exists())
{
theErrorStatus = ossimErrorCodes::OSSIM_ERROR;
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimDtedUhl::ossimDtedUhl: The DTED file does not exist: " << dted_file << std::endl;
return;
}
// Check to see that the dted file is readable.
if(!dted_file.isReadable())
{
theErrorStatus = ossimErrorCodes::OSSIM_ERROR;
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimDtedUhl::ossimDtedUhl: The DTED file is not readable --> " << dted_file << std::endl;
return;
}
std::ifstream in(dted_file.c_str());
if(!in)
{
theErrorStatus = ossimErrorCodes::OSSIM_ERROR;
ossimNotify(ossimNotifyLevel_FATAL) << "FATAL ossimDtedUhl::ossimDtedUhl: Error opening the DTED file: " << dted_file << std::endl;
return;
}
in.seekg(offset);
parse(in);
in.close();
}
}
static void move( const ossimFilename& in, const ossimFilename& out )
{
#if defined(WIN32) || defined(_MSC_VER) && !defined(__CYGWIN__) && !defined(__MWERKS__)
std::string moveCommand = "ren";
#else
std::string moveCommand = "mv";
#endif
std::string command = moveCommand;
command += " ";
command += in.string();
command += " ";
command += out.string();
cout << "Executing " << command << endl;
system(command.c_str());
}
//*************************************************************************************************
//! Reads the TIL file for pertinent info. Returns TRUE if successful
//*************************************************************************************************
bool ossimQuickbirdRpcModel::parseTileData(const ossimFilename& image_file)
{
ossimFilename tileFile (image_file);
tileFile.setExtension("TIL");
if (!findSupportFile(tileFile))
return false;
ossimQuickbirdTile tileHdr;
if(!tileHdr.open(tileFile))
return false;
ossimQuickbirdTileInfo info;
if(!tileHdr.getInfo(info, image_file.file()))
return false;
if((info.theUlXOffset != OSSIM_INT_NAN) && (info.theUlYOffset != OSSIM_INT_NAN) &&
(info.theLrXOffset != OSSIM_INT_NAN) && (info.theLrYOffset != OSSIM_INT_NAN) &&
(info.theLlXOffset != OSSIM_INT_NAN) && (info.theLlYOffset != OSSIM_INT_NAN) &&
(info.theUrXOffset != OSSIM_INT_NAN) && (info.theUrYOffset != OSSIM_INT_NAN))
{
theImageClipRect = ossimIrect(ossimIpt(info.theUlXOffset, info.theUlYOffset),
ossimIpt(info.theUrXOffset, info.theUrYOffset),
ossimIpt(info.theLrXOffset, info.theLrYOffset),
ossimIpt(info.theLlXOffset, info.theLlYOffset));
}
else if ((info.theUlXOffset != OSSIM_INT_NAN) && (info.theUlYOffset != OSSIM_INT_NAN) &&
(theImageClipRect.width() != OSSIM_INT_NAN) && (theImageClipRect.height() != OSSIM_INT_NAN))
{
theImageClipRect = ossimIrect(info.theUlXOffset, info.theUlYOffset,
info.theUlXOffset+theImageClipRect.width()-1,
info.theUlYOffset+theImageClipRect.height()-1);
}
return true;
}
ossimRefPtr<ossimNitfRsmModel> getModelFromExtFile( const ossimFilename& file )
{
ossimRefPtr<ossimNitfRsmModel> result = 0;
if ( file.exists() )
{
result = new ossimNitfRsmModel();
if ( result->parseFile( file, 0 ) ) // Hard coded entry index of 0 for now.
{
cout << "Initialize from ext file success!" << endl;
}
else
{
result = 0;
cerr << "Could not open: " << file << endl;
}
}
else
{
cerr << "File does not exists: " << file << endl;
}
return result;
} // End: getModelFromExtFile(...)
bool ossimXmlDocument::openFile(const ossimFilename& filename)
{
theFilename = filename;
if(theFilename == "")
{
return false;
}
//
// Open XML File:
// Note: Opening text document binary to overcome an apparent windows bug.
//
ifstream xml_stream (filename.c_str(), ios::binary);
if (!xml_stream)
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG: ossimXmlDocument::ossimXmlDocument\n"
<< "encountered opening file <" << filename << "> for "
<< "reading. Aborting..." << endl;
}
return false;
}
return read(xml_stream);
}
void outputTemplateKeywordlist(const ossimFilename &templateFilename)
{
ofstream out(templateFilename.c_str());
out << "file1.filename: <full path and file name>" << endl
<< "file2.filename: <full path and file name>" << endl
<< "// :\n"
<< "// :\n"
<< "// fileN: <full path and file name to the Nth file in the list>" << endl
<< "\n// currently this option has been tested\n"
<< "// with ossimTiffWriter and ossimJpegWriter\n"
<< "// writer.type: ossimTiffWriter" << endl
<< "// writer.filename: <full path to output file>" << endl
<< "\n// Currently, the mosaic application supports\n"
<< "// SIMPLE mosaics (ie. no blending algorithms)\n"
<< "// BLEND for maps or layers that you want to blend together\n"
<< "// FEATHER for applying a spatial feaher along overlapped regions\n"
<< "// mosaic.type: SIMPLE" << endl
<< "\n// product type and projection information" << endl
<< "// is optional. It will use the first images"<<endl
<< "// geometry information instead." << endl
<< "// product.type: " << endl
<< "// product.meters_per_pixel_y: " << endl
<< "// product.meters_per_pixel_x: " << endl
<< "// product.central_meridian: " << endl
<< "// product.origin_latitude:" << endl;
ossimNotify(ossimNotifyLevel_NOTICE)
<< "Wrote file: " << templateFilename << std::endl;
}
void landsat_optimization(ossimFilename gcpFile, ossimFilename headerFile, ossimFilename elevationpath)
{
ossimFilename workfold = headerFile.path();
ossimFilename sourcefile = workfold + "\\header.dat";
ossimFilename gcpfile = gcpFile;
ossimFilename reportfile = workfold + "\\report.txt";
ossimKeywordlist MapProjection;
MyProject prj;
prj.m_CtrlGptSet = new ossimTieGptSet;
prj.m_ChkGptSet = new ossimTieGptSet;
//vector < ossimTieLine > tieLineList;
vector<ossimDFeature> imageFeatureList;
vector<ossimGFeature> groundFeatureList;
prj.ReadGcpAndProjection(ossimFilename(gcpfile));
prj.theMgr = ossimElevManager::instance();
//prj.theMgr->loadElevationPath(ossimFilename(elevationpath));//
prj.m_DemPath=ossimFilename(elevationpath);
prj.GetElevations(prj.m_CtrlGptSet);
prj.GetElevations(prj.m_ChkGptSet);
ossimMapProjection *MapPar = prj.m_MapPar;
MapProjection = prj.m_MapProjection;
prj.m_ImgFileNameUnc = sourcefile;
prj.InitiateSensorModel(sourcefile);
prj.UpdateSensorModel(*prj.m_CtrlGptSet, prj.m_sensorModel, prj.geom);
prj.m_sensorModel->loadState(prj.geom);
prj.OutputReport(reportfile, prj.m_sensorModel, prj.m_CtrlGptSet, prj.m_ChkGptSet);
}
bool ossimElevManager::loadElevationPath(const ossimFilename& path)
{
bool result = false;
ossimElevationDatabase* database = ossimElevationDatabaseRegistry::instance()->open(path);
if(!database&&path.isDir())
{
ossimDirectory dir;
if(dir.open(path))
{
ossimFilename file;
dir.getFirst(file, ossimDirectory::OSSIM_DIR_DIRS);
do
{
database = ossimElevationDatabaseRegistry::instance()->open(file);
if(database)
{
result = true;
addDatabase(database);
}
}while(dir.getNext(file));
}
}
else if(database)
{
result = true;
addDatabase(database);
}
return result;
}
bool genlas(const ossimFilename& fname)
{
cout << "Generating file <"<<fname<<">"<<endl;
FauxReader reader;
Options roptions;
BOX3D bbox(-0.001, -0.001, -100.0, 0.001, 0.001, 100.0);
roptions.add("bounds", bbox);
roptions.add("num_points", 11);
roptions.add("mode", "ramp");
reader.setOptions(roptions);
LasWriter writer;
Options woptions;
woptions.add("filename", fname.string());
woptions.add("a_srs", "EPSG:4326"); // causes core dump when ossimInit::initialize() called on startup
woptions.add("scale_x", 0.0000001);
woptions.add("scale_y", 0.0000001);
writer.setOptions(woptions);
writer.setInput(reader);
PointTable wtable;
writer.prepare(wtable);
writer.execute(wtable);
return true;
}
bool ossimErsSarModel::isErsLeader(const ossimFilename& file) const
{
std::ifstream candidate(file.c_str(), ios::in | ios::binary);
char ersFileName[16];
candidate.seekg(48);
if (candidate.bad() || candidate.eof())
{
return false;
}
candidate.read(ersFileName, 16);
if (candidate.bad() || candidate.eof())
{
return false;
}
candidate.close();
ossimString ersString(ersFileName);
if ((ersString.find("ERS") == 0) &&
(ersString.find(".SAR.") == 4) &&
(ersString.find("LEAD") == 12))
{
return true;
}
else
{
return false;
}
}
ossimDtedHandler::ossimDtedHandler(const ossimFilename& dted_file, bool memoryMapFlag)
:
ossimElevCellHandler(dted_file),
m_fileStr(),
m_numLonLines(0),
m_numLatPoints(0),
m_dtedRecordSizeInBytes(0),
m_edition(),
m_productLevel(),
m_compilationDate(),
m_offsetToFirstDataRecord(0),
m_latSpacing(0.0),
m_lonSpacing(0.0),
m_swCornerPost(),
m_swapBytesFlag(false)
{
static const char MODULE[] = "ossimDtedHandler (Filename) Constructor";
if (traceExec())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG " << MODULE <<": entering..." << std::endl;
}
m_swapBytesFlag = ossim::byteOrder() == OSSIM_LITTLE_ENDIAN ? true : false;
//---
// Open the dted file for reading.
//---
if (!open(dted_file, memoryMapFlag))
{
theErrorStatus = ossimErrorCodes::OSSIM_ERROR;
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_FATAL)
<< "FATAL " << MODULE << ": "
<< "\nCould not open file: " << dted_file.c_str()
<< "\nReturning..." << std::endl;
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG " << MODULE << ": returning with error..." << std::endl;
}
return;
}
else
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG " << MODULE <<": Loading dted file: " << dted_file
<< std::endl;
}
}
// DTED is stored in big endian.
if (traceExec())
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "DEBUG " << MODULE << ": returning..." << std::endl;
}
}
//*******************************************************************
// Private Method:
//*******************************************************************
bool ossimKeywordlist::parseFile(const ossimFilename& file,
bool ignoreBinaryChars)
{
if(!file.exists()) return false;
bool result = false;
std::ifstream is;
is.open(file.c_str(), std::ios::in | std::ios::binary);
if(!is.fail())
{
result = parseStream(is, ignoreBinaryChars);
}
is.close();
return result;
}
//*******************************************************************
// Private Method:
//*******************************************************************
bool ossimKeywordlist::parseFile(const ossimFilename& file,
bool ignoreBinaryChars)
{
std::ifstream is;
is.open(file.c_str(), std::ios::in | std::ios::binary);
if ( !is.is_open() )
{
// ESH 07/2008, Trac #234: OSSIM is case sensitive
// when using worldfile templates during ingest
// -- If first you don't succeed with the user-specified
// filename, try again with the results of a case insensitive search.
ossimDirectory directory(file.path());
ossimFilename filename(file.file());
std::vector<ossimFilename> result;
bool bSuccess = directory.findCaseInsensitiveEquivalents( filename, result );
if ( bSuccess == true )
{
int numResults = (int)result.size();
int i;
for ( i=0; i<numResults && !is.is_open(); ++i )
{
is.open( result[i].c_str(), std::ios::in | std::ios::binary );
}
}
if ( !is.is_open() )
{
if ( traceDebug() )
{
// report all errors that aren't existence problems.
// we want to know about things like permissions, too many open files, etc.
ossimNotify(ossimNotifyLevel_DEBUG)
<< "Error opening file: " << file.c_str() << std::endl;
}
return false;
}
}
bool result = parseStream(is, ignoreBinaryChars);
is.close();
return result;
}
void cmpFile(const ossimFilename& wsa,
const ossimFilename& wsb,
const ossimFilename& file)
{
ossimFilename bFile = file.substitute(wsa, wsb);
if ( !file.exists() )
{
cout << "\nnotice: wsb file: " << bFile
<< "\nnotice: wsa file does not exists: " << file
<< "\nb -> a copy command:"
<< "\ncp " << bFile << " " << file << "\n"
<< endl;
}
if ( !bFile.exists() )
{
cout << "\nnotice: wsa file: " << file
<< "\nnotice: wsb file does not exists: " << bFile
<< "\na -> b copy command:"
<< "\ncp " << file << " " << bFile << "\n"
<< endl;
}
if ( file.exists() && bFile.exists() )
{
std::string command = "diff -w --ignore-matching-lines=\\$Id ";
command += file.string();
command += " ";
command += bFile.string();
int status = system( command.c_str() );
if ( status != 0 )
{
cout << "\nnotice files differ:"
<< "\nwsa file: " << file
<< "\nwsb file: " << bFile
<< "\na -> b copy command:"
<< "\ncp " << file << " " << bFile
<< "\nb -> a copy command:"
<< "\ncp " << bFile << " " << file << "\n"
<< endl;
}
}
}
bool ossimTileMapModel::open(const ossimFilename& file)
{
static const char MODULE[] = "ossimTileMapModel::open";
ossimString os = file.beforePos(4);
if (traceDebug())
{
CLOG << " Entered..." << std::endl
<< " trying to open file " << file << std::endl;
}
if(os == "http" || file.ext() == "otb")
{
return true;
}
return false;
}
ossimGeneralRasterElevHandler::ossimGeneralRasterElevHandler(const ossimFilename& file)
:ossimElevCellHandler(file.c_str()),
m_streamOpen(false)
{
if(!open(file))
{
setErrorStatus();
}
}
//**************************************************************************
// CONSTRUCTOR
//**************************************************************************
ossimDtedVol::ossimDtedVol(const ossimFilename& dted_file,
ossim_int32 offset)
:
theStartOffset(0),
theStopOffset(0)
{
if(!dted_file.empty())
{
// Check to see that dted file exists.
if(!dted_file.exists())
{
theErrorStatus = ossimErrorCodes::OSSIM_ERROR;
ossimNotify(ossimNotifyLevel_FATAL)
<< "FATAL ossimDtedVol::ossimDtedVol"
<< "\nThe DTED file does not exist: " << dted_file << std::endl;
return;
}
// Check to see that the dted file is readable.
if(!dted_file.isReadable())
{
theErrorStatus = ossimErrorCodes::OSSIM_ERROR;
ossimNotify(ossimNotifyLevel_FATAL)
<< "FATAL ossimDtedVol::ossimDtedVol"
<< "\nThe DTED file is not readable: " << dted_file << std::endl;
return;
}
// Open the dted file for reading.
std::ifstream in(dted_file.c_str());
if(!in)
{
theErrorStatus = ossimErrorCodes::OSSIM_ERROR;
ossimNotify(ossimNotifyLevel_FATAL)
<< "FATAL ossimDtedVol::ossimDtedVol"
<< "\nUnable to open the DTED file: " << dted_file << std::endl;
return;
}
in.seekg(offset);
parse(in);
in.close();
}
}
ossimRefPtr<ossimNitfRsmModel> getModel( const ossimFilename& file )
{
ossimRefPtr<ossimNitfRsmModel> result = 0;
if ( file.size() )
{
// Get downcased extension:
std::string ext = file.ext().downcase().string();
if ( ext == "ext" )
{
result = getModelFromExtFile( file );
}
else if ( ( ext == "ntf" ) || ( ext == "nitf" ) )
{
result = getModelFromImage( file );
}
}
return result;
}
ossimFilename ossimErsSarModel::findErsLeader(const ossimFilename& file) const
{
ossimFilename leaFile = file;
ossimString datString("DAT_01");
ossimString nulString("NUL_DAT");
ossimString vdfString("VDF_DAT");
ossimString leaString("LEA_01");
if ((file.fileNoExtension() == datString)
|| (file.fileNoExtension() == nulString)
|| (file.fileNoExtension() == leaString))
{
leaFile.setFile(leaString);
if (leaFile.exists())
{
return leaFile;
}
}
return file;
}