sigsimPhong.h

Go to the documentation of this file.

/*  1998 JRM Technologies, Inc.*/




/***********************************
Copyright JRM Enterprises, Inc. 1998
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.
***********************************/

#ifndef _SIGSIMPHONG_H_
#define _SIGSIMPHONG_H_

#include "JRMlibrary.h"
#include "SigSimDefines.h"
#include "sigsim.h"
#include "sigsimDLLstub.h"


#ifdef __cplusplus
extern "C"
{
#endif



    /* ============================ EOIR-BAND ROUTINES ==================================== */

   // FillPhongParms() checks to see if Phong parameters (params[8-11]) have been set already (contain >0 values). If any are not, sets them using JRM SigSim BRDF values (params[1-3]).
   // FillPhongParms is optional if the material table already has canonical Phong model parameter arrays set, and required otherwise. It translates DHR, %spec, etc. to Phong A,D,S,Shine.
   // FillPhongParms() inputs a nmatls-element MATL_PROP_TABLE array which is assumed to contain valid spectral BRDF parameters in the SigSim Modified Phong Model format.
   // It then converts these parameters (for each wavelength) into canonical Phong Model format (ambient, diffuse, specular, shininess) and writes them back to the mp_table.
   // Also band-averages DHR to determine AND OVERWRITE material solar absorptivity and Lambertian emissivity on disk, if necessary.
   // Inputs:  sigsim_data_dir = string giving path to the main data directory. 
   //       nmatls = number of entries in mp_table array.
   //       mp_table = array of MATL_PROP_TABLEs for which Phong parameters, absorptivities, and Lambertian emissivities should be calculated.
   // Outputs: Modified material files if discrepancies in solar absorptivity or Lambertian emissivity are found.
   // Returns: SIGSIM_MEMORY_ALLOCATION_ERROR if internal wavelength and DHR arrays cannot be allocated.
   //       SIGSIM_FILE_NOT_FOUND if a material file cannot be rewritten.
   //       SIGSIM_SUCCESS upon successful completion.
   SIGSIM_API int FillPhongParms(char *sigsim_data_dir, long nmatls, MATL_PROP_TABLE *mp_table);
   SIGSIM_API void ValidateBRDFParams(MATL_PROP_TABLE *mp_table);


   // Ltotal() calculates Reflected Radiance into View direction based on an illuminating Radiance of the form  
   // L_in = Edif/PI + Edir * delta-function(Vdir) = Ldif + Ldir. That is, a flux density Edif assumed purely isotropic plus         
   // a flux density Edir assumed purely directional in a Cartesian sense (plane wave) in direction -Vdir.             
   // The relevant inputs for specifying the incoming flux are then Edif, Edir, and the source VECTOR Vdir.            
   // Now, for a given ARBITRARY incoming direction, the differential amount of flux density (per solid angle)         
   // which hits a unit area dA on the surface (whose normal is the VECTOR Norm, also an input) and which is           
   // reflected into a solid angle at VECTOR View is dOmega cos(theta) L_in * Rho(Omega, View), which then             
   // must be integrated over all possible incoming angles dOmega, where Rho is the BRDF, specified by the following   
   // inputs: DHR,  pct_spec (w.r.t DHR), width of specular lobe, and the ref_angle at which Rho was measured.         
   // The result of the integration (and this subroutine) is thus the radiance Ltotal into the View direction,         
   // that is, the flux density per unit solid angle into a solid angle at View. If one further assumes that the       
   // light within this cone is emitted as a plane wave, i.e. purely directionally (or will be assumed so by the       
   // sensor), then one can take the output of this subroutine as a flux density Etotal * delta-function(View).        
   // Note that incoming and outgoing flux densities are with respect to areas normal to the direction of propagation, 
   // as is the convention.                                                                     
   //                                                                                     
   // The BRDF we assume here is of the following form:                                                                
   // Rho = Kdif/PI + Kspec*max[cos(PHI),0]^Shine/cos(theta_i),                                   
   // where Kdif and Kspec are constants, theta_i is the incoming angle w.r.t Norm, and PHI is the angle between       
   // the viewing direction View and the Mirror angle (the angle of outgoing light assuming pure specular reflection). 
   // This BRDF is consistent with (but not provably following uniquely from) the Phong Model, as it leads to the      
   // Phong result Ltotal = Ldif Kamb + Ldir ( Kdif*max[cos(theta_i),0] + Kspec*max[cos(PHI),0]^Shine ), where Shine   
   // is the specular lobe parameter given by 128*( 1 - lobe_width/(2PI) ). Kamb gives the fractional contribution     
   // from the incoming diffuse light.                                                                                 
   //double Ltotal(VECTOR View, VECTOR Norm, double Ldir, VECTOR Vdir, double Ldif, double DHR, double ref_angle, double pct_spec, double lobe);   
    //double Ltotal2(VECTOR View, VECTOR Norm, double Ldir, VECTOR Vdir, double Ldif, double Kamb, double Kdif, double Kspec, double Shine);


    double specint_mc(double theta_r, double shine, int m);


   // Converts SigSim BRDF params (DHR, theta_fix, pct_spec, lobedeg) to Phong params (Kamb, Kdif, Kspec, Shine).
   // FIXEDANGLE : If TRUE, uses original Phong prescription (builds lobeintegral into Kspec, limits Shine<128). Otherwise uses new prescription which evaluates lobeint and K's at runtime.
    // DHR [unitless] : hemispherical reflectivity
    // thetafix_deg [deg]: angle at which DHR was measured
    // pct_spec [%] : Percent Specularity
    // lobedeg [deg]: Lobe width
   // b [unitless] :  For angle-dependent (hemispherical) output, set b=0. Otherwise Phong params will be angle-independent.
   // Kamb [unitless] : ambient reflectivity
   // Kdif [unitless] : diffuse reflectivity
   // Kspec [unitless]: specular reflectivity
   // Shine [unitless]: specular lobe exponent
   SIGSIM_API int SigSimBRDF2Phong(jrmbool FIXEDANGLE, double DHR, double thetafix_deg,  double b, double pct_spec, double lobedeg, double* Shine, double* Kamb, double* Kdif, double *Kspec);
    
   
   // Converts Sandford Robertson BRDF params (b, width, difref, hemiemit, xmit) to SigSim BRDF params (DHR, pct_spec, lobedeg), given theta_fix angle at which DHR is to be quoted.
   // b = Grazing-angle parameter [unitless]
   // w = Lobe width parameter [unitless]
   // pd = diffuse reflectivity [unitless]
   // e = emissivity [unitless]
   // t = transmissivity [unitless]
   SIGSIM_API int SR2SigSimBRDF(double theta_fix, double difref, double hemiemit, double xmit, double b, double width, double *pct_spec, double *lobe, double *DHR);



    SIGSIM_API double ShinyFromLobeWidth(jrmbool FIXEDANGLE, double lobe);    // [deg] to [unitless]
    SIGSIM_API double LobeWidthFromShiny(jrmbool FIXEDANGLE, double shiny);   // [unitless] to [deg]
   SIGSIM_API double Total2HemisphericalReflectivity(double param, double b, double thetarad, jrmbool USEOMG);
   SIGSIM_API double Hemispherical2TotalReflectivity(double param, double b, double thetarad, jrmbool USEOMG);


    // SSReflection : Performs SigSim Phong reflection integral.
    // DHR [unitless] = Directional Hemispherical Reflectivity (angle-dependent)
    // thetafix_deg [deg] = zenith angle at which DHR measured
    // pct_spec [%] = percent specular
    // lobe [deg] = width [0-180] of specular lobe.
   // b = SR grazing angle parameter (OK if unknown : set = 0) 
   // reflect_dir = vector from surface toward viewing direction
   // surfnorm = surface normal direction
   // direct_dir = vector from surface toward direct light incident direction
   // LDirect = direct light true radiance
   // dOmegaDirect [sr] = direct light apparent solid angle
   // ambsym_dir = vector from surface toward axis of symmetry of ambient light contribution 
   // Lambient = ambient light true radiance
   // Output = true radiance seen by observer
   SIGSIM_API double SSReflection(  VECTOR reflect_dir, VECTOR surfnorm, 
                              VECTOR direct_dir, double LDirect, double dOmegaDirect, 
                              VECTOR ambsym_dir, double LAmbient, 
                              double b, double DHR, double thetafix_deg, double pct_spec, double lobedeg);


   // PhongReflection : Performs Phong Reflection equation. Energy conserving.
   // Phong input params assumed angle-independent (total) unless b=0.
   // ka = ambient reflectivity
   // kd = diffuse reflectivity
   // ks = specular reflectivity
   // n = shininess exponent
   // reflect_dir = vector from surface toward viewing direction
   // surfnorm = surface normal direction
   // direct_dir = vector from surface toward direct light incident direction
   // LDirect = direct light true radiance
   // dOmegaDirect [sr] = direct light apparent solid angle
   // ambsym_dir = vector from surface toward axis of symmetry of ambient light contribution 
   // Lambient = ambient light true radiance
   // Output = true radiance seen by observer
   SIGSIM_API double PhongReflection(VECTOR reflect_dir, VECTOR surfnorm, 
                              VECTOR direct_dir, double LDirect, double dOmegaDirect, 
                              VECTOR ambsym_dir, double LAmbient, 
                              double b, double ka, double kd, double ks, double n);

   // OriginalPhongReflection : Performs Original Phong Reflection equation. (Not energy conserving except trivially at angleDHR).
   // Phong input params assumed angle-dependent at mp_table->angleDHR.
   // kA = ambient reflectivity
   // kD = diffuse reflectivity
   // kS = specular reflectivity
   // N = shininess exponent
   // reflect_dir = vector from surface toward viewing direction
   // surfnorm = surface normal direction
   // direct_dir = vector from surface toward direct light incident direction
   // LDirect = direct light true radiance
   // dOmegaDirect [sr] = direct light apparent solid angle
   // ambsym_dir = vector from surface toward axis of symmetry of ambient light contribution 
   // Lambient = ambient light true radiance
   // Output = true radiance seen by observer
   SIGSIM_API double OriginalPhongReflection(VECTOR reflect_dir, VECTOR surfnorm, 
                                    VECTOR direct_dir, double LDirect, double dOmegaDirect, 
                                    VECTOR ambsym_dir, double LAmbient, 
                                    double kA, double kD, double kS, double N);


    // SRg(theta ,b)
    //
    // description:  g(theta,b) function for Sandford Robertson BRDF. GPU capable
    //
    // params: theta = angle [rad]
    //         b - Geometric parameter governing reflectance at grazing angles
    //
    // returns: result of function
    //
    SIGSIM_API double SRg(double theta, double b);


    // SRG(b)
    //
    // description:  G(b) function for Sandford Robertson BRDF. 
    //
    // param: b - Geometric parameter governing reflectance at grazing angles
    //
    // returns: result of function
    //
    SIGSIM_API double SRG(double b);


    // SRh(alpha, width)
    //
    // description: Rh(alpha, width) function for Sandford Robertson BRDF. 
    //
    // params: alpha - glint angle defined by acos(dot_product(g,n)), where n is the surface normal and g is the normalized version of
    //         (i+o)/sqrt(2*(1-dot_product(i,o))), where i is the vector to source (incident) and o is vector to eye (reflected).
    //         width - Geometric parameter governing the width of the specular lobe
    //
    // returns: result of function
    //
    SIGSIM_API double SRh(double alpha, double width);


    // SRH(theta, width)
    //
    // description: H(theta, width) function for Sandford Robertson BRDF. GPU capable
    //
    // params: theta - angle [rad]
    //         width - Geometric parameter governing the width of the specular lobe
    //
    SIGSIM_API double SRH(double theta, double width);

   // SRDHR(theta, b, hemiemit, xmit)  [unitless]
   //
   // description: DHR(theta, b, hemiemit, xmit) function for Sandford Robertson BRDF. GPU capable
   //
   // params:  theta - angle [rad]
   //       b - Geometric parameter governing reflectance at grazing angles
   //       hemiemit - Total angle-independent emittance
   //       xmit - Total angle-independent transmittance
   //
   //
   // returns: Angle-dependent hemispheric DHR (or HDR) reflectance seen at angle theta.
   //
   SIGSIM_API double SRDHR(double theta, double b, double hemiemit, double xmit);

   // SREmis(theta, b, DHR, xmit)   [unitless]
   //
   // description: hemiemit(theta, b, DHR, xmit) inverse function for Sandford Robertson BRDF. GPU capable
   //
   // params:  theta - angle at which DHR measured [rad]
   //       b - Geometric parameter governing reflectance at grazing angles
   //       DHR - Hemispheric angle-dependent reflectance
   //       xmit - Total angle-independent transmittance
   //
   // returns: Total angle-independent emittance
   //
   SIGSIM_API double SREmis(double theta, double b, double DHR, double xmit);

   // SRDifRef(theta, b, DHR, pctspec) [unitless]
   //
   // description: difref(theta, b, DHR, pctspec) inverse function for Sandford Robertson BRDF. GPU capable
   //
   // params:  theta - angle at which DHR measured [rad]
   //       b - Geometric parameter governing reflectance at grazing angles
   //       DHR - Hemispheric angle-dependent reflectance
   //       pctspec - percent specularity
   //
   // returns: Total angle-independent diffuse reflectance
   //
   SIGSIM_API double SRDifRef(double theta, double b, double DHR, double pctspec);

   // SRXmit(theta, b, DHR, hemiemit)  [unitless]
   //
   // description: xmit(theta, b, DHR, hemiemit) inverse function for Sandford Robertson BRDF. GPU capable
   //
   // params:  theta - angle at which DHR measured [rad]
   //       b - Geometric parameter governing reflectance at grazing angles
   //       DHR - Hemispheric angle-dependent reflectance
   //       hemiemit - Total angle-independent emittance
   //
   //
   // returns: Total angle-independent transmittance
   //
   SIGSIM_API double SRXmit(double theta, double b, double DHR, double hemiemit);

   // SRPctSpec(theta, b, hemiemit, difref) [%]
   //
   // description: %specular(theta, b, hemiemit, difref, xmit) function for Sandford Robertson BRDF. GPU capable
   //
   // params:  theta - angle [rad]
   //       b - Geometric parameter governing reflectance at grazing angles
   //       hemiemit - Total angle-independent emittance
   //       difref   = Total angle-independent diffuse reflectance 
   //       xmit = Total angle-independent transmittance
   //
   // returns: Percent specularity [%]
   //
   SIGSIM_API double SRPctSpec(double theta, double b, double hemiemit, double difref, double xmit);

   // SRShiny(width) [unitless]
   //
   // description: shininess(width) function for Sandford Robertson BRDF. GPU capable
   //
   // params:  width - Geometric parameter governing the width of the specular lobe
   //
   SIGSIM_API double SRShiny(double width);

   // SRWidth(shiny) [unitless]
   //
   // description: Converts Phong Shininess to Sandford Robertson width. 
   //
   // params:  shiny - Phong parameter governing the width of the specular lobe
   //
   double SRWidth(double shiny);

   // SRReflection: Performs SR Reflection equation.
   // SR input params assumed angle-independent (total).
   // b = Grazing-angle parameter
   // w = Lobe width parameter
   // pd = diffuse reflectivity
   // e = emissivity
   // t = transmissivity
   // reflect_dir = vector from surface toward viewing direction
   // surfnorm = surface normal direction
   // direct_dir = vector from surface toward direct light incident direction
   // LDirect = direct light true radiance
   // dOmegaDirect [sr] = direct light apparent solid angle
   // ambsym_dir = vector from surface toward axis of symmetry of ambient light contribution 
   // Lambient = ambient light true radiance
   // Output = true radiance seen by observer
   SIGSIM_API double SRReflection(  VECTOR reflect_dir, VECTOR surfnorm, 
                              VECTOR direct_dir, double LDirect, double dOmegaDirect, 
                              VECTOR ambsym_dir, double LAmbient, 
                              double b, double w, double pd, double e, double t);

   // SRWidth2BeckmannWidth [unitless]
   //
   // description: Converts SR lobe width (w) to Beckmann width (m) 
   //
   // params:  w : parameter governing the width of the specular lobe
   // params:  costheta : cosine of angle of measurement (expected: costheta > LOLIM)
   //
   SIGSIM_API double SRWidth2BeckmannWidth(double w, double costheta);


    // BKh(alpha, width)
    //
    // description: Rh(alpha, width) function for Beckmann BRDF. 
    //
    // params: alpha - glint angle defined by acos(dot_product(g,n)), where n is the surface normal and g is the normalized version of
    //         (i+o)/sqrt(2*(1-dot_product(i,o))), where i is the vector to source (incident) and o is vector to eye (reflected).
    //         width - Geometric parameter governing the width of the specular lobe
    //
    // returns: result of function
    //
    SIGSIM_API double BKh(double alpha, double width);


    // BKH(theta, width)
    //
    // description: H(theta) function for Beckmann BRDF. GPU capable
    //
    // params: theta - angle [rad]
    //
    SIGSIM_API double BKH(double theta);


   // BKReflection : Performs Beckmann Reflection equation.
   // BK input params assumed angle-independent (total).
   // b = Grazing-angle parameter
   // m = Lobe width parameter
   // pd = diffuse reflectivity
   // e = emissivity
   // t = transmissivity
   // reflect_dir = vector from surface toward viewing direction
   // surfnorm = surface normal direction
   // direct_dir = vector from surface toward direct light incident direction
   // LDirect = direct light true radiance
   // dOmegaDirect [sr] = direct light apparent solid angle
   // ambsym_dir = vector from surface toward axis of symmetry of ambient light contribution 
   // Lambient = ambient light true radiance
   // Output = true radiance seen by observer
   SIGSIM_API double BKReflection   (  VECTOR reflect_dir, VECTOR surfnorm, 
                  VECTOR direct_dir, double LDirect, double dOmegaDirect, 
                  VECTOR ambsym_dir, double LAmbient, 
                  double b, double m, double pd, double e, double t);


   // ReadSpectrumFromMATL_PROP_TABLE Reads a spectrum from mp_table (only records with specified reflecttype and polarization) into {spectrum, yout).
   // Allocates spectrum and yout. BE SURE TO USE Free_SPECTRAL_DOMAIN_Arrays and Free_Double_Array to free this memory!
   SIGSIM_API int ReadSpectrumFromMATL_PROP_TABLE(MATL_PROP_TABLE *mp_table, int param, enum ReflectType reflecttype, enum Polarization polarization, SPECTRAL_DOMAIN *spectrum, double **yout);

   // WARNING : Fill_MATL_PROP_TABLE_IOSpectrum deletes the current IO spectrum from the mp_table, and replaces it with an unpolarized spectrum given by {lambda,DHR,pctspec,lobewidth}.
   // nspecrecs is the number of elements in these input arrays (assumed the same)
   // The Sandford Robertson and Standard Phong parameters are set to -1, so it is recommended that one run FillPhongParams() after this routine.
   SIGSIM_API int Fill_MATL_PROP_TABLE_IOSpectrum(MATL_PROP_TABLE *mp_table, double *lambda, double *DHR, double *pctspec, double *lobewidth, long nspecrecs);

   // ------------------- DUAL-FACTOR INTENSITY MODULATION CODE (CF2006) ---------------------------------------------- //

   // FindSDASystem calculates the coordinate system defined by the RGB directions of incident specular and diffuse pseuoradiances {Ls, Ld}.
   // See "Dual-factor Intensity Modulation" JRM whitepaper (Chris Fink 061008).
   // 
   // --- Inputs ---
   // Ls = Specular at-surface incident pseudoradiance [units immaterial] in 3 bands (usually RGB)
   // Ld = Diffuse (=ambient) at-surface incident pseudoradiance [units immaterial but same as Ls] in 3 bands (usually RGB)
   // costheta = [unitless] cosine of angle between surface normal and direction to specular incident pseudoradiance
   // shadow = [unitless] fraction of specular incident pseudoradiance that is unshadowed. Note 0=fully shadowed, 1=unshadowed.
   // --- Outputs ---
   // (*shat) = Direction of Ls. ( = X-direction)
   // (*dhat) = Direction of projection of Ld perpendicular to Ls ( = Y-direction)
   // (*ahat) = Direction out-of-plane of {Ls, Ld} ( = Z-direction)
   // (*dmag) = magnitude of projection of Ld perpendicular to Ls
   // (*M) = rotation matrix defined by transpose of {shat, dhat, ahat}. Converts RGB-system vectors to SDA-system representation.
   SIGSIM_API void FindSDASystem(VECTOR Ls, VECTOR Ld, double costheta, double shadow, VECTOR *shat, VECTOR *dhat, VECTOR *ahat, double *dmag, rotmatrix *M);

   // IntensityModulation calculates three parameters related to the difference in at-surface response between a pixel RGB value and its approximated Phong-model material prediction.
   // See "Dual-factor Intensity Modulation" JRM whitepaper (Chris Fink 061008).
   // NOTE : Requires output of FindSDASystem as input.
   // 
   // --- Inputs ---
   // Ls = Specular at-surface incident pseudoradiance [units immaterial] in 3 bands (usually RGB)
   // Ld = Diffuse (=ambient) at-surface incident pseudoradiance [units immaterial but same as Ls] in 3 bands (usually RGB)
   // costheta = [unitless] cosine of angle between surface normal and direction to specular incident pseudoradiance
   // shadow = [unitless] fraction of specular incident pseudoradiance that is unshadowed. Note 0=fully shadowed, 1=unshadowed.
   // DHR = [unitless] material DHR value in 3 bands (usually RGB bands).
   // Predict = Predicted at-surface reflected material radiance [units same as Ls and Ld] in 3 bands (usually RGB)
   // Pixel = At-surface reflected material radiance from image pixel [units same as Ls and Ld] in 3 bands (usually RGB)
   // shat = Direction of Ls. ( = X-direction)
   // dhat = Direction of projection of Ld perpendicular to Ls ( = Y-direction)
   // ahat = Direction out-of-plane of {Ls, Ld} ( = Z-direction)
   // dmag = magnitude of projection of Ld perpendicular to Ls
   // M = rotation matrix defined by transpose of {shat, dhat, ahat}. Converts RGB-system vectors to SDA-system representation.
   // --- Outputs ---
   // (*drsin) = [unitless] |dr| sin(theta_delta) = magnitude of DHR reflectance difference in plane of Ls and Ld
   // (*phi) = [radians] angle of DHR reflectance difference in {Ls, Ld} plane measured from Ls.
   // (*dshadow) = [unitless] Difference in shadowing fraction between pixel and prediction.
   SIGSIM_API int IntensityModulation(VECTOR Ls, VECTOR Ld, double costheta, double shadow, VECTOR shat, VECTOR dhat, VECTOR ahat, double dmag, rotmatrix M, VECTOR DHR, VECTOR Predict, VECTOR Pixel, double *drsin, double *phi, double *dshadow);

   // IntensityModulationPixelResponse calculates the approximate Phong-model pixel response in the dual-factor intensity modulation algorithm.
   // See "Dual-factor Intensity Modulation" JRM whitepaper (Chris Fink 061008).
   // NOTE : Requires output of FindSDASystem and IntensityModulation as input.
   // 
   // --- Inputs ---
   // Ls = Specular at-surface incident pseudoradiance [units immaterial] in 3 bands (usually RGB)
   // Ld = Diffuse (=ambient) at-surface incident pseudoradiance [units immaterial but same as Ls] in 3 bands (usually RGB)
   // costheta = [unitless] cosine of angle between surface normal and direction to specular incident pseudoradiance
   // shadow = [unitless] fraction of specular incident pseudoradiance that is unshadowed. Note 0=fully shadowed, 1=unshadowed.
   // M = rotation matrix defined by transpose of {shat, dhat, ahat}. Converts RGB-system vectors to SDA-system representation.
   // DHR = [unitless] material DHR value in 3 bands (usually RGB bands).
   // drsin = [unitless] |dr| sin(theta_delta) = magnitude of DHR reflectance difference in plane of Ls and Ld
   // phi = [radians] angle of DHR reflectance difference in {Ls, Ld} plane measured from Ls.
   // dshadow = [unitless] Difference in shadowing fraction between pixel and prediction.
   // --- Outputs ---
   // (*PixelPredict) = Predicted at-surface reflected image pixel radiance [units same as Ls and Ld] in 3 bands (usually RGB)
   SIGSIM_API int IntensityModulationPixelResponse(VECTOR Ls, VECTOR Ld, double costheta, double shadow, rotmatrix M, VECTOR DHR, double drsin, double phi, double dshadow, VECTOR *PixelPredict, double *Rtraceave);


   /* ======================== RF-BAND ROUTINES ================================== */

    double Tsigma0(double Zenith, double P1, double P2, double P3, double P4, double P5, double P6);
    double TSTDDev(double Zenith, double M1, double M2, double M3);


   int BandAveragedArealRCS(MATL_PROP_TABLE mp_table, BAND band, double Zenith, enum Polarization PL, double *RCS, double *STD);
   int BandAveragedUlabyParams(MATL_PROP_TABLE mp_table, BAND band, enum Polarization PL, double *P1, double *P2, double *P3, double *P4, double *P5, double *P6, double *M1, double *M2, double *M3);
   int BAND_UlabyParams(MATL_PROP_TABLE mp_table, BAND band, enum Polarization PL, double *P1, double *P2, double *P3, double *P4, double *P5, double *P6, double *M1, double *M2, double *M3);
   SIGSIM_API int BAND_EstimateRCSShininess(MATL_PROP_TABLE mp_table, BAND band);


   // BAND_TerrainRCS() provides Ulaby-Dobson terrain RCS returns for a given zenith angle and waveband: 
   // Inputs:  band = desired waveband
   //       Zenith angle [rad] 
   //       mp_table = relevant MATL_PROP_TABLE whose top layer contains spectral RCS data
   // Uses :   mp_table.{nspecrecs, reflectflag[i]=rf, polarflag[i]==PL, mp_table.lambda_um[i], param{1-9}[i]}.
   // Outputs: *RCS = mean unpolarized terrain radar cross section (sigma_0) [dB] for the specified waveband and angle.
   //       *STD = standard deviation of the RCS value [dB] for the specified waveband and angle.
   // Assumes: mp_table.lambda_um values are at beginning of bins, and are in increasing order for a given polarization.
   // Returns: SIGSIM_DATA_NOT_FOUND if there exist no spectral records in mp_table for which (mp_table.reflectflag[i]==rf)&&(mp_table.polarflag[i]==PL)&&(lambda>mp_table.lambda_um[i]).
   //       SIGSIM_SUCCESS upon successful completion.
   SIGSIM_API int BAND_TerrainRCS(MATL_PROP_TABLE mp_table, BAND band, double Zenith, enum Polarization PL, double *RCS, double *STD);
    SIGSIM_API int test_BAND_TerrainRCS(MATL_PROP_TABLE mp_table, BAND band, double Zenith, enum Polarization PL, double *RCS, double *STD);

   // TerrainRCS() provides Ulaby-Dobson terrain RCS returns for a given zenith angle and wavelength: 
   // Inputs:  lambda [um] = desired wavelength 
   //       Zenith angle [rad] 
   //       mp_table = relevant MATL_PROP_TABLE whose top layer contains spectral RCS data
   // Uses :   mp_table.{nspecrecs, reflectflag[i]=rf, polarflag[i]==PL, mp_table.lambda_um[i], param{1-9}[i]}.
   // Outputs: *RCS = mean unpolarized terrain radar cross section (sigma_0) [dB] for the specified wavelength and angle.
   //       *STD = standard deviation of the RCS value [dB] for the specified wavelength and angle.
   // Assumes: mp_table.lambda_um values are at beginning of bins, and are in increasing order for a given polarization.
   // Returns: SIGSIM_DATA_NOT_FOUND if there exist no spectral records in mp_table for which (mp_table.reflectflag[i]==rf)&&(mp_table.polarflag[i]==PL)&&(lambda>mp_table.lambda_um[i]).
   //       SIGSIM_SUCCESS upon successful completion.
   SIGSIM_API int TerrainRCS(MATL_PROP_TABLE mp_table, double lambda, double Zenith, enum Polarization PL, double *RCS, double *STD);

   // TerrainRCS_Polynomial() provides Ulaby-Dobson terrain RCS parameters for a given wavelength: 
   // Inputs:  lambda [um] = desired wavelength 
   //    mp_table = relevant MATL_PROP_TABLE whose top layer contains spectral RCS data
   //              PL = polarization state (use "un" for average of all polarization states).
   // Uses :   mp_table.{nspecrecs, reflectflag[i]=rf, polarflag[i]==PL, mp_table.lambda_um[i], param{1-9}[i]}.
   // Outputs: Coefficients of polynomial RCS = RCS0 + RCS1 * sin(Zenith) + RCS2 * sin^2(Zenith) + RCS3 * sin^3(Zenith)
   //    Coefficients of polynomial STD = STD0 + STD1 * sin(Zenith) + STD2 * sin^2(Zenith)   
   // Assumes: mp_table.lambda_um values are at beginning of bins, and are in increasing order for a given polarization.
   // Returns: SIGSIM_DATA_NOT_FOUND if there exist no spectral records in mp_table for which (mp_table.reflectflag[i]==rf)&&(mp_table.polarflag[i]==PL)&&(lambda>mp_table.lambda_um[i]).
   //    SIGSIM_SUCCESS upon successful completion.
   SIGSIM_API int TerrainRCS_Polynomial(MATL_PROP_TABLE mp_table, double lambda, enum Polarization PL, double *RCS0, double *RCS1, double *RCS2, double *RCS3, double *STD0, double *STD1, double *STD2);

   int BAND_TerrainRCS_Polynomial(MATL_PROP_TABLE mp_table, BAND band, enum Polarization PL, double *RCS0, double *RCS1, double *RCS2, double *RCS3, double *STD0, double *STD1, double *STD2);



#ifdef __cplusplus
}
#endif

#endif // _SIGSIMPHONG_H_