DtOsgEarthCacheHandler.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsgEarthQt/vrvOsgEarthQt.h>


#include <osg/Matrix>
#include <osgEarth/Bounds>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <matrix/vlVector.h>

#include <QThread>

// Class Forward Declarations
namespace osgEarth
{
   class MapNode;
}

namespace makVrv
{
   // Class Forward Declarations
   class DtCameraNode;
   class DtOsgEarthCache;
   class DtOsgEarthCacheInterface;
   class DtFilledPolygon;
   class DtWindow;
   class DtChannel;
   class DtOsgEarthCacheEditingEventProcessor;
   class DtOverlayRenderer;
   class DtWidgetPicker;
   class DtWindowConfiguration;
   class DtDisplayUnitsConverter;

   class DT_DLL_VRVOSGEARTHQT DtOsgEarthCacheHandler : public QThread
   {
      Q_OBJECT
   public:
      friend class DtOsgEarthCacheHandlerCreator;

      virtual ~DtOsgEarthCacheHandler();

      virtual void onGenerateCacheButtonClicked();
      virtual void onSelectOsgEarthChanged(const std::string& file);
      virtual void onSpecifyCacheAreaCheckBoxChanged(int checked);
      virtual void onEstimateMessageBoxResult(int result);
      virtual void onProgressUpdate(int progress);
      virtual void onCleanup();
      virtual void onClearAreaButtonClicked();
      virtual void onStartLongitudeChanged(double value, bool isFromSlider);
      virtual void onStartLatitudeChanged(double value, bool isFromSlider);
      virtual void onEndLongitudeChanged(double value, bool isFromSlider);
      virtual void onEndLatitudeChanged(double value, bool isFromSlider);
      virtual void onLowestLODChanged(int lowLOD);
      virtual void onHighestLODChanged(int highLOD);
      virtual void onCancelButtonClicked();
      virtual void onCacheFinished();
      virtual void onCacheFinishedMessageBoxResult(int result);

      virtual bool isFinished();

      virtual bool isCanceled();

   signals:

      void QtSignal_updateProgress(int progress);

      void QtSignal_cacheFinished();

   public:

      virtual void run();

      virtual void initialize();

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

      virtual void setLowestLOD(int lowestLevel);

      virtual void setHighestLOD(int highestLevel);

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

      virtual std::string getEstimateInfo();

      virtual void cleanup(bool checkSpecifyCacheCheckBox, bool deleteAll = false);

      virtual osgEarth::Bounds getCorrectBound();

      virtual osg::Matrix getWorldToWindowMatirx();

      DtOsgEarthCacheEditingEventProcessor* getEventProcessor();

      DtOsgEarthCacheInterface* getOsgEarthCacheInterface();

   protected:

      DtOsgEarthCacheHandler(DtDe& de, DtOsgEarthCacheInterface* iFace);

      virtual void initializeChannel();

      virtual void slot_postTick();

      virtual void slot_place(const DtVector& geocentricPos);

      virtual void slot_locationChanged(const DtVector& geocentricPos);

      virtual void slot_drag();

      virtual void slot_windowToBeDestroyed(DtWindow* window);

      virtual void slot_channelToBeDestroyed(const std::string& display, const std::string& window
                                             ,const std::string& channel);

      virtual void slot_updateProgress(int progress);

      virtual void slot_cacheFinished();

      virtual void connectSignals();

      virtual void disconnectSignals();

      virtual std::string formatEstimateTimeandSpace(double estimateTime, double estimateSize);

      class VertexInfo
      {
      public:
         VertexInfo();
         virtual ~VertexInfo();
         virtual void reset();
         virtual void highlight(bool highlight);
         virtual void initialize(const DtVector& normalColor, const DtVector& highLightColor,
                                DtOverlayRenderer* render, DtWidgetPicker& picker);
         virtual void hide();
         virtual void draw();

         double   myWindowX;
         double   myWindowY;
         DtVector myGeocentric;
         DtVector myGeodetic;
         bool     myIsDefined;
         bool     myIsPlaced;
         bool     myIsDragging;
         bool     myIsHighlight;
         DtVector myNormalColor;
         DtVector myCurrentColor;
         DtVector myHighlightColor;
         DtFilledPolygon* myPolygon;
         int myVertexWidth;
      };

      class CacheArea
      {
      public:
         CacheArea(DtDe& dtde,DtVector rectangleColor);

         virtual ~CacheArea();

         virtual void initialize(DtOsgEarthCacheHandler* osgEarthCacheHandler, 
                                 DtOverlayRenderer* render, DtWidgetPicker& picker);

         virtual void setVertexGeocentric(int index, const DtVector& geocentric);

         virtual void setVertexLongitude(int index, double longitude,bool isFromSlider);

         virtual void setVertexLatitude(int index, double latitude, bool isFromSlider);

         virtual double getVertexLongitude(int index);

         virtual double getVertexLatitude(int index);

         virtual void place(const DtVector& geocentric);

         virtual void locationChanged(const DtVector& geocentricPos);

         virtual void drag();

         virtual void markAsDirty(bool fromGeocentric);

         virtual void cleanup(bool deleteAll);

         virtual void update(double mouseX,double mouseY);

         virtual void updateWindowCoordinate();

         virtual void updateHidePoints();

         virtual void draw(double mouseX, double mouseY);

         virtual void handleHighlight(double mouseX,double mouseY);

         virtual void geodeticToGeocentric(const DtVector& geodetic, DtVector& geocentric);

         virtual void geocentricToGeodetic(const DtVector& geocentric, DtVector& geodetic);

         virtual void geocentricToWindow(const DtVector& geocentric, double& mouseX, double& mouseY);

         virtual void setCreating(bool creating);

         virtual void setPlaced(bool placed);

         virtual void setDragging(bool dragging);

         DtDe& myDe;
         DtDisplayUnitsConverter& myConverter;
         DtOsgEarthCacheHandler* myOsgEarthCacheHandler;
         VertexInfo* myVertexs[4];
         DtFilledPolygon* myRectangle;
         bool myIsCreating;
         bool myIsDragging;
         bool myIsPlaced;
         bool myIsDirty;
         bool myUpdateFromGeocentric;
         DtVector myColor;
         int myHighlightRange;
      };

   protected:
      DtDe& myDe;
      DtCameraNode* myCameraNode;
      DtOsgEarthCacheInterface* myInterface;
      DtSignalConnectionManager mySignals;
      DtOsgEarthCache* myOsgEarthCache;
      DtChannel* myChannel;
      CacheArea myCacheArea;
      osgEarth::MapNode* myMapNode;
      DtOsgEarthCacheEditingEventProcessor* myEventProcessor;
      bool mySpecifyArea;
      bool myChannelInitialized;
      int myLowestLOD;
      int myHighestLOD;
      double myEstimateTime;
      double myEstimateSize;
   };

   class DT_DLL_VRVOSGEARTHQT DtOsgEarthCacheHandlerCreator
      : public DtVirtualBaseClass
   {
   public:
      static DtOsgEarthCacheHandlerCreator& instance(DtDe& de);
      static void registerInstance(DtDe& de, DtOsgEarthCacheHandlerCreator* creator);
      virtual DtOsgEarthCacheHandler* create(DtDe& de, DtOsgEarthCacheInterface* iFace) const;
   };
}