DtChannelConfiguration.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2012 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
 
 
#pragma once

#include <vrvUtil/vrvUtil.h> 
#include <vrvUtil/DtConfiguration.h>
#include <vrvUtil/DtKeywordMixin.h>

#include <boost/serialization/set.hpp>
 
namespace makVrv 
{ 
   class DT_DLL_VRVUTIL DtChannelConfiguration 
      : public DtConfiguration
      , public DtKeywordMixin
   { 
      
   public:

      static const char* DefaultChannelString;
      
      static const char* UseObserverSensorString;

      enum ProjectionUnits
      {
         NoUnits,
         FieldOfViewAngles,
         DatabaseUnits
      };

      enum ProjectionResizePolicy
      {
         FIXED = 0, 
         HORIZONTAL, 
         VERTICAL, 
         NONE
      };

      DtChannelConfiguration(const std::string& name = DefaultChannelString);

      DtChannelConfiguration(const DtChannelConfiguration&);

      DtChannelConfiguration& operator=(const DtChannelConfiguration&);

      virtual ~DtChannelConfiguration();

      virtual void setParentChannel(const std::string& displayName, 
         const std::string& windowName, const std::string& channelName);

      virtual void getParentChannel(std::string& displayEngineNameOut, 
         std::string& windowNameOut, std::string& channelNameOut) const;
    
      virtual void setProjection(ProjectionUnits units, double left, double right, double bottom, double top, 
         double zNear, double zFar);

      virtual void getProjection(ProjectionUnits& units, double &left, double &right, double &bottom, double &top, 
         double &zNear, double &zFar) const;

      bool dynamicNearFar() const;

      void setDynamicNearFar(bool enabled);

      double nearFarRatio() const;

      void setNearFarRatio(double ratio);

      virtual ProjectionUnits projectionUnits() const;

      virtual void setProjectionUnits(ProjectionUnits units);
                  
      virtual void getClearColor(float& r,float& g,float& b,float& a) const;

      virtual void setClearColor(float r,float g,float b,float a);

      virtual void setCameraPositionOffset(double x, double y, double z);

      virtual void getCameraPositionOffset(double& x, double& y, double& z) const;

      virtual void setCameraOrientationOffset(double psi, double theta, double phi);

      virtual void getCameraOrientationOffset(double& psi, double& theta, double& phi) const;

      virtual void getViewport(double& left,double& right,double& bottom,double& top) const;

      virtual void setViewport(double left,double right,double bottom, double top);

      virtual const std::string& observerName() const;

      virtual void setObserverName(const std::string& observerName);

      virtual const std::string& sensorName() const;

      virtual void setSensorName(const std::string& sensorName);

      virtual ProjectionResizePolicy projectionResizePolicy() const;

      virtual void setProjectionResizePolicy(ProjectionResizePolicy policy);

      virtual double cameraMagnification() const;

      virtual void setCameraMagnification(double mag);
   
      DT_DECLARE_ALL_serialize_FUNCTIONS
   protected:

      template<class Archive>
      void _serialize(Archive & ar, const unsigned int version)
      {
         ar & DT_SERIALIZE_BASE(DtConfiguration);

         ar & DT_SERIALIZE_MEMBER(myClearColorR);
         ar & DT_SERIALIZE_MEMBER(myClearColorG);
         ar & DT_SERIALIZE_MEMBER(myClearColorB);
         ar & DT_SERIALIZE_MEMBER(myClearColorA);
         ar & DT_SERIALIZE_MEMBER(myViewportLeft);
         ar & DT_SERIALIZE_MEMBER(myViewportRight);
         ar & DT_SERIALIZE_MEMBER(myViewportBottom);
         ar & DT_SERIALIZE_MEMBER(myViewportTop);
         ar & DT_SERIALIZE_MEMBER(myParentDisplayEngineName);
         ar & DT_SERIALIZE_MEMBER(myParentWindowName);
         ar & DT_SERIALIZE_MEMBER(myParentChannelName);
         ar & DT_SERIALIZE_MEMBER(myCameraPositionOffsetX);
         ar & DT_SERIALIZE_MEMBER(myCameraPositionOffsetY);
         ar & DT_SERIALIZE_MEMBER(myCameraPositionOffsetZ);
         ar & DT_SERIALIZE_MEMBER(myCameraOrientationOffsetPsi);         
         ar & DT_SERIALIZE_MEMBER(myCameraOrientationOffsetTheta);
         ar & DT_SERIALIZE_MEMBER(myCameraOrientationOffsetPhi);
         ar & DT_SERIALIZE_MEMBER(myFrustumLeft);
         ar & DT_SERIALIZE_MEMBER(myFrustumRight);
         ar & DT_SERIALIZE_MEMBER(myFrustumTop);
         ar & DT_SERIALIZE_MEMBER(myFrustumBottom);
         ar & DT_SERIALIZE_MEMBER(myNearZ);
         ar & DT_SERIALIZE_MEMBER(myFarZ);
         ar & DT_SERIALIZE_MEMBER(myProjectionUnits);
         ar & DT_SERIALIZE_MEMBER(myObserverName);
         ar & DT_SERIALIZE_MEMBER(myProjectionResizePolicy);   

         if(version > 1)
         {
            ar & DT_SERIALIZE_MEMBER(myKeywords);
         }
         
         if (version > 2)
         {
            ar & DT_SERIALIZE_MEMBER(myDynamicNearFar);
            ar & DT_SERIALIZE_MEMBER(myNearFarRatio);
         }

         if (version > 3)
         {
            ar & DT_SERIALIZE_MEMBER(myCameraMagnification);
         }

         if (version > 4)
         {
            ar & DT_SERIALIZE_MEMBER(mySensorName);
         }
      }

      std::string myParentDisplayEngineName;
      std::string myParentWindowName;
      std::string myParentChannelName;

      //Default Clear color is 0,0,0,0
      float myClearColorR;
      float myClearColorG;
      float myClearColorB;
      float myClearColorA;;

      double myViewportLeft;
      double myViewportRight;
      double myViewportBottom;
      double myViewportTop;

      double myCameraPositionOffsetX;
      double myCameraPositionOffsetY;
      double myCameraPositionOffsetZ;
      double myCameraOrientationOffsetPsi;
      double myCameraOrientationOffsetTheta;
      double myCameraOrientationOffsetPhi;
      
      double myFrustumLeft;
      double myFrustumRight;
      double myFrustumTop;
      double myFrustumBottom;
      double myNearZ;
      double myFarZ;

      bool myDynamicNearFar; //Version 3
      double myNearFarRatio; //Version 3

      double myCameraMagnification; // Version 4

      ProjectionUnits myProjectionUnits;
      std::string myObserverName;
      std::string mySensorName;
      ProjectionResizePolicy myProjectionResizePolicy;
   }; 
} 

BOOST_CLASS_VERSION(makVrv::DtChannelConfiguration,5)