ossimElevManager.h

Go to the documentation of this file.

//*****************************************************************************
// FILE: ossimElevManager.h
//
// License:  See top level LICENSE.txt file.
//
// DESCRIPTION:
//   Contains declaration of class ossimElevManager. This object provides a
//   single interface to an imaging chain for accessing multiple elevation
//   sources. This object owns one or more elevation sources in an ordered
//   list. When queried for an elevation at a particular point, it searches
//   the available sources for the best result, instantiating new sources if
//   necessary.
//
// SOFTWARE HISTORY:
//>
//   13Apr2001  Oscar Kramer
//              Initial coding.
//<
//*****************************************************************************
#ifndef ossimElevManager_HEADER
#define ossimElevManager_HEADER

#include <vector>
#include <ossim/base/ossimConstants.h>
#include <ossim/base/ossimVisitor.h>
#include <ossim/elevation/ossimElevSource.h>
#include <ossim/elevation/ossimElevationDatabase.h>
#include <mutex>

class OSSIM_DLL ossimElevManager : public ossimElevSource
{
public: 
   typedef std::vector<ossimRefPtr<ossimElevationDatabase> > ElevationDatabaseListType;
   
   class OSSIM_DLL ConnectionStringVisitor : public ossimVisitor
   {
   public:
      ConnectionStringVisitor(const ossimString& value);
      virtual ossimRefPtr<ossimVisitor> dup()const{return new ConnectionStringVisitor(*this);}
      const ossimString& getConnectionString()const{return m_connectionString;}
      virtual void visit(ossimObject* obj);
      ossimElevationDatabase* getElevationDatabase(){return m_database.get();}
      
   protected:
      ossimString m_connectionString;
      ossimRefPtr<ossimElevationDatabase> m_database;
   };
   
   virtual ~ossimElevManager();
   
   static ossimElevManager* instance();
   
   virtual double getHeightAboveEllipsoid(const ossimGpt& gpt);
   virtual double getHeightAboveMSL(const ossimGpt& gpt);
   virtual bool pointHasCoverage(const ossimGpt&) const;

   virtual double getMeanSpacingMeters() const;

   virtual bool getAccuracyInfo(ossimElevationAccuracyInfo& info, const ossimGpt& gpt) const;
  
   ossim_uint32 getNumberOfElevationDatabases()const
   {
      return (ossim_uint32) m_dbRoundRobin[0].size();
   }
   ossimElevationDatabase* getElevationDatabase(ossim_uint32 idx)
   {
      return m_dbRoundRobin[0][idx].get();
   }
   const ossimElevationDatabase* getElevationDatabase(ossim_uint32 idx)const
   {
      return m_dbRoundRobin[0][idx].get();
   }

   void addDatabase(ossimElevationDatabase* database, bool set_as_first=false);

   bool loadElevationPath(const ossimFilename& path, bool set_as_first=false);
   
   void setDefaultHeightAboveEllipsoid(double meters) {m_defaultHeightAboveEllipsoid=meters;}
   void setElevationOffset(double meters) {m_elevationOffset=meters;}
   double getElevationOffset() const { return m_elevationOffset; }
   
   void getOpenCellList(std::vector<ossimFilename>& list) const;

   void getCellsForBounds( const std::string& connectionString,
                           const ossim_float64& minLat,
                           const ossim_float64& minLon,
                           const ossim_float64& maxLat,
                           const ossim_float64& maxLon,
                           std::vector<ossimFilename>& cells,
                           ossim_uint32 maxNumberOfCells=0 );

   void getCellsForBounds( const ossim_float64& minLat,
                           const ossim_float64& minLon,
                           const ossim_float64& maxLat,
                           const ossim_float64& maxLon,
                           std::vector<ossimFilename>& cells,
                           ossim_uint32 maxNumberOfCells=0 );
   void getCellsForBounds( const ossimGrect& bounds,
                           std::vector<ossimFilename>& cells,
                           ossim_uint32 maxNumberOfCells=0 );

   void setUseGeoidIfNullFlag(bool flag) { m_useGeoidIfNullFlag = flag; }
   bool getUseGeoidIfNullFlag() const { return m_useGeoidIfNullFlag; }
   void setRoundRobinMaxSize(ossim_uint32 size);

   void clear();
   virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const;
   
   virtual bool loadState(const ossimKeywordlist& kwl, const char* prefix=0);
   
   virtual void accept(ossimVisitor& visitor);
   
   virtual std::ostream& print(std::ostream& out) const;

protected:
   virtual ossimObject* dup() const { return 0; } // required to implement but not permitted to call

   ossimElevManager();
   void loadStandardElevationPaths();

   ElevationDatabaseListType& getNextElevDbList() const; // for multithreading
   
   //static ossimElevManager* m_instance;
   mutable std::vector<ElevationDatabaseListType> m_dbRoundRobin;
   ossim_uint32 m_maxRoundRobinSize;
   ossim_float64 m_defaultHeightAboveEllipsoid;
   ossim_float64 m_elevationOffset;
   
   // if an elevation is returned that's null for ellipsoid then use the geoid manager to calculate a shift
   bool m_useGeoidIfNullFlag;
   bool m_useStandardPaths;
   
   mutable ossim_uint32 m_currentDatabaseIdx;
   
   mutable std::mutex m_mutex;
};

#endif