DtCDBPager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright(c) 2025 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/

#pragma once

#include <Cee_CdbDB.h>

#include <osgEarth/MapNodeObserver>
#include <osgEarth/Map>

#include <osgdb_osgearth_model_cdb/DtCDBGroupNode.h>
#include <osgdb_osgearth_model_cdb/DtCDBModelRangeTable.h>
#include <osgdb_osgearth_model_cdb/DtCDBModelOptions.h>

#include <osgdb_osgearth_model_cdb/DtCDBVector.h>

#include <osgearth_cdb_utils/DtCDBTileCache.h>
#include <osgearth_cdb_utils/DtCDBTile.h>
#include <osgearth_cdb_utils/DTCDBDatabase.h>
#include <osgearth_cdb_utils/DtCDBDbfConfig.h>

CEE_NAMESPACE_BEGIN_DECL(CEE_NAMESPACE_CDBAPI)
class VectFile;
class VectAttribute;
class VectFeature;
CEE_NAMESPACE_END_DECL(CEE_NAMESPACE_CDBAPI)

namespace osgDB
{
   class Options;
}

namespace makVrv 
{
   class DtDe;

namespace oe { namespace CDB
{
   class CDBTileKey;
   class CDBTileVerbose;
   class CDBModelOptions;
   class DtCDBClassIndex;

   class DtSceneGraphFrameNumberCallback : public osg::NodeCallback
   {
   public:
      DtSceneGraphFrameNumberCallback();

      void operator()( osg::Node* node, osg::NodeVisitor* nv ) override;

      unsigned myFrameNumber;
      bool myCanCancel;
   };

   class DtCdbGroupNodeProgress;

   class DtPagedLodFrameNumberCallback : public osg::NodeCallback
   {
   public:
      DtPagedLodFrameNumberCallback( DtSceneGraphFrameNumberCallback*, bool canCancel );

      void operator()( osg::Node*, osg::NodeVisitor* ) override;

      osg::ref_ptr<DtCdbGroupNodeProgress> myGroupNodeProgressArray[4];
   };

   class DtCdbGroupNodeProgress : public osg::Referenced
   {
   public:
      DtCdbGroupNodeProgress( DtSceneGraphFrameNumberCallback* master, bool canCancel );

      bool isCanceled() const;

      void touch( const osg::FrameStamp* stamp );

      bool myCanCancel;
      unsigned myLastTouchedFrame;
      osg::observer_ptr<DtSceneGraphFrameNumberCallback> myScenegraphFrameNumberCallback;
   };
   
   class CDBPager : public osg::Group, public osgEarth::MapNodeObserver
   {
   public:

      CDBPager( const osgEarth::Map* map, const CDBModelOptions& CdbModelOptions, const osgDB::Options* dbOptions,
         osgEarth::SceneGraphCallbacks* sgCallbacks, DtDe& de );

      virtual ~CDBPager();

      void build();

      void initialize();

      virtual osgEarth::MapNode* getMapNode();

      virtual void setMapNode( osgEarth::MapNode* mapNode );

      //virtual void setMap(const osgEarth::Map* map);

      //int getMinLevel() const { return myMinLevel; }

      //void setMinLevel(int minLevel) { myMinLevel = minLevel; }

      //int getMaxLevel() const { return myMaxLevel; }

      //void setMaxLevel(int maxLevel) { myMaxLevel = maxLevel; }

      //float getPriorityScale() const { return myPriorityScale; }

      //void setPriorityScale(float value) { myPriorityScale = value; }

      //float getPriorityOffset() const { return myPriorityOffset; }

      //void setPriorityOffset(float value) { myPriorityOffset = value; }

      void setFileLocationCallback( osgDB::FileLocationCallback* cb )
      {
         myFileLocationCallback = cb;
      }

      osgDB::FileLocationCallback* getFileLocationCallback() const
      {
         return myFileLocationCallback.get();
      }

      void setEnableCancellation( bool value );

      bool getEnableCancellation() const;

      virtual osg::ref_ptr<CdbGroupNode> createCDBGroupNode( const CDBTileKey& key, DtCdbGroupNodeProgress* progress, CdbGroupNode* parentGroup, bool& CdbtileFound, bool& hasChildren );

      struct Callback : public osg::Referenced
      {
         virtual void onCreateNode( const CDBTileKey& key, osg::Node* node )
         {
         }
      };

      void addCallback( Callback* callback );

      void removeCallback( Callback* callback );

      void traverse( osg::NodeVisitor& nv );

   public:
      osg::Node* loadKey( CDBTileKey key, DtPagedLodFrameNumberCallback* progress, CdbGroupNode* parentGroup );

   protected:

      osg::Node* buildRootNode();

      osg::PagedLOD* createPagedNode( const CDBTileKey& key, DtCdbGroupNodeProgress* progress, CdbGroupNode* parentGroup );

      bool loadCdbTileModels( const CDBTileKey& key, DtCdbGroupNodeProgress* progress, CdbGroupNode* groupNode, bool& CdbtileFound ) const;

      inline bool doesLod0Exist( const CDBTileVerbose& verboseKey, int CdbDatasetCode, int CdbComponentSelector1, int CdbComponentSelector2 ) const;

      inline Quadrant getQuadrant( const CDBTileKey& key ) const;

      bool writeTileToCache( const std::string& cacheKey, CdbGroupNode* node );

      CdbGroupNode* readTileFromCache( const CDBTileKey& key, const std::string& cacheKey );

      void initializeVector( const std::string& instanceshp, DtCDBInstanceIndex& instanceAttrIndexes,
         const std::string& classdbf, DtCDBClassIndex& classAttrIndexes,
         const std::string& extendeddbf ) const;

      int myMinLevel;

      int myMaxLevel;

      osg::ref_ptr< DtSceneGraphFrameNumberCallback > mySceneGraphFrameNumberCallback;

      osg::ref_ptr< osgDB::FileLocationCallback > myFileLocationCallback;

      float myPriorityScale;

      float myPriorityOffset;

      bool myCanCancel;

      osg::ref_ptr< osgEarth::SpatialReference > myWgs84;

      osg::ref_ptr< osgEarth::SpatialReference >  mySrs;

      mutable osgEarth::Threading::Mutex myMutex;

      typedef std::vector< osg::ref_ptr<Callback> > Callbacks;

      Callbacks myCallbacks;

      osg::ref_ptr< osgEarth::SceneGraphCallbacks > mySGCallbacks;

      osg::observer_ptr<osgEarth::MapNode> myMapNode;
      //osg::observer_ptr<const osgEarth::Map> myMap;

      void fire_onCreateNode( const CDBTileKey& key, osg::Node* node );

      osg::ref_ptr<CDBTileCache>    myTileCache;

      const CDBModelOptions myCdbModelOptions;

      osg::ref_ptr<osgDB::Options>  myDbOptions;

      DtCDBModelRangeTable myDefaultModelRangeTable;

      DatasetsModelRangeTable myDatasetsModelRangeTable;

      DatasetInfo myCurrentDataset;

      CDBTile* myCdbTilePtr;

      mutable osg::ref_ptr<DtCDBDatabase> myCdbDatabase;

      CDBDatasets* myCDBDatasets;

      unsigned  int myLastNumBlacklistedFilenames;

      std::string myCachePath;

      std::string myAppDataPath;

      bool processShapeFile( VectFile* shpVector
         , const std::string& instanceShp
         , DtCDBInstanceIndex& instanceAttrIndexes
         , const std::string& classdbf
         , DtCDBClassIndex& classAttrIndexes
         , CdbGroupNode* groupNode
         , DtCdbGroupNodeProgress* progress
         , bool& wasModelFound ) const;


      static const DtCDBDbfConfig myConfig;
      Threading::Atomic myCacheReads;
      Threading::Atomic myCacheHits;
      osg::ref_ptr<CacheBin> myCacheBin;
      optional<CachePolicy> myPolicy;
      osg::ref_ptr<DtCDBVector> myVector;

      DtDe& myDe;

      bool myMapNodeRequired;
   };

} } } // namespace makVrv::oe::CDB