| /////////////////////////////////////////////////////////////////////////// |
| // |
| // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas |
| // Digital Ltd. LLC |
| // |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Industrial Light & Magic nor the names of |
| // its contributors may be used to endorse or promote products derived |
| // from this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| |
| |
| |
| #ifndef INCLUDED_IMF_LUT_H |
| #define INCLUDED_IMF_LUT_H |
| |
| //----------------------------------------------------------------------------- |
| // |
| // Lookup tables for efficient application |
| // of half --> half functions to pixel data, |
| // and some commonly applied functions. |
| // |
| //----------------------------------------------------------------------------- |
| |
| #include <ImfRgbaFile.h> |
| #include <ImfFrameBuffer.h> |
| #include "ImathBox.h" |
| #include "halfFunction.h" |
| |
| namespace Imf { |
| |
| // |
| // Lookup table for individual half channels. |
| // |
| |
| class HalfLut |
| { |
| public: |
| |
| //------------ |
| // Constructor |
| //------------ |
| |
| template <class Function> |
| HalfLut (Function f); |
| |
| |
| //---------------------------------------------------------------------- |
| // Apply the table to data[0], data[stride] ... data[(nData-1) * stride] |
| //---------------------------------------------------------------------- |
| |
| void apply (half *data, |
| int nData, |
| int stride = 1) const; |
| |
| |
| //--------------------------------------------------------------- |
| // Apply the table to a frame buffer slice (see ImfFrameBuffer.h) |
| //--------------------------------------------------------------- |
| |
| void apply (const Slice &data, |
| const Imath::Box2i &dataWindow) const; |
| |
| private: |
| |
| halfFunction <half> _lut; |
| }; |
| |
| |
| // |
| // Lookup table for combined RGBA data. |
| // |
| |
| class RgbaLut |
| { |
| public: |
| |
| //------------ |
| // Constructor |
| //------------ |
| |
| template <class Function> |
| RgbaLut (Function f, RgbaChannels chn = WRITE_RGB); |
| |
| |
| //---------------------------------------------------------------------- |
| // Apply the table to data[0], data[stride] ... data[(nData-1) * stride] |
| //---------------------------------------------------------------------- |
| |
| void apply (Rgba *data, |
| int nData, |
| int stride = 1) const; |
| |
| |
| //----------------------------------------------------------------------- |
| // Apply the table to a frame buffer (see RgbaOutpuFile.setFrameBuffer()) |
| //----------------------------------------------------------------------- |
| |
| void apply (Rgba *base, |
| int xStride, |
| int yStride, |
| const Imath::Box2i &dataWindow) const; |
| |
| private: |
| |
| halfFunction <half> _lut; |
| RgbaChannels _chn; |
| }; |
| |
| |
| // |
| // 12bit log rounding reduces data to 20 stops with 200 steps per stop. |
| // That makes 4000 numbers. An extra 96 just come along for the ride. |
| // Zero explicitly remains zero. The first non-zero half will map to 1 |
| // in the 0-4095 12log space. A nice power of two number is placed at |
| // the center [2000] and that number is near 0.18. |
| // |
| |
| half round12log (half x); |
| |
| |
| // |
| // Round to n-bit precision (n should be between 0 and 10). |
| // After rounding, the significand's 10-n least significant |
| // bits will be zero. |
| // |
| |
| struct roundNBit |
| { |
| roundNBit (int n): n(n) {} |
| half operator () (half x) {return x.round(n);} |
| int n; |
| }; |
| |
| |
| // |
| // Template definitions |
| // |
| |
| |
| template <class Function> |
| HalfLut::HalfLut (Function f): |
| _lut(f, -HALF_MAX, HALF_MAX, half (0), |
| half::posInf(), half::negInf(), half::qNan()) |
| { |
| // empty |
| } |
| |
| |
| template <class Function> |
| RgbaLut::RgbaLut (Function f, RgbaChannels chn): |
| _lut(f, -HALF_MAX, HALF_MAX, half (0), |
| half::posInf(), half::negInf(), half::qNan()), |
| _chn(chn) |
| { |
| // empty |
| } |
| |
| |
| } // namespace Imf |
| |
| #endif |