| 
         
	SCATMECH > Classes and Functions >
        Surface Scattering Models
        > BRDF_Model
	 
        Abstract class BRDF_Model
         
        The abstract class BRDF_Model handles the generic
        operations associated with any bidirectional reflectance distribution function (BRDF) scattering model and
        acts as an interface by which programs can access different
        models. A pointer to a BRDF_Model (or a
        BRDF_Model_Ptr, which is a typedef to Model_Ptr<BRDF_Model>) can point to one of any number of
        specific models.
         The convention of BRDF_Model is that the function 
	  Mueller returns the Mueller matrix BRDF in 
	  the desired geometry.  The function Jones returns
	  a JonesMatrix that upon typecasting to 
	  MuellerMatrix is the Mueller matrix BRDF.
	  Classes inheriting BRDF_Model are required to provide either a function 
	  jones or mueller, returning these matrices.  The class BRDF_Model provides 
	  these functions with four variables of type double: thetai, thetas, phis, and rotation, specifying
	 the angles  i, 
	   s, 
	   s, and β, respectively, defined in the figure
        below.
         
           
        
	The angle  i  (thetai) is defined as the angle that a vector
        pointing to the source makes with respect to the surface
        normal. The angle  s (thetas) is the angle that a vector pointing in
        the scattering direction makes with respect to the surface
        normal. The angle  s (phis) is the azimuthal angle of the scattered
        light, measured in a right-handed fashion about the surface
        normal from the plane defined by the incident direction and
        the surface normal. Finally, the angle β (rotation) represents the rotation of the 
	sample in a counterclockwise fashion. 
        To write your own BRDF_Model class, see the outline
        given in "Writing your own BRDF
        model." 
	Parameters:
        
          
            | Parameter | 
            Data Type | 
            Description | 
            Default | 
           
          
            | lambda | 
            double | 
	    Wavelength of the light in vacuum [µm]. | 
	    0.532 | 
           
          
            | type | 
            int | 
	    
	      Indicates whether the light is incident from above the
            substrate or from within the substrate and whether the
            scattering is evaluated in reflection or transmission.
            The choices are: 
	      0 : Light is incident from the above the substrate, and scattering is evaluated in reflection. 
	      1 : Light is incident from the above the substrate, and scattering is evaluated in transmission. 
	      2 : Light is incident from within the substrate, and scattering is evaluated in reflection. 
	      3 : Light is incident from within the substrate, and scattering is evaluated in transmission. 
	      For 1, 2, and 3, the substrate must be non-absorbing. 
	      Not all modes are supported for all models inheriting BRDF_Model.
	       | 
	    0 | 
           
          
            | substrate | 
            dielectric_function | 
	    The
            optical constants of the substrate, expressed as a
            complex number (n,k) or, optionally, as a function of
            wavelength. | 
	    (4.05,0.05) | 
           
          
         
        See also:
        SCATMECH Home,  
        Conventions,   MuellerMatrix,   JonesMatrix,   List of child classes 
        
	    J. C. Stover, Optical Scattering: Measurement and
	    Analysis, (SPIE Optical Engineering Press, Bellingham,
	    WA, 1995).
	    D. S. Flynn and C. Alexander,
	    "Polarized surface scattering expressed in terms of a
	    bidirectional reflectance distribution function matrix,"
	    Opt. Eng. 34(6), 1646-1650 (1995). 
	Include file:
          
#include "brdf.h"
 
	Source code:
          
brdf.cpp
reg_brdf.cpp
 
         Definition of public and protected elements:
          
class BRDF_Model : public Model {
public:
    enum Coordinate_System {psps = 0,xyxy = 1,plane = 2};
    enum  {
        Type_DOWNUP = 0,
        Type_DOWNDOWN = 1,
        Type_UPDOWN = 2,  
        Type_UPUP = 3    
	}; 
    JonesMatrix Jones(double thetai,
                      double thetas,
                      double phis,
                      double rotation,
                      Coordinate_System cs = psps);
    MuellerMatrix Mueller(double thetai,
                          double thetas,
                          double phis,
                          double rotation,
                          Coordinate_System cs = psps);
    JonesMatrix Jones(Vector& source,
                      Vector& viewer,
                      Vector& normal,
                      Vector& xaxis,
                      Coordinate_System cs = plane);
    MuellerMatrix Mueller(Vector& source,
                          Vector& viewer,
                          Vector& normal,
                          Vector& xaxis,
                          Coordinate_System cs = plane);
    Coordinate_System get_model_cs();
protected:
    virtual void setup();
    Coordinate_System model_cs;
    virtual JonesMatrix jones();
    virtual MuellerMatrix mueller();
    double thetai;
    double thetas;
    double phii;
    double rotation;
};
typedef Model_Ptr<BRDF_Model> BRDF_Model_Ptr;
         
        double thetai 
        double thetas 
        double phis 
        double rotation
        
          These variables
          represent the geometry for which the calculation is to be
          performed. They are set by the public functions
          Mueller() and Jones(). They are used by the
          functions mueller() or jones().
           The variable
          thetai is the incident polar angle in
          radians. 
          The variable
          thetas is the scattering polar angle in
          radians. 
          The variable
          phis is the scattering azimuthal angle in
          radians. 
          The variable
          rotation is the rotation angle of the sample in
          radians about the surface normal. 
         
        Top of Page 
	
        
          This variable stores the coordinate system for which the
          scattering is defined in the code. By default, it is set
          to BRDF_Model::psps. A scattering
          model which inherits the properties of BRDF_Model
          and which has its scattering defined with respect to
          another coordinate system should set this variable in its
          constructor. The value can be publicly queried using
          get_model_cs.
           The different coordinate systems are: 
          BRDF_Model::psps - This coordinate system uses
          the standard {s,p,k} right-handed
          basis vectors appropriate for both the incident and
          scattered light. The k direction is the respective
          direction of propagation, the s direction is
          parallel to the plane defined by k and the surface
          normal, and the p direction is perpendicular to
          that plane. Most models are coded using this coordinate
          system. 
          BRDF_Model::xyxy - This coordinate system uses
          the same coordinates as BRDF_Model::psps for the
          incident light, but rotates the scattered light
          coordinates by the angle phis. Near the surface
          normal, this coordinate system is close to the directions
          x and y, where x is a vector in the
          plane of incidence and the plane of the sample, and
          y is a vector perpendicular to the plane of
          incidence. This coordinate system removes an apparent
          singularity which exists at the surface normal using the
          BRDF_Model::psps coordinate system. 
          BRDF_Model::plane - This coordinate system is
          defined by the plane which includes the incident and
          scattered directions. The basis vectors are parallel and
          perpendicular to this plane, respectively, for both the
          incident and the scattered light. This coordinate system
          may be more appropriate than the others for rendering
          applications. 
         
        Top of Page 
	
        
          These public functions return the Jones matrix or the
          Mueller matrix associated with the model, as a function
          of scattering geometry and polarization coordinate
          system. The value of cs defines the coordinate
          system for which the scattering matrix will be returned.
          Example:
        
          
double ti,ts,ps;
JonesVector incidentlight;
BRDF_Model *model;
JonesVector jones = model->Jones(ti,ts,ps,0,
                                    BRDF_Model::plane)*incidentlight;
         
        Top of Page 
	
        
          These public functions return the Jones matrix or the
          Mueller matrix associated with the model, as a function
          of scattering geometry and polarization coordinate
          system. The value of cs defines the coordinate
          system for which the scattering matrix will be returned.
          source is a Vector
          pointing from the sample to the light source.
          viewer is a Vector
          pointing in the scattering direction. normal is a
          Vector pointing in the outward
          surface normal. xaxis is a Vector which must have a component along
          the substrate surface, and defines the x-axis of that
          surface.Neither source, viewer,
          normal, or xaxis need be normalized. If
          xaxis is the zero vector, the sample rotation will
          be set to zero degrees.
           Note that the coordinate system defaults to
          BRDF_Model::plane, which is most natural for
          rendering applications. 
         Example:
        
          The following is an example of how one might use the
          Vector-based Mueller function.
          The sample is assumed to be tilted in the y-direction by
          an angle tilt, while the light is incident at an
          angle thetai and the receiver is collecting light
          at a polar angle of thetas and azimuthal angle
          phis.
          
        
          
Vector source(-sin(thetai),0.,cos(thetai));
Vector receiver(sin(thetas)*cos(phis),sin(thetas)*sin(phis),cos(thetas));
Vector normal(0.,sin(tilt),cos(tilt));
StokesVector incidentlight;
Some_BRDF_Model model; // Assume that Some_BRDF_Model is a BRDF_Model...
StokesVector stokes = model.Mueller(source,
                                     receiver,
                                      normal,
                                       Vector(0,0,0))*incidentlight;
         
        Top of Page 
	
        
          All functions that modify model parameters 
          set  Model::recalc to a non-zero value. The function
          setup() performs any housekeeping that is
          necessary if parameters have been changed. All
          inherited classes should have such a setup()
          function if they require such operations. They should
          all begin by calling the parent's setup() function.
          
        Top of Page 
	
        
          This function returns the Jones scattering matrix. It
          uses the variables thetai, thetas,
          phis, and rotation, defined above. If this function is not defined
          for an inherited class, it throws an exception if called.
          One of the functions, mueller or jones,
          must be defined by any inherited class.
          
        Top of Page 
	
        
          This function returns the Mueller matrix BRDF.
          It uses the variables thetai, thetas,
          phis, and rotation, defined above. If this function is not defined
          for an inherited class, it defaults to a JonesMatrix to MuellerMatrix conversion. One of
          the functions, mueller or jones, must be
          defined by any inherited class. 
         
        Top of Page 
	
        
          The typedef BRDF_Model_Ptr behaves like a pointer
          to an instance of class BRDF_Model. The following
          statement will query the user for an instance of class
          BRDF_Model:
          
        
          
BRDF_Model_Ptr model = Get_Model_Ptr();
 
         
        
          The next
          statement will also create an instance of class
          BRDF_Model:
          
        
          
BRDF_Model_Ptr model = "Microroughness_BRDF_Model";
 
         
        
          See Model_Ptr<model>.
          
        Top of Page 
 
For More Information
SCATMECH Technical Information and Questions 
Sensor Science Division Home Page 
Sensor Science Division Inquiries 
Website Comments
 
Current SCATMECH version: 7.22 (April 2021) 
 
  |