DtCDBPager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright(c) 2020 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/DtCDBPagerConfig.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>

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 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);

        bool getAdditive() { return myAdditive; }

        void setAdditive(bool additive) { myAdditive = additive; }

        //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 CdbGroupNode* createCDBGroupNode(const CDBTileKey& key, osgEarth::ProgressCallback* 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:

        struct ProgressTracker : public osg::NodeCallback {
            ProgressTracker(osg::NodeCallback*);
            osg::ref_ptr<osgEarth::ProgressCallback> _progress[4];
            void operator()(osg::Node*, osg::NodeVisitor*);
        };

        osg::Node* loadKey(const CDBTileKey& key, ProgressTracker* progress, CdbGroupNode* parentGroup);

    protected:

        osg::Node* buildRootNode();

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

        bool loadCdbTileModels(const CDBTileKey& key, ProgressCallback* 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, const std::string& classdbf, const std::string& extendeddbf) const;

        bool myAdditive;

        int myMinLevel;

        int myMaxLevel;

        osg::ref_ptr< osg::NodeCallback > myProgressMaster;

        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;

        bool processShapeFile(VectFile* shpVector 
           , const std::string& instanceShp
           , const std::string& classdbf
           , const CDBTileVerbose& verboseKey
           , CdbGroupNode* groupNode
           , ProgressCallback* progress
           , bool& wasModelFound) const;


        static const DtCDBPagerConfig 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