ssAtmosphericTable.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:     Ken George     Date: July 2004

#ifndef _ssAtmosphericTable_
#define _ssAtmosphericTable_


#include "ssSensor.h"
//#include "ssBuffer.h"

#define BNN_MUMODE   2     // [0=Default, 1=Linear, 2=Exponential] Mu sampling mode.  NOTE: Mode 1 is not yet supported in shaders!!!!
#define BNN_VMODE 1     // [0=dot(solar,view), 1=dot(solar_azimuth, view_azimuth)] V-sampling mode.
#define BNN_NR    3.0      // [unitless>=0.001] Increases altitude sampling density at low altitude (All modes)
#define BNN_NMU      5.2      // [unitless>=0.001] Increases mu sampling density away from horizon (Default mu mode only)
#define BNN_NV    2.0      // [unitless>=1] Increases sampling around v=1 (All modes)
#define BNN_NMUSEGS 8      // [>0] Number of segments in linear-mu mode.
#define BNN_RHO0  0.1   // [unitless 0.05-1] is relative sampling density for mu regions away from horizon or source.
#define BNN_RHOH  0.3      // [unitless 0-0.95] is relative sampling density peak for mu region near horizon 
#define BNN_RHOS  0.5      // [unitless 0-0.95] is relative sampling density peak for mu region around source direction
#define BNN_DEVH  0.1      // [unitless 0.01-2] is width of sampling density curve for mu region near horizon
#define BNN_DEVS  0.05  // [unitless 0.01-2] is width of sampling density curve for mu region around source direction

#define MAXFLOAT   65000.0f
#define NUM_IRRLUT_COMPONENTS 5

#ifndef SKYDOME_RANGE
#define SKYDOME_RANGE 1100000.0  /* //195000.0  //!< the skydome range.  See also ciScenario.h and ciEnvironment.h */
#endif

#ifndef REFRACTK
#define REFRACTK 1.0 /* 1.0182 */
#endif

#ifndef SHADER_LOLIM
#define SHADER_LOLIM 1.0E-15
#endif

// class: ssAtmosphericTable
//
// description: class for the sensor atmospheric maps 
//    Note all spectral values are defined by a sensor resolution or metin
//    This class is not part of the API and is accessed thru ssEnvironment.
//
class ssAtmosphericTable
{
public:

   // BNN LUT SETTINGS

   typedef struct
   {
      int mumode;    // [0=Default, 1=Linear, 2=Exponential] Mu sampling mode.
      int vmode;     // [0=dot(solar,view), 1=dot(solar_azimuth, view_azimuth)] V-sampling mode.
      double nr;     // [unitless>=0.001] Increases altitude sampling density at low altitude (All modes)
      double nmu;    // [unitless>=0.001] Increases mu sampling density away from horizon (Default mu mode)
      double nv;     // [unitless>=1] Increases sampling around v=1 (All modes)

      // ------------- PARAMS FOR LINEAR & EXPONENTIAL MU MODES -----------
      int nmusegs;   // [>0] Number of segments in linear-mu mode.
      double rho0;   // [unitless 0.05-1] is relative sampling density for mu regions away from horizon or source.
      double rhoh;   // [unitless 0-0.95] is relative sampling density peak for mu region near horizon 
      double rhos;   // [unitless 0-0.95] is relative sampling density peak for mu region around source direction
      double devh;   // [unitless 0.01-2] is width of sampling density curve for mu region near horizon
      double devs;   // [unitless 0.01-2] is width of sampling density curve for mu region around source direction
   }  BNNLUTPARMS;   // Set of parameters which govern polar ATM LUT sampling.



   // ssAtmosphericTable
   ssAtmosphericTable(ssSensor* sensor);

   //~ssAtmosphericTable
   ~ssAtmosphericTable();

   //initializeAtm
   bool initializeAtm(METIN* metin, ssSensor* sensor);


   //setATMflags
   void setATMflags(bool useSun, bool useBothSunMoon, double sensorAltitude, bool spectralMode, bool atmEnable, bool scatterEnable,
        bool multiScatterEnable, bool roundEarthEnable, bool useODLimit);

   //makeSensorAtmosphericData
   void makeSensorAtmosphericData();
   void makeSensorAtmosphericData2();

   // ssAtmosphericTable::makePolarATMLUTs
   //
   // description: Creates the following tables:
   //          polarXmitData indexed by {sensorAlt, objAngle, wavelength_index} = transmission to maxrange.
   //          polarPradData indexed by {sensorAlt, objAngle, wavelength_index} = thermal and MS path radiance to maxrange.
   //          polarScatData indexed by {sensorAlt, objAngle, viewSourceAzimuth, wavelength_index} = solar + lunar single-scattering radiance to maxrange.
   //          polarMradData indexed by {sensorAlt, objAngle, wavelength_index} = solar + lunar multiple-scattering radiance to maxrange.
   //          sourceAngles and Main Source type (sun, moon) are computed from METIN ephemeris.
   //
   //
   void makePolarATMLUTs();

   //makeLightSourceData
   void makeLightSourceData();

   // ssAtmosphericTable::makeBathymetryData
   //
   // description: Updates the acoustic sea layer data
   //
   void makeBathymetryData();

   // ssAtmosphericTable::makeAcousticPathData
   //
   // description: Updates the acoustic path data
   //
   void makeAcousticPathData();

   // ssAtmosphericTable::substituteRefractionRadiusRatio
   //
   // description: If we are in (passband) radar mode:
   //          1. Add multiple scattering contributions into single scattering data elements 
   //          2. Replace multiple scattering data element with effective earth radius ratio
   //             for given {sensor alt, object alt, ground range} combination.
   //          If constEratio=true, refractive earth radius ratio will be set to 4/3 for all paths.
   //
   void substituteRefractionRadiusRatio(bool constEratio);


   //makeLightSourceDataSigSim
   void makeLightSourceDataSigSim();
   void makeLightSourceDataSigSim2();

   //updateSunDiskRadiance
   void updateSunDiskRadiance();

   //updateMoonDiskRadiance
   void updateMoonDiskRadiance();

   //updateManMadeLightData
   void updateManMadeLightData(bool forceUpdate = false);

   //getAtmospherics
   void getAtmospherics(double sensorAltitude, double objAltitude, double objRange, bool transOnly = false);


   //getNumberWavelengths
   unsigned int getNumberWavelengths();

   //getNumberMetinWavelengths
   unsigned int getNumberMetinWavelengths();

   //getNumberLayers
   unsigned int getNumberLayers();

   //setNumberLayers
   void setNumberLayers(unsigned int layers);

   //getNumberObjectAltitudes
   unsigned int getNumberObjectAltitudes();

   //setNumberObjectAltitudes
   void setNumberObjectAltitudes(unsigned int alts);

   //getNumberObjectAngles
   unsigned int getNumberObjectAngles();

   //setNumberObjectAngles
   void setNumberObjectAngles(unsigned int angles);

   //getNumberSensorAltitudes
   unsigned int getNumberSensorAltitudes();

   //setNumberSensorAltitudes
   void setNumberSensorAltitudes(unsigned int alts);

   //getNumberSamplesPerLayer
   unsigned int getNumberSamplesPerLayer();

   //setNumberSamplesPerLayer
   void setNumberSamplesPerLayer(unsigned int alts);

   //getNumberScatAngles
   unsigned int getNumberScatAngles();

   //setNumberScatAngles
   void setNumberScatAngles(unsigned int angles);

   //getMaxAltitude
   double getMaxAltitude();

   //setMaxAltitude
   void setMaxAltitude(double max);

   //setPowAltitude
   void setPowAltitude(double p);

   //getPowAltitude
   double getPowAltitude();

   //getNumberTextureRanges
   unsigned int getNumberTextureRanges();

   //setNumberTextureRanges
   void setNumberTextureRanges(unsigned int ranges);

   //getMaxRange
   double getMaxRange();

   //setMaxRange
   void setMaxRange(double max);

   //setPowRange
   void setPowRange(double p);

   //getPowRange
   double getPowRange();

   //setPowDensity
   void setPowDensity(double p);

   //getPowDensity
   double getPowDensity();


   //getNumberComponents
   unsigned int getNumberComponents();

   //setUseSun
   void setUseSun(bool flag);

   //getUseSun
   bool getUseSun();

   //setUseBothSunMoon
   void setUseBothSunMoon(bool flag);

   //getUseBothSunMoon
   bool getUseBothSunMoon();

   //getSensorAltitude
   double getSensorAltitude();

   //setSensorAltitude
   void setSensorAltitude(double alt);

   //getSpectralMode
   bool getSpectralMode();

   //getScatterEnable
   bool getScatterEnable();

   //getAtmEnable
   bool getAtmEnable();

   //getMultiScatterEnable
   bool getMultiScatterEnable();

   //getRoundEarth
   bool getRoundEarth();

   //getUseODLimit
   bool getUseODLimit();

   //getMaxRadiance
   double getMaxRadiance();

   //setMaxRadiance
   void setMaxRadiance(double maxRadiance);

   //getUpdateTime
   JRMTIME getUpdateTime();

   //setUpdateTime
   void setUpdateTime(JRMTIME time);

   //timeChanged
   bool timeChanged(JRMTIME time, double buffer_hrs = LOLIM);

   //*getAltitudePtr
   double* getAltitudePtr();

   //*getObjAltPtr
   double* getObjAltPtr();

   //*getSensAltPtr
   double* getSensAltPtr();

   //*getRangePtr
   double* getRangePtr();

   //*getScatAnglePtr
   double* getScatAnglePtr();

   //*getMetinAtmosphericsData
   void getMetinAtmosphericsData(double** Trans, double** AbsorbTrans, double** PathRad, double** ScatRad, double** MScatRad);

   //*getSensorAtmosphericsData
   void getSensorAtmosphericsData(double** Trans, double** AbsorbTrans, double** PathRad, double** ScatRad, double** MScatRad);

   //*getObjectScatData
   double* getObjectScatData();

   //*getObjectAmbientUpwelling
   double* getObjectAmbientUpwelling();

   //*getObjAmbientDownwelling
   double* getObjectAmbientDownwelling();

   //*getAtmosphericData
   float* getAtmosphericData(bool spectralMode);

   //makeScatteringData
    void makeScatteringData(bool useSun = true, bool includeSky = true, bool includeEarth = true, bool includeStars = true);

   //makeScatteringDataSigSim
   int makeScatteringDataSigSim(bool useSun = true, bool includeStars = true);

   //*getAmbientLightSourceData
   double* getAmbientLightSourceData(unsigned int altitude = 0);

   //*getDownwellLightSourceData
   double* getDownwellLightSourceData(unsigned int altitude = 0);

   //*getUpwellLightSourceData
   double* getUpwellLightSourceData(unsigned int altitude = 0);

    //*getDirectLightSourceData
    double *getDirectLightSourceData(unsigned int altitude = 0);

   //*getLightSourceData
   float* getLightSourceData();

   //getSunDiskRadiance
   float* getSunDiskRadiance();

   //getMoonDiskRadiance
   float* getMoonDiskRadiance();

   // getNumberManMadeLights
   // description:  gets the number of man-made light sources
   int getNumberManMadeLights();

   //getManMadeLightData
   float* getManMadeLightData();

   //getIrradiance
   void getIrradiance(double altitude, double* downwellIrradiance, double* upwellIrradiance, double* directIrradiance, bool useSun = true, bool includeSky = true, bool includeEarth = true, bool includeAmbient = true);

   //computeDiffuseIrradiance
   void computeDiffuseIrradiance(double altitude, bool includeSky, bool includeSunMoon, bool includeEarthshine);


   //computeDiffuseSolarLunar
   void computeDiffuseSolarLunar(double altitude);

   void computeDiffuseLightSigSim(double altitude, bool includeSun, bool includeMoon, bool includeSky, bool includeEarth, long startindex, long endindex);


    //computeDiffuseEarthshine
    void computeDiffuseEarthshine(double altitude);


   //computeDiffuseSky
   void computeDiffuseSky(double altitude);

   //setAtmExtinctionScale
   void setAtmExtinctionScale(float scale);

   //getAtmExtinctionScale
   float getAtmExtinctionScale();

   //setAtmAmbientLightScale
   void setAtmAmbientLightScale(float scale);

   //getAtmAmbientLightScale
   float getAtmAmbientLightScale();

   //setAtmSkyScale
   void setAtmSkyScale(float scale);

   //getAtmSkyScale
   float getAtmSkyScale();

   //getRefractiveProfile
   void getRefractiveProfile(double& n0, double& h0);


   //isDirty
   bool isDirty();

   //setDirty
   void setDirty();

   //clrDirty
   void clrDirty();

   //getSensorPtr
   ssSensor* getSensorPtr();

   //setOriginalCode
   void setOriginalCode(bool onoff);

   //getOriginalCode
   bool getOriginalCode();

   //setModRad
   void setModRad(bool onoff);

   //getModRad
   bool getModRad();

   // writeATMLUT
   /*
   * description: Writes the sensor atmospheric data table to disk
   *
   */
   int writeATMLUT(char* cacheDirectory, char* statefile);

   // readATMLUT
   /*
   * description: Reads a sensor atmospheric data table from disk
   *
   */
   int readATMLUT(char* cacheDirectory, char* statefile);

   // rescaleATMLUT
   /*
   * description: Rescales a sensor atmospheric data table in memory
   *
   */
   int rescaleATMLUT(double oldMaxRad, double newMaxRad);

   // writeENVLUT
   //
   // description: Writes the light source irradiance data table to disk
   //
   //
   //
   int writeENVLUT(char* cacheDirectory, char* statefile);

   // ssAtmosphericTable::readENVLUT
   //
   // description: Reads a light source irradiance data table from disk
   //
   //
   //
   int readENVLUT(char* cacheDirectory, char* statefile);

   // ssAtmosphericTable::rescaleENVLUT
   //
   // description: Rescales the light source irradiance data table in memory
   //
   //
   //
   int rescaleENVLUT(double oldMaxRad, double newMaxRad);

   //getLUTTODInterval
   double getLUTTODInterval();

   //setLUTTODInterval

---

Copyright © 2005-2024 MAK Technologies. All Rights Reserved (www.mak.com)