ssObject.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004 - 2012
// 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:     Eric Olson     Date: May 2004

#ifndef _ssObject_
#define _ssObject_

#include "ssIncAll.h"
#include "atm_common.h"
#include "Objects.h"

#include "ssdllexport.h"
#include "ssMaterialSet.h"

#include <memory>

#define DIRTY_VELDIF_MPS 1.0
#define DIRTY_ALTDIF_M 1000.0
#define HFT_DTMIN 0.0001


// class: ssObject
class SIGSIMRT_API ssObject 
{
public:
    typedef enum
    {
        ORIGINAL_PHONG=0,  
        SR,
      BECKMANN,
      PHONG
    } ObjectBrdfEnum;


    //   ssObject
    ssObject();

    //~ssObject
    virtual ~ssObject();

    //getThermalSpinUpTime
    double getThermalSpinUpTime();

    //setThermalSpinUpTime
    bool setThermalSpinUpTime(double hours);

    //*getResponseData
    float *getResponseData(ssSensor *sensor, unsigned int &numMaterials, unsigned int &numBins, unsigned int &numParameters);
    //*getSandfordRobertsonResponseData
    float *getSandfordRobertsonResponseData(ssSensor *sensor, unsigned int &numMaterials, unsigned int &numBins, unsigned int &numParameters);

    // getVisualdata
    float *getVisualData(unsigned int &numMaterials, ssSensor *sensor);

    //getMaterialResponse
    void getMaterialResponse(ssSensor *sensor, unsigned int matCode,
        float &ambient, float &emission, float &cosEmission);

    //getNumberResponses
    unsigned int getNumberResponses();

    // getNumberResponseValues
    //
    unsigned int getNumberResponseValues();

    //getNumberMaterials
    unsigned int getNumberMaterials();

   //*getObjectType
   int getObjectType();

   //setObjectType
   void setObjectType(const int type);

    //*getName
    char *getName();

    //setName
    void setName(const char *name);

    //getUniqueID
    int getUniqueID();

    //setUniqueID
    bool setUniqueID(int id);

    //*setFullResponseEnable
    void setFullResponseEnable(bool flag);

    //*getFullResponseEnable
    bool getFullResponseEnable();

    //*setIncludeEmissivity
    void setIncludeEmissivity(bool flag);

    //*getIncludeEmissivity
    bool getIncludeEmissivity();

   //setGeomFileName
   void setGeometryFileName(char *name);

   //getGeomFileName
   char *getGeometryFileName();


    //setMaterialSystemFileName
    void setMaterialSystemFileName(char *name);

    //getMaterialSystemFileName
    char *getMaterialSystemFileName();

    //setSCfilename
    void setSCfilename(char *name);

    //getSCfilename
    char *getSCfilename();

    //setRCSfilename
    void setRCSfilename(char *name);

    //getRCSfilename
    char *getRCSfilename();

    //setPIPfilename
    void setPIPfilename(char *name = NULL);

    //getPIPfilename
    char *getPIPfilename();

    //setMSICfilename
    void setMSICfilename(char *name = NULL);

    //getMSICfilename
    char *getMSICfilename();

    //setSmokeMaterialSystemFileName
    void setSmokeMaterialSystemFileName(char *name);

    //getSmokeMaterialSystemFileName
    char *getSmokeMaterialSystemFileName();

    //setSmokeGeomFileName
    void setSmokeGeometryFileName(char *name);

    //getSmokeGeomFileName
    char *getSmokeGeometryFileName();

    //setSmokePIPfilename
    void setSmokePIPfilename(char *name = NULL);

    //getSmokePIPfilename
    char *getSmokePIPfilename();

    //setTrackFileName
    void setTrackFileName(char *name);

    //getTrackFileName
    char *getTrackFileName();

    //setIndex
    void setIndex(int i);
    //getIndex
    int getIndex();

    //*setMaterialSet
    void setMaterialSet(const std::shared_ptr<ssMaterialSet>& set);

   //*getMaterialSet
   ssMaterialSet* getMaterialSet() const;

   //*getMaterialSetPtr
   std::shared_ptr<ssMaterialSet> getMaterialSetPtr() const;

    //setGeocentricLocation
    void setGeocentricLocation(
        double x, 
        double y, 
        double z);

    //getGeocentricLocation
    void getGeocentricLocation(
        double &x, 
        double &y, 
        double &z);

    //setGeodeticLocation
    void setGeodeticLocation(
        double lat, 
        double lon, 
        double alt);

    //getGeodeticLocation
    void getGeodeticLocation(
        double &lat, 
        double &lon, 
        double &alt);

    //setOrientation
    void setOrientation(
        double h, 
        double p, 
        double r);

    //getOrientation
    void getOrientation(
        double &h, 
        double &p, 
        double &r);


    //setLinearVelocity
    void setLinearVelocity(double e, 
        double n, 
        double u);

    //getLinearVelocity
    void getLinearVelocity(double &e, 
        double &n, 
        double &u);

    //setLinearAcceleration
    void setLinearAcceleration(double e, 
        double n, 
        double u);

    //getLinearAcceleration
    void getLinearAcceleration(double &e, 
        double &n, 
        double &u);

    //setAngularVelocity
    void setAngularVelocity(double e, 
        double n, 
        double u);

    //getAngularVelocity
    void getAngularVelocity(double &e, 
        double &n, 
        double &u);

    //setAngularAcceleration
    void setAngularAcceleration(double e, 
        double n, 
        double u);

    //getAngularAcceleration
    void getAngularAcceleration(double &e, 
        double &n, 
        double &u);

   void setTimeActivated(double time = 0.0);

   double getTimeActivated(void);

   void setHFTTimeLastUpdated(double time);

   double getHFTTimeLastUpdated(void);

   void setHFTTimeLLoaded(double time);

   double getHFTTimeLoaded(void);

   void ResetHFT();

   bool LoadHFTFile(char *infile, double current);

   void UpdateHFT(double current, double dwell_secs = UPLIM);



    // setTrack
    void setTrack(TRACK *track, int numTracks);

    // setTrackfileUpdate
    void setTrackfileUpdate(double simTime, ::ellipsoid *ellipsoid);

   
   ssObject *getPtr();

   
    //*getObjectPtr
    OBJECT *getObjectPtr();

    //thermalSpinUp
    bool thermalSpinUp(ssEnvironment *env);

    //isEmatType
    bool isEmatType() ;

    //setEmatType
    void setEmatType(bool flag);

    //initialize
    bool initialize(char *dataDir = NULL);

    // update
    bool update(ssEnvironment *env);

#ifdef _SIGSIM_RADAR_H_

    // loadSCFile
    bool loadSCFile();

    // loadRCSFile
    bool loadRCSFile();

    // getRCS
    double getRCS(ssSensor *sensor, ssEnvironment *env);

    //ReturnSCVArray
   int ReturnSCVArray(ssSensor *curSensor, double freq, double Cel, double Caz, int *ncenters, std::vector<SCATTER_VECTOR_CENTER>& svc);
   int ReturnSCVArray(ssSensor *curSensor, double freq, double Cel, double Caz, int *ncenters, SCATTER_VECTOR_CENTER **svc);

#endif // _SIGSIM_RADAR_H_

#ifdef _GFE_NRT_

   // getScaledPlumeSpectralSignature
   //
   // description: Retrieves (dynamic-range scaled) sensor band value for emission along the centerline LOS from end to end of the plume.
   //
   // parameter : ssSensor pointer corresponding to desired sensor band,
   //          ssEnvironment pointer whose metin->inf.spectrum must be the same as used in ssObject::update()!!!
   //
   //
   float * getScaledPlumeSpectralSignature(int &numSensorWaveLengths, int &reponseWidth, ssSensor *sensor);
#endif

#ifdef _PARTICLES_H_

    // getScaledEffectBandSignature
    bool getScaledEffectBandSignature(double &emission, double &reflectivity, double &alpha, int &processpath, ssEnvironment *env, ssSensor *sensor);

    // getScaledEffectSpectralSignature
    float *getScaledEffectSpectralSignature(int &processpath, int &numSensorWaveLengths, int &reponseWidth, ssEnvironment *env, ssSensor *sensor);

    // updateVisibleScaledEffectBandSignature
    void updateVisibleScaledEffectBandSignature(ssEnvironment *env);

    // getVisibleScaledEffectBandSignature
    void getVisibleScaledEffectBandSignature(double &emission, double &reflectivity, double &alpha);

    // setVisibleScaledEffectBandSignature
    void setVisibleScaledEffectBandSignature(double emission, double reflectivity, double alpha);
#endif

#ifdef _CTDR_CPDR_H_

    //* getPlumeRadianceMap
    PLUME_RADIANCE_MAP *getPlumeRadianceMap();
#endif


    // copyIntrinsicParams
    void copyIntrinsicParams(ssObject *from);


    // setIsDirty
    void setIsDirty(bool flag);

    // isDirty
    bool isDirty();

    //setWorldLocation
    void setWorldLocation(double x, double y, double z);

    //getWorldLocation
    void getWorldLocation(double& x, double& y, double& z);

    // Method for querying the state of whether this object is a flare or not
    bool isFlareObject() const
    {
        return m_isFlare;
    }

    // Methods for per object, material system independent, intensity modification
    void setObjectIntensityFactor( float intensity )
    {
        m_intensityFactor = intensity;
    }

    float getObjectIntensityFactor() const
    {
        return m_intensityFactor;
    }

    // Methods for SR support
    void setBrdf (ObjectBrdfEnum v);
    ObjectBrdfEnum getBrdf ();
    void setRoughness (float r);
    float getRoughness ();

   /* -------------- BEGIN SILVERLINING SUPPORT ----------------- */

   typedef enum
   {
      NONE = -1,
      CIRROCUMULUS=0,
      CIRRUS_FIBRATUS,
      STRATUS,
      CUMULUS_MEDIOCRIS,
      CUMULUS_CONGESTUS,
      CUMULUS_CONGESTUS_HI_RES,
      CUMULONIMBUS_CAPPILATUS,
      STRATOCUMULUS,
      TOWERING_CUMULUS
   }  SL_CLOUD_TYPE;

    // Category
    typedef enum
    {
        defaultCategory = 0,
        clouds,
        specialeffect,
        diguy,
        water,
        speedtree,
      rdg,
        ship,
        aircraft,
      storm,
      plume,
      embedk,
      pointsource,
      emsig
    } Category;


   typedef struct
   {
      SL_CLOUD_TYPE  type;       // [enum] SL CLOUD TYPE
      double         basealt_m;     // [m] Base Altitude
      double         extent_m;      // [m] Horizontal Extent
      double         thickness_m;   // [m] Vertical Thickness
      double         coverage;      // [unitless 0-1] Cloud Coverage Fraction (maps to SL "density")
      ATM_VOL_PROPS  atm;        // [ATM_VOL_PROPS] Spectral array of extinction, scattering, and thermal emission params computed from ssEnvironment::ProcessSL_CLOUD() (over metin.inf.spectrum).
      double         *emission;     // [W/cm2/sr/um] Emission spectral array (over metin.inf.spectrum)
      double         *reflectivity; // [unitless] Reflectivity spectral array (over metin.inf.spectrum)
      double         *alpha;        // [unitless] Alpha spectral array (over metin.inf.spectrum)
      double         *g1;        // [unitless] HG asymmetry #1
      double         *g2;        // [unitless] HG asymmetry #2
      double         *f;            // [unitless] HG mixing parameter s.t. PH(x) = f * HG(g1,x) + (1-f) * HG(g2,x).
      double         simulationTime; // [seconds] SensorRender's simulation clock the last time SkyDrawable::updateSL_CLOUD()
      int            handle;        // [cardinal] SilverLining cloud handle
   }  SL_CLOUD;

   // ProcessSL_CLOUD 
   // Processes main signature components for SilverLining cloud type
   int ProcessSL_CLOUD(ssEnvironment *env, double H2O_density_gpm3, double voxdim_m);

   // getSL_CLOUD 
   // Gets pointer to SilverLining cloud
   SL_CLOUD *getSL_CLOUD(void);

   // FreeSL_CLOUDArrays
   // Frees pointers inside SilverLining cloud
   // If init=true, just performs NULLification.
   void FreeSL_CLOUDArrays(bool init);

   // AllocateSL_CLOUDArrays
   // Allocates spectral arrays inside SilverLining cloud
   int AllocateSL_CLOUDArrays(long nlambda);

   // getSL_CLOUDPassbandSignature
   // Assumes ProcessSL_CLOUD is performed first!
   // Outputs the following quantities:
   // emission [unitless 0-1] : Emission integrated over sensor's passband and scaled by sensor's dynamic range.
   // reflectivity [unitless 0-1] : Reflectivity averaged over sensor's passband.
   // alpha [unitless 0-1] : Alpha = (1 - transmission), averaged over sensor's passband.
   // g1 [unitless -1->1] : Equivalent Henyey-Greenstein asymmetry parameter #1, averaged over sensor's passband.
   // g2 [unitless -1->1] : Equivalent Henyey-Greenstein asymmetry parameter #2, averaged over sensor's passband.
   // f [unitless 0-1] : Equivalent mixing factor for HG functions [f*HG(g1)+(1-f)*HG(g2)], averaged over sensor's passband.
   int getSL_CLOUDPassbandSignature(ssSensor *sensor, ssEnvironment *env, double &emission, double &reflectivity, double &alpha, double &g1, double &g2, double &f);

   void setSLCloudGeometry(SL_CLOUD_TYPE type, double basealt_m, double thickness_m, double extent_m, double coverage);
   int getSLCloudGeometry(SL_CLOUD_TYPE &type, double &basealt_m, double &thickness_m, double &extent_m, double &coverage);

#ifdef _GFE_NRT_
   void setST_CONTEXT_TEMPLATE(ST_CONTEXT_TEMPLATE st);
   ST_CONTEXT_TEMPLATE * getST_CONTEXT_TEMPLATE();
#endif

   Category getCategory();
    void setCategory(Category category);

   // Offsets due to ship motion in sea state, but could also be used for other sources of turbulence.
   void setOffsetTranslation(double X, double Y, double Z);
   void getOffsetTranslation(double &X, double &Y, double &Z);
   void setOffsetOrientation(double yaw, double pitch, double roll);
   void getOffsetOrientation(double &yaw, double &pitch, double &roll);
   // ------------------------------


   /* -------------- END SILVERLINING SUPPORT ----------------- */

protected:
    bool m_isFlare;

private:

    virtual void updateInternal(ssEnvironment *env, bool forceUpdate);

    //setObjectPtr
    void setObjectPtr(OBJECT *objectPtr);

    int m_index;

    int m_id;
   std::shared_ptr<ssMaterialSet> m_materialSet;

    OBJECT *m_objectPtr;
    bool m_objectPtr_alloc;

    char m_trackFileName[SIGSIM_STRING_SIZE];
    char m_materialSystemFileName[SIGSIM_STRING_SIZE];

    char m_dataDirectory[SIGSIM_STRING_SIZE];
   char m_geometryFilename[SIGSIM_STRING_SIZE];
    char m_rcsFilename[SIGSIM_STRING_SIZE];
    char m_scFilename[SIGSIM_STRING_SIZE];
    char m_pipFilename[SIGSIM_STRING_SIZE];
    char m_msicFilename[SIGSIM_STRING_SIZE];
    char m_smokeGeometryFileName[SIGSIM_STRING_SIZE];
    char m_smokeMaterialSystemFileName[SIGSIM_STRING_SIZE];
    char m_smokePipFilename[SIGSIM_STRING_SIZE];

    double m_thermalSpinUp;
    bool m_fullResponseEnable;
    bool m_includeEmissivity;
    // For generating the unique id
    bool m_ematType;

   double m_visAlpha;
   double m_visReflectivity;
   double m_visEmission;

   bool m_isDirty;

   double m_worldXCoord; 
   double m_worldYCoord; 
   double m_worldZCoord; 


   // Offsets due to ship motion in sea state, but could also be used for other sources of turbulence.
   double m_offsetTranslationX;     // [m]
   double m_offsetTranslationY;     // [m]
   double m_offsetTranslationZ;     // [m]
   double m_offsetOrientationYaw;      // [rad]
   double m_offsetOrientationPitch; // [rad]
   double m_offsetOrientationRoll;     // [rad]
   // ------------------------------

   // --- HFT and IntensityFactor support ---
    float m_intensityFactor;        // [1] Current at-object signature multiplier
   int m_numHFT;                 // [1] Number of entries in m_HFT array
   float *m_HFT;                 // [1] Array of at-object signature multipliers to be applied
   float m_HFTTimeInterval;         // [s] Scenario Time between m_HFT entries
   double m_HFTLoadTime;            // [s] Scenario Timestamp at which HFT array was loaded/initialized
   double m_HFTLastUpdate;          // [s] Scenario Timestamp at which m_intensityFactor last came from element [i] in m_HFT array
   // ---------------------------------------

   float *m_specialEffectsReponse; 

    ObjectBrdfEnum m_brdf;
    float m_roughness;

   // SILVERLINING SETTINGS
   SL_CLOUD *sl_cloud;

#ifdef _GFE_NRT_
   // GFE-NRT
   ST_CONTEXT_TEMPLATE *st_ct;
#endif

    //object category (default, diguy, sfx, speedtree, water, etc)
    Category m_category;

    static int s_objectId;

    friend class SigSimRT;

};

#endif // _ssObject_