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"

// 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:


    //   ssAtmosphericTable
    ssAtmosphericTable();

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

    //makeSensorAtmosphericData
    void makeSensorAtmosphericData();

    //makeLightSourceData
    void makeLightSourceData();

    //makeLightSourceDataSigSim
    void makeLightSourceDataSigSim();

    //updateSunDiskRadiance
    void updateSunDiskRadiance();

    //updateMoonDiskRadiance
    void updateMoonDiskRadiance();

    //updateManMadeLightData
    void updateManMadeLightData();

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

    //getNumberTextureRanges
    unsigned int getNumberTextureRanges();

    //setNumberTextureRanges
    void setNumberTextureRanges(unsigned int ranges);

    //getMaxRange
    double getMaxRange();

    //setMaxRange
    void setMaxRange(double max);

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

    //getMaxRadiance
    double getMaxRadiance();

    //getUpdateTime
    JRMTIME getUpdateTime();

    //setUpdateTime
    void setUpdateTime(JRMTIME time);

    //timeChanged
    bool timeChanged(JRMTIME time);

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

    //*getDiffuseLightSourceData
    double *getDiffuseLightSourceData(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);


    //computeDiffuseSolarLunar
    void computeDiffuseSolarLunar(double altitude);

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

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

    //isDirty
    bool isDirty();

    //setDirty
    void setDirty();

    //clrDirty
    void clrDirty();


   /* -------------------------------------  START MODIFIED BRUNETON & NEYRET ATM LUT CODE ------------------------------ */

   // ssAtmosphericTable::BNgetUr
   //
   // description: Converts alt[m] to unitless Ur index.
   //
   // int n increases sampling at low altitude
   //
   double BNgetUr(double alt_m, double n);

   // ssAtmosphericTable::BNgetAlt
   //
   // description: Converts unitless Ur parameter to alt[m].
   //
   // int n increases sampling at low altitude
   //
   double BNgetAlt(double Ur, double n);


   // ssAtmosphericTable::BNgetUmu
   //
   // description: Converts {alt[m], mu[unitless]} to unitless Umu index.
   //
   // int n increases sampling away from horizon
   //
   double BNgetUmu(double alt_m, double mu, double n);

   // ssAtmosphericTable::BNgetMu
   //
   // description: Converts {alt[m], Umu[unitless]} to Mu[unitless] dot product of zenith and look angle.
   //
   // int n increases sampling away from horizon
   //
   double BNgetMu(double alt_m, double Umu, double n);


   // ssAtmosphericTable::BNgetUmus
   //
   // description: Converts mu_s[unitless] to unitless Umus index.
   //
   //
   //
   double BNgetUmus(double mu_s);

   // ssAtmosphericTable::BNgetMus
   //
   // description: Converts unitless Umus parameter to mu_s[unitless] dot product of zenith and sun vec.
   //
   //
   //
   double BNgetMus(double Umus);

#if 0 // These versions assume v = dot(source, view).  Shader must correspond!

   // ssAtmosphericTable::BNgetUv
   //
   // description: Converts v[unitless] to unitless Uv index.
   //
   // int n increases sampling around v=1
   //
   double BNgetUv(double v, double mu, double mus, int n);
   
   // ssAtmosphericTable::BNgetV
   //
   // description: Converts unitless Uv parameter to v[unitless] dot product of look dir and sun vec.
   //
   // int n increases sampling around v=1
   //
   double BNgetV(double Uv, double mu, double mus, int n);

#else // These versions assume v = dot(source_xy_projection, view_xy_projection).  Shader must correspond!

   // ssAtmosphericTable::BNgetUv
   //
   // description: Converts v[unitless] to unitless Uv index.
   //
   // int n increases sampling around v=1
   //
   double BNgetUv(double v, double n);
   
   // ssAtmosphericTable::BNgetV
   //
   // description: Converts unitless Uv parameter to v[unitless] dot product of (look dir)_xy and (sun vec)_xy.
   //
   // int n increases sampling around v=1
   //
   double BNgetV(double Uv, double n);
#endif

   // ssAtmosphericTable::BNgetLook
   //
   // description: Computes look direction from {sourcevec, viewdotsource, viewdotup}.
   //
   //
   //
   VECTOR BNgetLook(VECTOR source, double viewdotsource, double viewdotup);

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

   //*getXmitData
   float *getXmitData();

   //*getPradData
   float *getPradData();

   //*getSradData
   float *getSradData();

   //*getMradData
   float *getMradData();

   //*getMaxOptDepth
   float *getMaxOptDepth();

   //setOriginalCode
   void setOriginalCode(bool onoff);

   //getOriginalCode
   bool getOriginalCode();

   //setMBNATM
   void setMBNATM(bool onoff);

   //getMBNATM
   bool getMBNATM();

   /* -------------------------------------  END MODIFIED BRUNETON & NEYRET ATM LUT CODE ------------------------------ */


private:

   void FreeArrays();


    //getLayer
    int getLayer(double alt);

    //getAltitudeSample
    double getAltitudeSample(int layer, int sample);

    //getDataIndex
    void getDataIndex(double alt, int layer, unsigned int &index);

    //getDataIndexFract
    void getDataIndexFract(double alt, int layer, unsigned int &index, double &fract);


    //makeSensorAltAtmData
    void makeSensorAltAtmData(double sensorAlt, float*AtmData, double *polarData);

    //initAtmosphericData
    void initAtmosphericData();

    //convertMetinToSensor
    void convertMetinToSensor();

    //getSingleScattering
    void getSingleScattering(double objAltitude, double *sourceTOA, double *scatData);

   // ssAtmosphericTable::fillMultipleScattering
   //
   // description: get the array of multiple scattering irradiance 
   //
   // source VECTOR 
   // sourceTOA [W/m2/um]
   // rangeFactor [unitless]
   // sourceRange [m]
   // sourceAlt [m]
   // downwell, upwell [W/m2/um] : pointers to metin arrays to hold total scattered irradiances for the irradiance LUTs. We add the MS contribution to them here.
   void fillMultipleScattering(VECTOR source, double *sourceTOA, double rangeFactor, double sourceRange, double sourceAlt, bool includeStars);

    //getAmbientScattering
    void getAmbientScattering(double objAltitude, VECTOR source, double *objMultiScatData, double *metinAmbientDownwelling, double *metinAmbientUpwelling);

    unsigned int m_numSensorWaveLengths;
    unsigned int m_numMetinWaveLengths;
    unsigned int m_numberLayers;
    unsigned int m_numSamplesPerLayer;
    unsigned int m_numObjectAngles;
    unsigned int m_numObjectAltitudes;
    unsigned int m_numSensorAltitudes;
    unsigned int m_numberTextureRanges;
    unsigned int m_numberScatAngles;

    double m_maxAltitude; // [m]
    double m_maxRange;    // [m]

    float *m_spectralAtmosphericData;       // comp0 = [1/m^(1/2)] the sqrt of density, comp1 = [unitless] scaled pathrad, comp2 = [unitless] scaled scatrad difference, comp3 = [unitless] log-scaled scatrad midvalue. 
    ssBuffer<float> m_passbandAtmosphericData;       // // comp0 = [1/m^(1/2)] the sqrt of density, comp1 = [unitless] scaled pathrad, comp2 = [unitless] scaled scatrad difference, comp3 = [unitless] log-scaled scatrad midvalue. 
    double *m_ambientLightSource;           // [W/cm2/sr] Sum of downwell & upwell diffuse. index < m_numSensorWaveLengths * m_numObjectAltitudes
   double *m_downwellLightSource;         // [W/cm2/sr] Downwelling diffuse.           index < m_numSensorWaveLengths * m_numObjectAltitudes
   double *m_upwellLightSource;        // [W/cm2/sr] Upwelling diffuse.          index < m_numSensorWaveLengths * m_numObjectAltitudes
    double *m_diffuseLightSource;           // [W/cm2/sr] Really Direct, not diffuse.     index < m_numSensorWaveLengths * m_numObjectAltitudes

    ssBuffer<float> m_lightSourceData;               // [W/cm2/sr] : comp0 = [unitless] scaled ambient radiance, comp1 = [unitless] scaled directional diffuse radiance, comp2 = scaled directional radiance, comp3 = scaled upwelling earthshine radiance, comp4 = [unitless] scaled downwelling radiance

    int m_numberComponents;

/* ------START MODIFIED BRUNETON & NEYRET ATM LUT  ----*/
   float *m_xmitData;      // [unitless] Modified B&N transmission  : index =  m_numSensorWaveLengths * (objectAngleIndex + m_numObjectAngles * sensorAltIndex) + sensorWavelengthIndex;
   float *m_pradData;      // [unitless] Modified B&N pathrad+MS    : index =  m_numSensorWaveLengths * (objectAngleIndex + m_numObjectAngles * sensorAltIndex) + sensorWavelengthIndex;
   float *m_sradData;      // [unitless] Modified B&N singlescatrad : index =  m_numSensorWaveLengths * (scatAngleIndex + m_numberScatAngles * (objectAngleIndex + m_numObjectAngles * sensorAltIndex)) + sensorWavelengthIndex;
   float *m_mradData;      // [unitless] Modified B&N singlescatrad : index =  m_numSensorWaveLengths * (scatAngleIndex + m_numberScatAngles * (objectAngleIndex + m_numObjectAngles * sensorAltIndex)) + sensorWavelengthIndex;
   float *m_maxOptDepth;   // [unitless] Max optical depth encountered while building the ATM LUT. : index = sensorWavelengthIndex.
/* ------END MODIFIED BRUNETON & NEYRET ATM LUT  ----*/

   double *m_objAlt;
   double *m_sensAlt;
   double *m_range;

    bool m_useSun;
    bool m_useBothSunMoon;
    double m_sensorAltitude;        // [m]
    bool m_spectralMode;
    bool m_atmEnable;
    bool m_scatterEnable;
    bool m_multiScatterEnable;
    bool m_roundEarth;
    double m_maxRadiance;     // [W/cm2/sr] according to ssSensor::recomputeMinMaxRadiance() 
    JRMTIME m_updateTime;

    METIN *m_metin;
    ssSensor *m_sensor;

    double *m_metinTrans;            // [unitless]
    double *m_metinAbsorbTrans;      // [unitless]
    double *m_metinPathRad;          // [W/cm2/sr/um]       
    double *m_metinScatter;          // [W/cm2/sr/um] index < m_numMetinWavelengths * m_numberScatAngles
    double *m_metinMultiScat;        // [W/cm2/sr/um]  

   // sensor-specific atmospherics : index < m_numSensorWavelengths
    double *m_sensorTrans;           // [unitless]       
    double *m_sensorAbsorbTrans;     // [unitless]
    double *m_sensorPathRad;         // [W/cm2/sr/um]
    double *m_sensorScatter;         // [W/cm2/sr/um] index < m_numSensorWavelengths * m_numberScatAngles
    double *m_sensorMultiScat;       // [W/cm2/sr/um]  

    double *m_altitude;             // [m] according to ssAtmosphericTable::initializeAtm
    double *m_scatAngles;           // [unitless cosine]
    double *m_objectScatData;       // [W/m3/sr/um] index = scatangleindex + (m_numberScatAngles * (wavelengthindex + m_numMetinWaveLengths * objaltindex))
    double *m_objAmbientUpwelling;     // [W/m2/um]
    double *m_objAmbientDownwelling;   // [W/m2/um] according to ssAtmosphericTable::makeScatteringData  
   ssBuffer<float> m_mmLightData;           // [unitless] scaled sensor spectral radiance
    float *m_sunDiskData;           // [unitless] scaled sensor spectral radiance 
    float *m_moonDiskData;          // [unitless] scaled sensor spectral radiance

    int m_startIndex;
    int m_endIndex;
    double m_ax;                    // [um]
    double m_bx;                    // [um]        

    float m_atmExtinctionScale;     // [unitless]

    float m_atmAmbientLightScale;   // [unitless] according to getAmbientScattering

    float m_atmSkyScale;         // [unitless]

    double m_fogRatio;              // [unitless]

    // flag to indicate that incremental paths are being traversed.
    bool m_incremental;

    bool m_dirty;


   bool m_OriginalCode; // Reproduces code as of Sept. 2012
   bool m_MBNATM;       // if(m_OriginalCode==false), this flag turns on the Modified B&N atmospheric LUT processing.
};


#endif