DtOsgEarthCache.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsgEarth/vrvOsgEarth.h>

#include <osgEarth/Bounds>
#include <osgEarth/Progress>
#include <osgEarth/GeoData>

#include <vrvUtil/DtUnicode.h>
#include <vrvUtil/DtVirtualBaseClass.h>

// Class Forward Declarations
namespace osgEarth
{
   class Profile;
   class CacheSeed;
   class MapNode;
   class ModelLayer;
   class TaskService;
   class TileVisitor;
   class CacheEstimator;
   class TileKey;
   namespace Features
   {
      class FeatureModelGraph;
   }
}

namespace makVrv
{
   // Class Forward Declarations
   class DtDe;
   class DtOsgEarthCacheEstimator;
   class DtOsgEarthCacheProgressCallback;

   class DT_DLL_VRVOSGEARTH DtOsgEarthCache
   {
   public:
      friend class DtOsgEarthCacheCreator;

      //let the WidgetProgressCallback emit updateProgress signal
      friend class DtWidgetProgressCallback;

      virtual ~DtOsgEarthCache();

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

      virtual void setLowestLOD(int lowestLOD);

      virtual void setHighestLOD(int highestLOD);

      virtual void setBound(const osgEarth::Bounds& bound);

      virtual void getEstimateInfo(double& time, double& size);

      virtual const std::vector<std::string>& imageLayers();

      virtual const std::vector<std::string>& elevationLayers();

      virtual std::vector<std::string> modelLayers();

      virtual void reset();

      virtual void startCache();

      virtual DtUnicode currentLayerName();

      virtual void cancelCache();

      virtual bool isFinished();

      virtual bool isCanceled();

      virtual void setSkipImageLayers(bool skip);

      virtual void setSkipElevationLayers(bool skip);

      virtual void setSkipModelLayers(bool skip);

      boost::signal<void(int)>            signal_updateProgress;
      boost::signal<void()>               signal_cacheFinished;

   private:
      DtOsgEarthCache();
      DtOsgEarthCache(const DtOsgEarthCache &);
      DtOsgEarthCache &operator=(const DtOsgEarthCache &);

   protected:
      DtOsgEarthCache(DtDe&de);

      virtual void cacheModelLayers();

      virtual void cacheModelLayer(osgEarth::ModelLayer* modelLayer);

      virtual osgEarth::GeoExtent getModelLayerExtent(osgEarth::Features::FeatureModelGraph* featureModelGraph);

      virtual osgEarth::Features::FeatureModelGraph* findFeatureModelGraph(osgEarth::ModelLayer* modelLayer);

      virtual void discoverModelLayers();

      virtual void cacheModelLayerImplementation(osgEarth::TaskService* service, osgEarth::ModelLayer* modelLayer);

   protected:
      DtDe& myDe;
      osgEarth::Bounds myBound;
      osgEarth::MapNode* myMapNode;
      osgEarth::TileVisitor* myTileVisitor;
      DtOsgEarthCacheProgressCallback* myProgressCallback;
      osgEarth::CacheSeed* myCacheSeed;
      DtOsgEarthCacheEstimator* myCacheEstimator;
      int  myLowestLOD;
      int  myHighestLOD;
      bool myCanceled;
      bool myFinished;
      bool mySkipImageLayers;
      bool mySkipElevationLayers;
      bool mySkipModelLayers;
      std::vector<std::string> myImageLayers;
      std::vector<std::string> myElevationLayers;
      std::vector<osgEarth::ModelLayer*> myIntersectModelLayers;
   };

   class DT_DLL_VRVOSGEARTH DtOsgEarthCacheProgressCallback : public osgEarth::ProgressCallback
   {
   public:

      DtOsgEarthCacheProgressCallback(DtOsgEarthCache* osgEarthCache);

      virtual ~DtOsgEarthCacheProgressCallback();

      DtUnicode currentProcessingLayerName();

      void setCurrentLayName(const DtUnicode& name);

      void startCacheModelLayer(int tiles, const DtUnicode& name);

      void reset();

      void increaseModelLayerProgress();

      virtual bool reportProgress(
         double             current,
         double             total,
         unsigned           currentStage,
         unsigned           totalStages,
         const std::string& msg);

      DtOsgEarthCache* myOsgEarthCache;
      DtUnicode myCurrentProcessingLayerName;
      int myCurrentProgress;
      bool myUpdateModelLayer;
      int myModelLayerTotalTiles;
      OpenThreads::Mutex myProgressMutex;
   };

   class DT_DLL_VRVOSGEARTH DtOsgEarthCacheCreator
      : public DtVirtualBaseClass
   {
   public:
      static DtOsgEarthCacheCreator& instance(DtDe& de);
      static void registerInstance(DtDe& de, DtOsgEarthCacheCreator* creator);
      virtual DtOsgEarthCache* create(DtDe& de) const;
   };
}