PBRT
/home/felix/UBC/projects/AdaptiveLightfieldSampling/pbrt_v2/src/3rdparty/openexr-1.7.0/ImfLut.h
00001 
00002 //
00003 // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
00004 // Digital Ltd. LLC
00005 // 
00006 // All rights reserved.
00007 // 
00008 // Redistribution and use in source and binary forms, with or without
00009 // modification, are permitted provided that the following conditions are
00010 // met:
00011 // *       Redistributions of source code must retain the above copyright
00012 // notice, this list of conditions and the following disclaimer.
00013 // *       Redistributions in binary form must reproduce the above
00014 // copyright notice, this list of conditions and the following disclaimer
00015 // in the documentation and/or other materials provided with the
00016 // distribution.
00017 // *       Neither the name of Industrial Light & Magic nor the names of
00018 // its contributors may be used to endorse or promote products derived
00019 // from this software without specific prior written permission. 
00020 // 
00021 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00022 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00023 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00024 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00025 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00026 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00027 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00028 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00029 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00030 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00031 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00032 //
00034 
00035 
00036 
00037 #ifndef INCLUDED_IMF_LUT_H
00038 #define INCLUDED_IMF_LUT_H
00039 
00040 //-----------------------------------------------------------------------------
00041 //
00042 //      Lookup tables for efficient application
00043 //      of half --> half functions to pixel data,
00044 //      and some commonly applied functions.
00045 //
00046 //-----------------------------------------------------------------------------
00047 
00048 #include <ImfRgbaFile.h>
00049 #include <ImfFrameBuffer.h>
00050 #include "ImathBox.h"
00051 #include "halfFunction.h"
00052 
00053 namespace Imf {
00054 
00055 //
00056 // Lookup table for individual half channels.
00057 //
00058 
00059 class HalfLut
00060 {
00061   public:
00062 
00063     //------------
00064     // Constructor
00065     //------------
00066 
00067     template <class Function>
00068     HalfLut (Function f);
00069 
00070 
00071     //----------------------------------------------------------------------
00072     // Apply the table to data[0], data[stride] ... data[(nData-1) * stride]
00073     //----------------------------------------------------------------------
00074 
00075     void apply (half *data,
00076                 int nData,
00077                 int stride = 1) const;
00078 
00079 
00080     //---------------------------------------------------------------
00081     // Apply the table to a frame buffer slice (see ImfFrameBuffer.h)
00082     //---------------------------------------------------------------
00083 
00084     void apply (const Slice &data,
00085                 const Imath::Box2i &dataWindow) const;
00086 
00087   private:
00088 
00089     halfFunction <half> _lut;
00090 };
00091 
00092 
00093 //
00094 // Lookup table for combined RGBA data.
00095 //
00096 
00097 class RgbaLut
00098 {
00099   public:
00100 
00101     //------------
00102     // Constructor
00103     //------------
00104 
00105     template <class Function>
00106     RgbaLut (Function f, RgbaChannels chn = WRITE_RGB);
00107 
00108 
00109     //----------------------------------------------------------------------
00110     // Apply the table to data[0], data[stride] ... data[(nData-1) * stride]
00111     //----------------------------------------------------------------------
00112 
00113     void apply (Rgba *data,
00114                 int nData,
00115                 int stride = 1) const;
00116 
00117 
00118     //-----------------------------------------------------------------------
00119     // Apply the table to a frame buffer (see RgbaOutpuFile.setFrameBuffer())
00120     //-----------------------------------------------------------------------
00121 
00122     void apply (Rgba *base,
00123                 int xStride,
00124                 int yStride,
00125                 const Imath::Box2i &dataWindow) const;
00126 
00127   private:
00128 
00129     halfFunction <half> _lut;
00130     RgbaChannels        _chn;
00131 };
00132 
00133 
00134 //
00135 // 12bit log rounding reduces data to 20 stops with 200 steps per stop.
00136 // That makes 4000 numbers.  An extra 96 just come along for the ride.
00137 // Zero explicitly remains zero.  The first non-zero half will map to 1
00138 // in the 0-4095 12log space.  A nice power of two number is placed at
00139 // the center [2000] and that number is near 0.18.
00140 //
00141 
00142 half round12log (half x);
00143 
00144 
00145 //
00146 // Round to n-bit precision (n should be between 0 and 10).
00147 // After rounding, the significand's 10-n least significant
00148 // bits will be zero.
00149 //
00150 
00151 struct roundNBit
00152 {
00153     roundNBit (int n): n(n) {}
00154     half operator () (half x) {return x.round(n);}
00155     int n;
00156 };
00157 
00158 
00159 //
00160 // Template definitions
00161 //
00162 
00163 
00164 template <class Function>
00165 HalfLut::HalfLut (Function f):
00166     _lut(f, -HALF_MAX, HALF_MAX, half (0),
00167          half::posInf(), half::negInf(), half::qNan())
00168 {
00169     // empty
00170 }
00171 
00172 
00173 template <class Function>
00174 RgbaLut::RgbaLut (Function f, RgbaChannels chn):
00175     _lut(f, -HALF_MAX, HALF_MAX, half (0),
00176          half::posInf(), half::negInf(), half::qNan()),
00177     _chn(chn)
00178 {
00179     // empty
00180 }
00181 
00182 
00183 } // namespace Imf
00184 
00185 #endif