TFParams.h

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     3-20-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

// TFParams.h

// Basic stuff for handling transfer functions

#ifndef __TRANSFER_FUNCTION_PARAMETERS_DOT_H
#define __TRANSFER_FUNCTION_PARAMETERS_DOT_H

// I really hate name collisions with stupid #defs
#ifdef max
#  undef max
#endif
#ifdef min
#  undef min
#endif 

#include <mathGutz.h>
#include <vector>
#include <limits>

/// Simian Transfer Function namespace
namespace STF { 

////////////////////////////////
/// what are the max dimensions 
/// of the domain and range?
enum MIN_NUM_TF_PARAMS {
   TF_MAX_D = 10,  ///< max domain dim of tf
   TF_MAX_R = 10   ///< max range dim of tf 
};

////////////////////////////////
/// transfer function primary (scalar) data type
typedef float tfSType;
/// a "bad" value (NAN) for comparisons
const tfSType tfSType_bad = std::numeric_limits<tfSType>::quiet_NaN();
const tfSType tfSType_max = std::numeric_limits<tfSType>::max();
const tfSType tfSType_min = std::numeric_limits<tfSType>::min();

inline tfSType randval() { return tfSType(DRAND48); }

////////////////////////////////
///@name "Range" (output) type for tf
///@{

/// this is a "vec<float,10>"
typedef gutz::vec<tfSType, TF_MAX_R> tfRangeType;
/// a "bad" range type for comparisons
const tfRangeType tfRangeType_bad(tfSType_bad);
const tfRangeType tfRangeType_max(tfSType_max);
const tfRangeType tfRangeType_min(tfSType_min);

typedef gutz::vec<int, TF_MAX_R> tfRangeIdx;
/// All indicied in order
const tfRangeIdx tfRangeIdx_ao(0,1,2,3,4,5,6,7,8,9);

/// the idicies match the symantics definition below
const tfRangeType tfRangeType_default(0,  ///<Red
                                      0,  ///<Green
                                      0,  ///<Blue
                                      0,  ///<Alpha
                                      0,  ///<TP Red
                                      0,  ///<TP Green
                                      0,  ///<TP Blue
                                      0,  ///<Frensnel
                                      0,  ///<Surface Scalar
                                      0); ///<???

/// a 4 vector, since we will be dealing mostly
/// with 4 value images (ex. RGBA)
typedef gutz::vec<tfSType, 4> tfRangeVec4;

/// a vector of RangeTypes
typedef std::vector<tfRangeType> tfRangeVec;
typedef tfRangeVec::iterator     tfRangeVecIter;

/// useful names for TFRange indicies
enum TF_RANGE_SYMANTICS {
   /// standard symantics
   RED      = 0,
   GREEN    = 1,
   BLUE     = 2,
   ALPHA    = 3,
   /// reflectance, alias for standard RGB
   RF_RED   = 0,
   RF_GREEN = 1,
   RF_BLUE  = 2, 
   /// transport (1-extinction)
   TP_RED   = 4,
   TP_GREEN = 5,
   TP_BLUE  = 6,
   /// fresnel term
   FRESNEL  = 7,
   /// surface scalar
   SURFACE  = 8,
   TFS_LAST = TF_MAX_R // == 10 for now
};

/// for separable 2D transfer function generation
///  used by TFElements
enum TF_4MAP_KINDS {
   TF_RGBA
};

const tfRangeIdx tfRGBA_idx(0,1,2,3);

///@}



////////////////////////////////
///@name "Domain" (input/axis dims) type for tf
///@{

/// this is a vec<float,10>
typedef gutz::vec<tfSType, TF_MAX_D> tfDomainType;
/// a bad domain type for coamparisons
const tfDomainType tfDomainType_bad(tfSType_bad);
const tfDomainType tfDomainType_max(tfSType_max);
const tfDomainType tfDomainType_min(tfSType_min);

/// vector of domain positions
typedef std::vector<tfDomainType> tfDomainVec;
typedef tfDomainVec::iterator     tfDomainVecIter;

////////////////////////////////
/// a 2D position/Val vec
/// this is a vec2<float>
typedef gutz::vec2<tfSType> tfVec2;
const   tfVec2              tfVec2_bad = tfVec2(tfSType_bad);

///@}


} /// end namespace STF

#endif

---

Send questions, comments, and bug reports to: