ciScenario.h

Go to the documentation of this file.

// Original Author:  Tim George
// Date:       Oct 2005
//
//
//

#if !defined(_CISCENARIO_H_)
#define _CISCENARIO_H_
#include "ciApi.h"

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <iostream>
#include <fstream>
#include <string.h>
#include "clXML.h"
#include "clXMLNode.h"

#ifndef SKYDOME_RANGE
#define SKYDOME_RANGE 1100000 //195000 
#endif

class CI_API ciScenario  
{
public:     // methods


   void setUseShadows(bool flag){m_useShadows = flag;}
    bool getUseShadows(){return m_useShadows;}
   void setShadowType(int type){m_shadowType = type;}
    int getShadowType(){return m_shadowType;}
   void setShadowMapSize(int size){m_shadowMapSize = size;}
    int getShadowMapSize(){return m_shadowMapSize;}
   void setUseAngleDependentEmissivity(bool flag){m_useAngleDependentEmissivity = flag;}
    bool getUseAngleDependentEmissivity(){return m_useAngleDependentEmissivity;}
   void setUseNormalBasedIM(bool flag){m_useNormalBasedIM = flag;}
    bool getUseNormalBasedIM(){return m_useNormalBasedIM;}
   void setUseLightSources(bool flag){m_useLightSources = flag;}
    bool getUseLightSources(){return m_useLightSources;}
   void setUseLitWindows(int flag){m_useLitWindows = flag;}
    int getUseLitWindows(){return m_useLitWindows;}
   void setLitWindowStart(double time){m_litWindowStart = time;}
   double getLitWindowStart(){return m_litWindowStart;}
   void setLitWindowStop(double time){m_litWindowStop = time;}
   double getLitWindowStop(){return m_litWindowStop;}

   void setChannelClip(bool state){m_channelClip = state;}
   bool getChannelClip(){return m_channelClip;}
   void setChannelClipNear(double nearClip){m_channelClipNear = nearClip;}
   double getChannelClipNear(){return m_channelClipNear;}
   void setChannelClipFar(double farClip){m_channelClipFar = farClip;}
   double getChannelClipFar(){return m_channelClipFar;}

   void setOverrideFltWithIve(bool state){m_overrideFltWithIve = state;}
   bool getOverrideFltWithIve(){return m_overrideFltWithIve;}

    void setUsePostRadScaleOffset(bool flag){m_usePostRadScaleOffset = flag;}
    bool getUsePostRadScaleOffset(){return m_usePostRadScaleOffset;}

   // setBackgroundThreadCPU
   void setBackgroundThreadCPU(int cpu)
   {
      m_backgroundCPUID = cpu;
   }

   // getBackgroundThreadCPU
   int getBackgroundThreadCPU() const
   {
      return m_backgroundCPUID;
   }

   // setBackgroundThreadPriority
   void setBackgroundThreadPriority(int priority)
   {
      m_backgroundThreadPriority = priority;
   }

   // getBackgroundThreadPriority
   int getBackgroundThreadPriority() const
   {
      return m_backgroundThreadPriority;
   }

   void setUseVectorISAR(bool flag){m_useVectorISAR = flag;}
    bool getUseVectorISAR(){return m_useVectorISAR;}

   // setNumMultiSamples
   void setNumMultiSamples(int samples)
   {
      m_numMultiSamples = samples;
   }

   // getNumMultiSamples
   int getNumMultiSamples() const
   {
      return m_numMultiSamples;
   }

   // setNumColorMultiSamples
   void setNumColorMultiSamples(int samples)
   {
      m_numColorMultiSamples = samples;
   }

   // getNumColorMultiSamples
   int getNumColorMultiSamples() const
   {
      return m_numColorMultiSamples;
   }

    // archive
    bool archive(std::ofstream &outf);

    // serialize
    bool serialize(char *filepath);

    //
    // loadXML
    //
    // \par Description:
    // Loads attributes from an XML node
    //
    // \param clXMLNode* scenarioNode
    // \return bool
    //
    bool loadXML(clXMLNode* scenarioNode);

    //
    // parseXML
    //
    // \par Description:
    // Parses an XML document for specific tags
    //
    // \param clXML xmlDocument
    // \return bool
    //
    bool parseXML(clXML& xmlDocument);

    //loadXMLNode
    bool loadXMLNode(std::string tag, char *nodeString);
    //loadXMLNode
    bool loadXMLNode(std::string tag, bool *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, int *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, double *nodeBool);

    //
    // saveXML
    //
    // \par Description:
    // Saves XML nodes to an XML document
    //
    // \param clXML* xmlDocument
    //
    void saveXML(clXML* xmlDocument);

    // operator =
    ciScenario operator = (ciScenario &obj);

protected:  // methods

public:     // construction/destruction

    // ciTrack
    ciScenario();

    // ciScenario
    ciScenario(ciScenario &obj);

    virtual ~ciScenario();

protected:  // variables

   bool m_useShadows;
   int m_shadowType;
   int m_shadowMapSize;
   bool m_useAngleDependentEmissivity;
   bool m_useNormalBasedIM;
   bool m_useLightSources;
   int m_useLitWindows;
   double m_litWindowStart;
   double m_litWindowStop;
   bool m_channelClip;
   double m_channelClipNear;
   double m_channelClipFar;
   bool m_overrideFltWithIve;
    bool m_usePostRadScaleOffset;
   int m_backgroundCPUID;
   int m_backgroundThreadPriority;
    bool m_useVectorISAR;
   int m_numMultiSamples;
   int m_numColorMultiSamples;
    clXMLNode* m_parentNode;
private: // variables

};

#endif // _ciSCENARIO_H_