DtCDBVector.h

Go to the documentation of this file.

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

#pragma once

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

#include <vrvOsg/DtRenderingMethod.h>

#include <osgearth_cdb_utils/DtCDBClassRow.h>
#include <osgearth_cdb_utils/DtCDBSigSizeTable.h>
#include <osgearth_cdb_utils/DTCDBDatabase.h>
#include <osgearth_cdb_utils/DtCDBDatasetInfo.h>
#include <osgearth_cdb_utils/DtCDBMcod.h>
#include <osgearth_cdb_utils/DtCDBBaseMaterialTable.h>
#include <osgearth_cdb_utils/DtCDBDbfConfig.h>

#include <tbb/concurrent_hash_map.h>

#include <Vect/Cee_VectFeature.h>
#include <Cee_CdbDB.h>

namespace osgEarth
{
   class SpatialReference;
}

namespace makVrv 
{ 
   class DtIndirectGeometryRegistrar;
   class DtIndirectGeometry;
   class DtOsgGraphMergeOperation;

   namespace oe { namespace CDB {

   class DatasetInfo;
   class CDBTileKey;
   class CDBTileVerbose;
   class CDBModelOptions;
   class CdbGroupNode;
   class CDBDatasets;
   class DtCDBClassIndex;
   class DtCDBInstanceIndex;
   class DtCdbGroupNodeProgress;

   class DtCDBVector : public osg::Referenced
   {
   public:
      DtCDBVector(const DatasetInfo& CurrentDataset, osg::ref_ptr<DtCDBDatabase> cdbDb, const osgDB::Options* dbOptions, const CDBModelOptions* cdbModelOptions, DtDe& de);
      ~DtCDBVector();

      virtual void initialize(const std::string& shpInstanceFile, DtCDBInstanceIndex& instanceAttrIndexes,
                              const std::string& dbfClassFile,    DtCDBClassIndex& classAttrIndexes, 
                              const std::string& dbfExtendedFile) = 0;
      virtual bool isInitialized() const { return myIsInitialized; };

      virtual void readInstance(const std::string& dbfClassFile, DtCDBInstanceIndex& instanceAttrIndexes, const CDBTileKey& key, 
         const std::string& shpInstanceFile, VectFile* shpVector, VecInstancesDbfRow& vecInstanceRow, const MapStringToClassDbfRow& classMap) = 0;

      virtual void readClass(const std::string& dbfClassFile, DtCDBClassIndex& classAttrIndexes, const CDBTileKey& key, MapStringToClassDbfRow& classMap) = 0;
      //virtual void readExtended() = 0;
      virtual void processFeature(const std::string& dbfClassFile, const CDBTileKey& key, CdbGroupNode* groupNode, VecInstancesDbfRow& vecInstanceRow, 
         DtCdbGroupNodeProgress* progress, bool& wasModelFound) = 0;

      bool getModelPoint(const VectFeature*  feature, osg::Vec3d& modelPoint);

      void setMapNode( osgEarth::MapNode* mapNode );

      virtual DtIndirectGeometryRegistrar * indirectGeometryRegistrar() { return NULL; }
      
      virtual void finishTileLoad(CdbGroupNode* groupNode) { ; }

      virtual void optimizeNodeGraphStateSharing(CdbGroupNode* groupNode);

      virtual void finishLoadingIndirect(DtIndirectGeometry * indirectGeometry);

      virtual bool performFeatureInitializationWithPriority() const;

      osg::ref_ptr<osgDB::Options> & getDbOptions() { return myDbOptions; }

      virtual bool getMCOD() const { return myMCOD;  }
      
      void setDatasetCachePath( const std::string& cachePath );

      RenderingMethod renderingMethod();
      const RenderingMethod renderingMethod() const;
      
      virtual void mapIsolatedNodeToParentNode( osg::ref_ptr<CdbGroupNode> isolatedTempNode,
         osg::ref_ptr<CdbGroupNode> parentNode );

      virtual void mergeGroupNodeIntoLiveScenegraph( osg::ref_ptr<CdbGroupNode> isolatedTempNode, int priority );
   protected:

      virtual std::string createMCODTableString(const std::map<std::string, color2DArray>& baseMaterialMap);

      bool myIsInitialized;
      osg::ref_ptr< osgEarth::SpatialReference > myWgs84;
      osg::observer_ptr<osgEarth::MapNode> myMapNode;

      osg::observer_ptr<osgEarth::ElevationPool> myElevationPool;

      osgEarth::ElevationPool::WorkingSet* myElevationPoolWorkingSet;

      static const DtCDBDbfConfig myVectorConfig;
      DatasetInfo myCurrentDataset;
      std::string myDatasetCachePath;
      std::string myShpInstanceFile;
      std::string myDbfClassFile; 
      std::string myDbfExtendedFile;
      osg::ref_ptr<DtCDBDatabase> myCdbDatabase;
      const CDBModelOptions* myCdbModelOptions;
      osg::ref_ptr<osgDB::Options>  myDbOptions;
      CDBSigSizeTable mySigSizeTable;
      std::string myCDBRootPath;
      std::string myFACC;
      std::string myFSC;
      std::string myCNAM;
      unsigned int myCMIX;

      //int myClassIndexCNAM;
      //int myClassIndexFACC;
      //int myClassIndexFSC;
      //int myClassIndexCMIX;
      
      int myTileLod;

      CDBDatasets* myCDBDatasets;

      RenderingMethod myRenderingMethod;

      DtDe& myDe;

      const bool myEnableIntersections = true;

      const float myModelScaling = 1.0f;

      // Color Map to transform CDB Raster Material to MCOD color
      makVrv::oe::CDB::mcodColorMap myMCODTerrainColorMap;

      osg::ref_ptr<DtCDBBaseMaterialTable>  myProceduralBaseMaterialTable;

      bool myMCOD;

      makVrv::DtOsgGraphMergeOperation* myMergeOperation;

      struct GroupPtrHash
      {
         size_t hash( const osg::ref_ptr<CdbGroupNode>& key ) const
         {
            return std::hash<const CdbGroupNode*>()(key.get());
         }
         bool equal( const osg::ref_ptr<CdbGroupNode >& lhs, const osg::ref_ptr<CdbGroupNode>& rhs ) const
         {
            return lhs.get() == rhs.get();
         }
      };

      using DtIsolatedNodeToLiveNodeMap =
         tbb::concurrent_hash_map< osg::ref_ptr<CdbGroupNode>, osg::ref_ptr<CdbGroupNode>, GroupPtrHash>;
      DtIsolatedNodeToLiveNodeMap myIsolatedGroupNodeToLiveGroupNodes;
   };
}}} // namespace makVrv::oe::CDB