ciEnvironment.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004
// All rights reserved.
//
// This code is the intellectual property of JRM Enterprises, Inc.
// It may not be used or released as source or compiled binary form
// without the prior written consent of JRM Enterprises, Inc.
//
// Original Author:  Nikolai Fedoroff
// Date:       Oct 2004
//
// $Header: /cvsroot/CommonInterface/CILib/include/ciEnvironment.h,v 1.30 2010-10-25 17:20:32 cvsuser Exp $
//
// $Log: not supported by cvs2svn $
// Revision 1.30  2010/10/25 17:20:32  cvsuser
// CF101025 : Added Relative Humidity to XML spec.
//
// Revision 1.29  2010/08/18 13:07:19  cvsuser
// (Tom G) Changed parse functions to pass clXML by reference in order to remove calls to a copy constructor that was causing major delays.
//
// Revision 1.28  2009/11/09 21:45:54  cvsuser
// (ken) Set time from environment not scenario for OSV  ***** could  break Asgard
//
// Revision 1.27  2009/11/05 11:02:17  cvsuser
// (ken) changed to a dll to hopefully allow it to be used with different versions of vc
//
// Revision 1.26  2009/02/27 18:18:20  cvsuser
// (ken) changes for use with VS 2008
// eliminate warnings for stdio routines
//
// Revision 1.25  2008/07/21 18:10:59  cvsuser
// Jon G: Reformated Files to be uniform in respect to tabs and braces. replaceds tabs with spaces.
//
// Revision 1.24  2008/05/14 13:54:54  cvsuser
// Added doxygen tags back into header files for ci module. PS
//
// Revision 1.23  2008/05/02 15:09:46  cvsuser
// Modified ci library to use clXML instead of libxml.  Adjusted project and solution properties and added unit test to ci.  PS
//
// Revision 1.22  2007/03/05 18:17:37  cvsuser
// (Tim) added Doxy comments to CI
//
// Revision 1.21  2007/02/13 23:50:10  cvsuser
// Fix for Linux
// TR
//
// Revision 1.20  2007/01/05 08:09:17  cvsuser
// (Tim) added xml loading to the ci project
//
// Revision 1.19  2006/10/24 12:37:58  cvsuser
// (Tim) added rain rate and rain temp
//
// Revision 1.18  2006/09/05 18:20:45  cvsuser
// (Ken) Changes to remove the atm layer offset in favor of terrain altitude.
//
// Revision 1.17  2006/03/30 23:27:29  cvsuser
// (Tim) Cleaned up the data handers code and added missing doxeygen style comments
//
// Revision 1.16  2006/01/30 22:31:04  cvsuser
// (Tim) Integrated the SenSim panel into the sensor panel
// Creates a SenSim, Detector, Electronics, and Detector Panel for each sensor
// The SenSim is used from the active sensor
// All sensim panels get saved and loaded independantly
//
// Revision 1.15  2006/01/09 23:36:46  cvsuser
// (Tim) Added the Atmosphere Offset and Atmosphere Extinction Scale to the Environment panel
//
// Revision 1.14  2005/12/06 00:21:57  cvsuser
// (Tim)Added a star threshold to set the amount of stars that appear
//
// Revision 1.13  2005/10/31 16:03:02  cvsuser
// (Tim)added the round earth checkbox to the envirnment panel and coded it to enable round earth when checked
//
// Revision 1.12  2005/10/26 19:49:07  cvsuser
// (Tim)Added the Scenario data class to store the data for the scenario Panel
// removed time of day from the envirnment panel and environment data class
// relocated mousevelocity and logscale within interface to be in a scenario data member
//
// Revision 1.11  2005/10/21 22:23:04  cvsuser
// (Tim) Added the button for multiple scattering and added a cimovieplayer object class that gets used to store the movieplayer information.
//
// Revision 1.10  2005/10/13 21:30:33  cvsuser
// (Tim) made mouse velocity and log scale get saved
//
// Revision 1.9  2005/09/19 12:45:53  cvsuser
// Com Library additions
// Tom
//
// Revision 1.8  2005/05/16 18:52:17  cvsuser
// (Ken) Added the emission and scattering enable flags.
//
// Revision 1.7  2005/04/29 21:43:29  cvsuser
// Eric: Changed precision to double from floats but since it wrecks the config files, will have to finish upgrade till later
//
// Revision 1.6  2005/04/22 20:09:48  cvsuser
// Tom
// Added sky dome radius to environment panel GUI.  Moved image display mode to combo box on menu bar.  Also added fnumber and focal length to optics panel
//
// Revision 1.5  2005/03/26 02:29:12  cvsuser
// Tom
// Ta max/min in interface...
//
// Revision 1.4  2005/02/08 16:10:24  cvsuser
// Tom
// Added user defined atmospheric modcard and atm state file loading support
//
// Revision 1.3  2004/11/08 19:01:36  cvsuser
// Added environment changes
// Updated doxycution
//
// Nik
//
// Revision 1.2  2004/11/02 23:03:51  cvsuser
// added "upwards" messaging
// added initialization
//
// Nik
//
// Revision 1.1  2004/10/27 18:40:50  cvsuser
// added ciEnvironment class
//
// Nik
//
//

#pragma once

#if !defined _ciEnvironment_h_
#define _ciEnvironment_h_

#include "ciApi.h"
#include "clXML.h"
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <fstream>
#include <iostream>
#include <assert.h>
#include "clXMLNode.h"

#ifndef DIURNAL
#define DIURNAL 24.0
#endif

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

class CI_API ciEnvironment
{
public:     // enumerations

    // enumAtmModel
    enum enumAtmModel
    {
        TROPICAL_ATMOSPHERE   = 1,        
        MIDLAT_SUMMER      = 2,        
        MIDLAT_WINTER      = 3,        
        SUBARC_SUMMER      = 4,        
        SUBARC_WINTER      = 5,        
        US_STANDARD_1976   = 6,        
        USER_SPEC
    };

    // enumHazeModel
    enum enumHazeModel
    {
        noAerosolAttenuation  = -1,       
        noCloudOrAerosolAtten = 0,        
        ruralVis_23km         = 1,        
        ruralVis_5km       = 2,        
        navyMaritime       = 3,        
        maritime           = 4,        
        urban              = 5,        
        tropospheric       = 6,        
        userDef_cards2Dx      = 7,        
        fog1_200m          = 8,        
        fog2_500m          = 9,        
        desert             = 10,       
    };

public:     // methods

    // setDate
    void setDate(int month, int day, int year)
    {
        m_dateMonth     = month;
        m_dateDay    = day;
        m_dateYear      = year;
    }
    // getDate
    void getDate(int &month, int &day, int &year)
    {
        month  = m_dateMonth;
        day    = m_dateDay;
        year   = m_dateYear;
    }

    // setNightSkyTableFilepath
   void setNightSkyTableFilepath(char *nightSkyTableFilepath){strncpy(m_nightSkyTableFilepath, nightSkyTableFilepath, sizeof(m_nightSkyTableFilepath));}

    // getNightSkyTableFilepath
    char *getNightSkyTableFilepath(){return m_nightSkyTableFilepath;}   

    // setBathymetryTableFilepath
   void setBathymetryTableFilepath(char *bathymetryTableFilepath){strncpy(m_bathymetryTableFilepath, bathymetryTableFilepath, sizeof(m_bathymetryTableFilepath));}

    // getBathymetryTableFilepath
    char *getBathymetryTableFilepath(){return m_bathymetryTableFilepath;}  

    // setMMLSTableFilepath
   void setMMLSTableFilepath(char *mmlsTableFilepath){strncpy(m_mmlsTableFilepath, mmlsTableFilepath, sizeof(m_mmlsTableFilepath));}

    // getMMLSTableFilepath
    char *getMMLSTableFilepath(){return m_mmlsTableFilepath;}  

    //setStarThreshold
    void setStarThreshold(double threshold){m_starThreshold = threshold; }

    //getStarThreshold
    double getStarThreshold(){ 
        if (m_starThreshold > 100)
            m_starThreshold = 100;
        else if (m_starThreshold < 0)
            m_starThreshold = 0;
        return m_starThreshold; }

    // setAtmModel
    void setAtmModel(int atmModel){m_atmModel = atmModel;}
    // getAtmModel
    int getAtmModel(){return m_atmModel;}

    // setHazeModel
    void setHazeModel(int hazeModel){m_hazeModel = hazeModel;}

    // getHazeModel
    int getHazeModel(){return m_hazeModel;}

    // setCloudModel
    void setCloudModel(int cldModel){m_cldModel = cldModel;}

    // getCloudModel
    int getCloudModel(){return m_cldModel;}


    // setNovamModel
    void setNovamModel(int novamModel){m_novamModel = novamModel;}

    // getNovamModel
    int getNovamModel(){return m_novamModel;}


    // setWindVelocity
    void setWindVelocity(double windVelocity){m_windVelocity = windVelocity;}

    // getWindVelocity
    double getWindVelocity(){return m_windVelocity;}

   // getWindDirection
   void setWindDirection(double windDirection) { m_windDirection = windDirection; }

   // getWindDirection
   double getWindDirection() { return m_windDirection; }


    // setVisibility
    void setVisibility(double visibility){m_visibility   = visibility;}

    // getVisibility
    double getVisibility(){return m_visibility;} 

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

    // serialize
    bool serialize(char *filepath);

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

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

    // ciEnvironment
    ciEnvironment(void);

    // ~ciEnvironment
    ~ciEnvironment(void);

    // ciEnvironment
    ciEnvironment(ciEnvironment &obj);

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

    // setUseAtmosphericAttenuation
    void setUseAtmosphericAttenuation(bool useAtmosphericAttenuation) {m_useAtmosphericAttenuation = useAtmosphericAttenuation;}

    // getUseAtmosphericAttenuation
    bool getUseAtmosphericAttenuation() {return m_useAtmosphericAttenuation;}

    // setUseAtmosphericScattering
    void setUseAtmosphericScattering(bool useAtmosphericScattering) {m_useAtmosphericScattering = useAtmosphericScattering;}

    // getUseAtmosphericScattering
    bool getUseAtmosphericScattering() {return m_useAtmosphericScattering;}

    // setUseRoundEarth
    void setUseRoundEarth(bool useRoundEarth) {m_useRoundEarth = useRoundEarth;}

    // getUseRoundEarth
    bool getUseRoundEarth() {return m_useRoundEarth;}

    // setUseODLimit
    void setUseODLimit(bool useODLimit) {m_useODLimit = useODLimit;}

    // getUseODLimit
    bool getUseODLimit() {return m_useODLimit;}



    // getApplyRefraction
    bool getApplyRefraction() {return m_applyRefraction;}

    // setApplyRefraction
    void setApplyRefraction(bool applyRefraction) {m_applyRefraction = applyRefraction;}

    // getConstEratio
    bool getConstEratio() {return m_constEratio;}

    // setConstEratio
    void setConstEratio(bool constEratio) {m_constEratio = constEratio;}

    // getNumAlts
   int getNumAlts()
   {
      return m_numAlt;
   }

    // setNumAlts
   void setNumAlts(int nalts)
   {
      if (nalts < 8) nalts = 8;
      m_numAlt = nalts;
   }

    // getPowAlt
   double getPowAlt()
   {
      return m_powAlt;
   }

    // setPowAlt
   void setPowAlt(double palt)
   {
      if (palt < 1.0E-15) palt = 1.0E-15;
      m_powAlt = palt;
   }

    // getNumRanges
   int getNumRanges()
   {
      return m_numRange;
   }

    // setNumRanges
   void setNumRanges(int nranges)
   {
      if (nranges < 8) nranges = 8;
      m_numRange = nranges;
   }

    // getPowRange
   double getPowRange()
   {
      return m_powRange;
   }

    // setPowRange
   void setPowRange(double prange)
   {
      if (prange < 1.0E-15) prange = 1.0E-15;
      m_powRange = prange;
   }

    // getPowDensity
   double getPowDensity()
   {
      return m_powDensity;
   }

    // setPowDensity
   void setPowDensity(double pdense)
   {
      if (pdense < 1.0E-15) pdense = 1.0E-15;
      m_powDensity = pdense;
   }

   //setLUTPrecomputationRange
   void setLUTPrecomputationRange(bool lut_precomp_enable, double lut_tod_start, double lut_tod_end, double lut_tod_interval)
   {
      if (lut_tod_interval < 1.0 / 60.0) lut_tod_interval = 1.0 / 60.0;
      m_lut_precomp_enable = lut_precomp_enable;
      m_lut_tod_start = fmod(lut_tod_start, DIURNAL);
      m_lut_tod_end = fmod(lut_tod_end, DIURNAL);
      m_lut_tod_interval = lut_tod_interval;
   }

   //getLUTPrecomputationRange
   void getLUTPrecomputationRange(bool &lut_precomp_enable, double &lut_tod_start, double &lut_tod_end, double &lut_tod_interval)
   {
      lut_precomp_enable = m_lut_precomp_enable;
      lut_tod_start = m_lut_tod_start;
      lut_tod_end = m_lut_tod_end;
      lut_tod_interval = m_lut_tod_interval;
   }


    // setUseAtmosphericMultiScattering
    void setUseAtmosphericMultiScattering(bool useAtmosphericMultiScattering) {m_useAtmosphericMultiScattering = useAtmosphericMultiScattering;}

    // getUseAtmosphericMultiScattering
    bool getUseAtmosphericMultiScattering() {return m_useAtmosphericMultiScattering;}

    // setUseOriginalCode
    void setUseOriginalCode(bool useOriginalCode) {m_useOriginalCode = useOriginalCode;}

    // getUseOriginalCode
    bool getUseOriginalCode() {return m_useOriginalCode;}

    // setUseModRad
    void setUseModRad(bool useModRad) {m_useModRad = useModRad;}

    // getUseModRad
    bool getUseModRad() {return m_useModRad;}

    // setUseBNNATM
    void setUseBNNATM(bool useBNNATM) {m_useBNNATM = useBNNATM;}

    // getUseBNNATM
    bool getUseBNNATM() {return m_useBNNATM;}


    // setUseFastEnvCache
    void setUseFastEnvCache(bool useFastEnvCache) {m_useFastEnvCache = useFastEnvCache;}

    // getUseFastEnvCache
    bool getUseFastEnvCache() {return m_useFastEnvCache;}

    // setUseThermalEmission
    void setUseThermalEmission(bool useThermalEmission) {m_useThermalEmission = useThermalEmission;}

    // getUseThermalEmission
    bool getUseThermalEmission() {return m_useThermalEmission;}

    // setEnableLighting
    void setEnableLighting(bool enableLighting) {m_enableLighting = enableLighting;}

    // getEnableLighting
    bool getEnableLighting() {return m_enableLighting;}

    // setUserSpecifiedAtmFilepath
    void setUserSpecifiedAtmFilepath(char *userSpecifiedAtmFilepath){strcpy(m_userSpecifiedAtmFilepath, userSpecifiedAtmFilepath);}

    // getUserSpecifiedAtmFilepath
    char *getUserSpecifiedAtmFilepath(){return m_userSpecifiedAtmFilepath;}

    // setUserSpecifiedTaMin
    void  setUserSpecifiedTaMin(double tempMin){m_tempMin = (float) tempMin;}

    // setUserSpecifiedTaMax
    void  setUserSpecifiedTaMax(double tempMax){m_tempMax = (float) tempMax;}

    // getUserSpecifiedTaMin
    double  getUserSpecifiedTaMin(){return m_tempMin;}

    // setUserSpecifiedTaMax
    double  getUserSpecifiedTaMax(){return m_tempMax;}

    // setSkyDomeRadius
    void  setSkyDomeRadius(double radius){m_skydomeRadius = radius;}

    // getSkyDomeRadius
    double  getSkyDomeRadius(){  return m_skydomeRadius;}

    //setAtmExtinction
    void setAtmExtinction(double extinction){m_atmExtinction = extinction;}
    //getAtmExtinction
    double  getAtmExtinction(){return m_atmExtinction;}
    //getRainRate
    double  getRainRate(){return m_rainRate;}
    //setRainRate
    void setRainRate(double rate){m_rainRate = rate;}
    //getRainTemp
    double  getRainTemp(){return m_rainTemp;}
    //setRainTemp
    void setRainTemp(double temp){m_rainTemp = temp;}
    //getRelativeHumidityRatio
    double  getRelativeHumidityRatio(){return m_humidityRatio;}
    //setRelativeHumidityRatio
    void setRelativeHumidityRatio(double ratio){m_humidityRatio = ratio;}


    void setLogScale(bool flag){m_logScale = flag;}
    bool getLogScale(){return m_logScale;}
    void setMouseVel(double vel){m_mouseVel = vel;}
    double getMouseVel(){return m_mouseVel;}
    void setTime(float time){m_timeOfDay = time;}
    float getTime(){return m_timeOfDay;}

private: // parts, variables, and other neat stuff...

    int     m_dateMonth,               
         m_dateDay,                 
         m_dateYear;                
    float   m_timeOfDay;               
    char m_nightSkyTableFilepath[512]; 
    char m_bathymetryTableFilepath[512];  
   char  m_mmlsTableFilepath[512];     
    int     m_atmModel;                
    int     m_hazeModel;               
   int      m_cldModel;                
   int      m_novamModel;              
    double  m_windVelocity;               
   double   m_windDirection;           
   double   m_visibility;              
    bool m_useAtmosphericAttenuation;  
    bool m_useAtmosphericScattering;      
    bool m_useThermalEmission;         
    bool m_enableLighting;          
    char m_userSpecifiedAtmFilepath[512];
    float   m_tempMin;                 
    float   m_tempMax;                 
    double  m_skydomeRadius;           
    bool m_logScale;
    double  m_mouseVel;
    bool m_useAtmosphericMultiScattering;
   bool  m_useOriginalCode;
   bool  m_useModRad;
   bool  m_useBNNATM;
   bool  m_useFastEnvCache;
    bool m_useRoundEarth;
   bool  m_useODLimit;
   bool  m_applyRefraction;
   bool  m_constEratio;
    double  m_starThreshold;
    double  m_atmOffset;               // unused now.
    double  m_atmExtinction;
    double  m_rainRate;
    double  m_rainTemp;
   double  m_humidityRatio;
   int      m_numAlt;
   double   m_powAlt;
   int      m_numRange;
   double   m_powRange;
   double  m_powDensity;
   bool  m_lut_precomp_enable;
   double  m_lut_tod_start;
   double  m_lut_tod_end;
   double  m_lut_tod_interval;
    clXMLNode* m_parentNode;
};

#endif   // _ciEnvironment_h_