ALTA  alpha
Public Types | Static Public Member Functions | List of all members
alta::params Class Reference

Detailed Description

Any function object or data object should have an associated parametrization.

We use the following convention to defined the tangent, normal and bi-normal of the surface:

#include <params.h>

Public Types

enum  input {
  RUSIN_TH_PH_TD_PD, RUSIN_TH_PH_TD, RUSIN_TH_TD_PD, RUSIN_TH_TD,
  RUSIN_VH_VD, RUSIN_VH, COS_TH_TD, COS_TH,
  SCHLICK_TK_PK, SCHLICK_VK, SCHLICK_TL_TK_PROJ_DPHI, COS_TK,
  RETRO_TL_TVL_PROJ_DPHI, STEREOGRAPHIC, SPHERICAL_TL_PL_TV_PV, COS_TLV,
  COS_TLR, ISOTROPIC_TV_TL, ISOTROPIC_TV_TL_DPHI, ISOTROPIC_TV_PROJ_DPHI,
  ISOTROPIC_TL_TV_PROJ_DPHI, ISOTROPIC_TD_PD, STARK_2D, STARK_3D,
  NEUMANN_2D, NEUMANN_3D, CARTESIAN, UNKNOWN_INPUT
}
 list of all supported parametrization for the input space. An unsupported parametrization will go under the name ! unknown. We use the following notations: More...
 
enum  output {
  INV_STERADIAN, INV_STERADIAN_COSINE_FACTOR, ENERGY, RGB_COLOR,
  XYZ_COLOR, UNKNOWN_OUTPUT
}
 list of all supported parametrization for the output space. An unsupported parametrization will go under the name unknown. More...
 

Static Public Member Functions

static params::input parse_input (const std::string &txt)
 parse a string to provide a parametrization type.
 
static params::output parse_output (const std::string &txt)
 parse a string to provide a parametrization type.
 
static const std::string & get_name (const params::input param)
 look for the string associated with a parametrization type.
 
static const std::string & get_name (const params::output)
 look for the string associated with a parametrization type. More...
 
static double * convert (const double *invec, params::input intype, params::input outtype)
 static function for input type convertion. This function allocate the resulting vector.
 
static void convert (const double *invec, params::output intype, int indim, params::output outtype, int outdim, double *outvec)
 static function for input type convertion. The outvec resulting vector should be allocated with the correct output size. TODO: RP this function is weird the outtype and intype ARE NEVER USED
 
static void convert (const double *invec, params::input intype, params::input outtype, double *outvec)
 static function for input type convertion. The outvec resulting vector should be allocated with the correct output size.
 
static void to_cartesian (const double *invec, params::input intype, double *outvec)
 convert a input vector in a given parametrization to an output vector in a cartesian parametrization, that is two 3d vectors concatenated.
 
static void from_cartesian (const double *invec, params::input outtype, double *outvec)
 convert a input CARTESIAN vector, that is two 3d vectors concatenated to an output vector in a given parametrization.
 
static int dimension (params::input t)
 provide a dimension associated with a parametrization
 
static int dimension (params::output t)
 provide a dimension associated with a parametrization
 
static bool is_cosine_weighted (params::output t)
 Is the value stored weighted by a cosine factor.
 
template<typename Real >
static void half_to_cartesian (Real theta_h, Real phi_h, Real theta_d, Real phi_d, Real *out)
 from the 4D definition of a half vector parametrization, export the cartesian coordinates.
 
static void classical_to_cartesian (double theta_l, double phi_l, double theta_v, double phi_v, double *out)
 from the 4D definition of a classical vector parametrization, export the cartesian coordinates.
 
template<class Vector , typename Real >
static void rotate_normal (Vector &vec, Real theta)
 rotate a cartesian vector with respect to the normal of theta degrees.
 
template<class Vector , typename Real >
static void rotate_binormal (Vector &vec, Real theta)
 rotate a cartesian vector with respect to the bi-normal of theta degrees.
 
template<class Vector , typename Real >
static void rotate (Vector &vec, Real theta, Real phi)
 Rotate VEC by THETA around the normal, and by PHI around the binormal.
 
static void print_input_params ()
 
static bool is_above_hemisphere (double *invec, params::input intype)
 Check whether or not a (light,view) configuration is above the hemisphere. More...
 
static bool is_below_hemisphere (double *invec, params::input intype)
 

Member Enumeration Documentation

  • The View vector is \(V\)
  • The Light vector is \(L\)
  • The Normal vector is \(N\)
  • The Reflected vector is \(R = 2\mbox{dot}({V}, {N}){N} - {V}\)
  • The Half vector is \(H = \frac{V+L}{||V+L||}\)
  • The Back vector is \(K = \frac{V-L}{||V-L||}\)
  • The elevation angle of vector \(V\) is \(\theta_V\)
  • The azimuth angle of vector \(V\) is \(\phi_V\)
Enumerator
RUSIN_TH_PH_TD_PD 

Half-angle parametrization as described by Rusinkiewicz [1998] described in spherical coordinates. Coordinates are: \( \left[ \theta_H, \phi_H, \theta_D, \phi_D \right] \).

RUSIN_TH_TD_PD 

Isotropic Half-angle parametrization. This parametrization is defined by the tuple \( \vec{x} = [\theta_H, \theta_D, \phi_D] \)

RUSIN_TH_TD 

Half-angle parametrization with no azimutal information

RUSIN_VH_VD 

Half-angle parametrization in vector format. Coordinates are: \( [H_x, H_y, H_z, D_x, D_y, D_z] \).

RUSIN_VH 

Half-angle parametrization with no difference direction in vector format. Coordinates are: [ \(\vec{h}_x, \vec{h}_y, \vec{h}_z\)].

COS_TH_TD 

Cosine of the RUSIN_TH_TD parametrization: Coordinates are in \( [\cos_{\theta_H},\cos_{\theta_D}] \).

SCHLICK_TK_PK 

Schlick's back vector parametrization

SCHLICK_VK 

Schlick's back vector

SCHLICK_TL_TK_PROJ_DPHI 

3D Parametrization where the phi component is projected and the parametrization is centered around the back direction. \([\theta_L, x, y] = [\theta_L, \theta_K \cos(\phi_K), \theta_K \sin(\phi_K)]\)

COS_TK 

Schlick's back vector dot product with the normal

RETRO_TL_TVL_PROJ_DPHI 

2D Parametrization where the phi component is projected and the parametrization is centered around the retro direction \([x, y] = [\theta_{VL} \cos(\Delta\phi), \theta_{VL} \sin(\Delta\phi)]\).

STEREOGRAPHIC 

Stereographic projection of the Light and View vectors

SPHERICAL_TL_PL_TV_PV 

Light and View vectors represented in spherical coordinates

COS_TLV 

Dot product between the Light and View vector

COS_TLR 

Dot product between the Light and Reflected vector

ISOTROPIC_TV_TL 

Light and View vectors represented in spherical coordinates,

ISOTROPIC_TV_TL_DPHI 

Light and View vectors represented in spherical coordinates, with the difference of azimutal coordinates in the last component

ISOTROPIC_TV_PROJ_DPHI 

2D Parametrization where the phi component is projected. Coordinates are: \(\left[\theta_v \cos(\Delta\phi), \theta_v \sin(\Delta\phi)\right]\).

ISOTROPIC_TL_TV_PROJ_DPHI 

3D Parametrization where the phi component is projected. Coordinates are: \(\left[\theta_l, \theta_v \cos(\Delta\phi), \theta_v \sin(\Delta\phi)\right]\).

ISOTROPIC_TD_PD 

Difference between two directions such as R and H

STARK_2D 

Modified Stark et al. [2005] 2D parametrization by Barla et al. [2015]. This parametrization is defined by the couple \( \vec{x} = ||\tilde{H}_p||, ||\tilde{B}|| \), where \( \tilde{H} = \frac{1}{2}(L+V) \) and \( \tilde{B} = \frac{1}{2}(L-V) \). \( \tilde{H}_p \) is the projected coordinates of \( \tilde{H} \) on the tangent plane.

STARK_3D 

Modified Stark et al. [2005] 2D parametrization by Barla et al. [2015]. This parametrization is defined by the tuple \( \vec{x} = \left[||\tilde{H}_p||, ||\tilde{B}||, \phi_B-\phi_H \right] \).

NEUMANN_2D 

Neumann and Neumann [1996] parametrization. This parametrization is defined by the couple \( \vec{x} = \left[ ||\tilde{H}_p||, ||\tilde{B}_p||\right] \), where \( \tilde{H} = \frac{1}{2}(L+V) \) and \( \tilde{B} = \frac{1}{2}(L-V) \). \( \tilde{H}_p \) is the projected coordinates of \( \tilde{H} \) on the tangent plane.

NEUMANN_3D 

Neumann and Neumann [1996] 3D parametrization. This parametrization is defined by the tuple \( \vec{x} = [||\tilde{H}_p||, ||\tilde{B}_p||, \phi_B-\phi_H] \).

CARTESIAN 

View and Light vectors represented in cartesian coordinates. We always pack the view vector first: \([V.x, V.y, V.z, L.x, L.y, L.z] \)

UNKNOWN_INPUT 

Default behaviour. Only use this is you do not fit BRDF data.

Enumerator
INV_STERADIAN 

Output values in inverse steradian (sr-1). This is the standard definition for a BRDF.

INV_STERADIAN_COSINE_FACTOR 

Output values in inverse steradian (sr-1) weighted by the cosine factor of the output direction.

Member Function Documentation

const std::string & params::get_name ( const params::output  param)
static
Todo:
Finish this implementation. It requires another static object.
bool params::is_above_hemisphere ( double *  invec,
params::input  intype 
)
static
Returns
true if both vectors (light and view) are above and false otherwise
Remarks
the function returns true also for grazing, tangential configuration (i.e., where light dot normal == 0 or view dot normal == 0)

The documentation for this class was generated from the following files: