rfreeimage 0.1.0

data/vendor/FreeImage/Source/OpenEXR/IlmImf/ImfDeepCompositing.h

@@ -0,0 +1,132 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2012, Weta Digital Ltd
+// 
+// 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 Weta Digital 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_DEEPCOMPOSITING_H
+#define INCLUDED_IMF_DEEPCOMPOSITING_H
+
+//-----------------------------------------------------------------------------
+//
+//	Class to sort and composite deep samples into a frame buffer
+//      You may derive from this class to change the way that CompositeDeepScanLine
+//      and CompositeDeepTile combine samples together - pass an instance of your derived
+//      class to the compositing engine
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfForward.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+class IMF_EXPORT DeepCompositing
+{
+    public:
+        DeepCompositing();
+        virtual ~DeepCompositing();
+        
+        
+        //////////////////////////////////////////////
+        ///
+        /// composite together the given channels
+        /// 
+        ///  @param outputs       - return array of pixel values - 
+        ///  @param inputs        - arrays of input sample
+        ///  @param channel_names - array of channel names for corresponding channels
+        ///  @param num_channels  - number of active channels (3 or greater)    
+        ///  @param num_samples   - number of values in all input arrays
+        ///  @param sources       - number of different sources
+        ///
+        /// each array input has num_channels entries: outputs[n] should be the composited
+        /// values in array inputs[n], whose name will be given by channel_names[n]
+        /// 
+        /// The channel ordering shall be as follows:
+        /// Position Channel
+        ///    0     Z
+        ///    1     ZBack (if no ZBack, then inputs[1]==inputs[0] and channel_names[1]==channel_names[0])
+        ///    2     A (alpha channel)
+        ///    3-n   other channels - only channels in the frame buffer will appear here
+        ///
+        /// since a Z and Alpha channel is required, and channel[1] is ZBack or another copy of Z
+        /// there will always be 3 or more channels.
+        ///
+        /// The default implementation calls sort() if and only if more than one source is active,
+        /// composites all samples together using the Over operator from front to back,
+        /// stopping as soon as a sample with alpha=1 is found
+        /// It also blanks all outputs if num_samples==0
+        ///
+        /// note - multiple threads may call composite_pixel simultaneously for different pixels
+        ///
+        ///
+        //////////////////////////////////////////////
+        virtual void composite_pixel(float outputs[],
+                                     const float * inputs[],
+                                     const char * channel_names[],
+                                     int num_channels,
+                                     int num_samples,
+                                     int sources
+                                     );
+                                     
+        
+       
+       ////////////////////////////////////////////////////////////////
+       ///
+       /// find the depth order for samples with given channel values
+       /// does not sort the values in-place. Instead it populates
+       /// array 'order' with the desired sorting order
+       ///
+       /// the default operation sorts samples from front to back according to their Z channel
+       ///
+       /// @param order         - required output order. order[n] shall be the nth closest sample
+       /// @param inputs        - arrays of input samples, one array per channel_name
+       /// @param channel_names - array of channel names for corresponding channels
+       /// @param num_channels  - number of channels (3 or greater)  
+       /// @param num_samples   - number of samples in each array
+       /// @param sources       - number of different sources the data arises from
+       ///
+       /// the channel layout is identical to composite_pixel() 
+       ///
+       ///////////////////////////////////////////////////////////////
+                                     
+       virtual void sort(int order[],
+                         const float * inputs[],
+                         const char * channel_names[],
+                         int num_channels,
+                         int num_samples,
+                         int sources);
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

data/vendor/FreeImage/Source/OpenEXR/IlmImf/ImfDeepFrameBuffer.cpp

@@ -0,0 +1,230 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "ImfDeepFrameBuffer.h"
+#include "Iex.h"
+
+
+using namespace std;
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+DeepSlice::DeepSlice (PixelType t,
+                      char *b,
+                      size_t xst,
+                      size_t yst,
+                      size_t spst,
+                      int xsm,
+                      int ysm,
+                      double fv,
+                      bool xtc,
+                      bool ytc)
+:
+    Slice (t, b, xst, yst, xsm, ysm, fv, xtc, ytc),
+    sampleStride (spst)
+{
+    // empty
+}
+
+
+void
+DeepFrameBuffer::insert (const char name[], const DeepSlice &slice)
+{
+    if (name[0] == 0)
+    {
+        THROW (IEX_NAMESPACE::ArgExc,
+               "Frame buffer slice name cannot be an empty string.");
+    }
+
+    _map[name] = slice;
+}
+
+
+void
+DeepFrameBuffer::insert (const string &name, const DeepSlice &slice)
+{
+    insert (name.c_str(), slice);
+}
+
+
+DeepSlice &
+DeepFrameBuffer::operator [] (const char name[])
+{
+    SliceMap::iterator i = _map.find (name);
+
+    if (i == _map.end())
+    {
+        THROW (IEX_NAMESPACE::ArgExc,
+               "Cannot find frame buffer slice \"" << name << "\".");
+    }
+
+    return i->second;
+}
+
+
+const DeepSlice &
+DeepFrameBuffer::operator [] (const char name[]) const
+{
+    SliceMap::const_iterator i = _map.find (name);
+
+    if (i == _map.end())
+    {
+        THROW (IEX_NAMESPACE::ArgExc,
+               "Cannot find frame buffer slice \"" << name << "\".");
+    }
+
+    return i->second;
+}
+
+
+DeepSlice &
+DeepFrameBuffer::operator [] (const string &name)
+{
+    return this->operator[] (name.c_str());
+}
+
+
+const DeepSlice &
+DeepFrameBuffer::operator [] (const string &name) const
+{
+    return this->operator[] (name.c_str());
+}
+
+
+DeepSlice *
+DeepFrameBuffer::findSlice (const char name[])
+{
+    SliceMap::iterator i = _map.find (name);
+    return (i == _map.end())? 0: &i->second;
+}
+
+
+const DeepSlice *
+DeepFrameBuffer::findSlice (const char name[]) const
+{
+    SliceMap::const_iterator i = _map.find (name);
+    return (i == _map.end())? 0: &i->second;
+}
+
+
+DeepSlice *
+DeepFrameBuffer::findSlice (const string &name)
+{
+    return findSlice (name.c_str());
+}
+
+
+const DeepSlice *
+DeepFrameBuffer::findSlice (const string &name) const
+{
+    return findSlice (name.c_str());
+}
+
+
+DeepFrameBuffer::Iterator
+DeepFrameBuffer::begin ()
+{
+    return _map.begin();
+}
+
+
+DeepFrameBuffer::ConstIterator
+DeepFrameBuffer::begin () const
+{
+    return _map.begin();
+}
+
+
+DeepFrameBuffer::Iterator
+DeepFrameBuffer::end ()
+{
+    return _map.end();
+}
+
+
+DeepFrameBuffer::ConstIterator
+DeepFrameBuffer::end () const
+{
+    return _map.end();
+}
+
+
+DeepFrameBuffer::Iterator
+DeepFrameBuffer::find (const char name[])
+{
+    return _map.find (name);
+}
+
+
+DeepFrameBuffer::ConstIterator
+DeepFrameBuffer::find (const char name[]) const
+{
+    return _map.find (name);
+}
+
+
+DeepFrameBuffer::Iterator
+DeepFrameBuffer::find (const string &name)
+{
+    return find (name.c_str());
+}
+
+
+DeepFrameBuffer::ConstIterator
+DeepFrameBuffer::find (const string &name) const
+{
+    return find (name.c_str());
+}
+
+
+void
+DeepFrameBuffer::insertSampleCountSlice(const Slice & slice)
+{
+    if (slice.type != UINT)
+    {
+        throw IEX_NAMESPACE::ArgExc("The type of sample count slice should be UINT.");
+    }
+
+    _sampleCounts = slice;
+}
+
+
+const Slice &
+DeepFrameBuffer::getSampleCountSlice() const
+{
+    return _sampleCounts;
+}
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

data/vendor/FreeImage/Source/OpenEXR/IlmImf/ImfDeepFrameBuffer.h

@@ -0,0 +1,339 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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 IMFDEEPFRAMEBUFFER_H_
+#define IMFDEEPFRAMEBUFFER_H_
+
+#include "ImfFrameBuffer.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+//--------------------------------------------------------
+// Description of a single deep slice of the frame buffer:
+//--------------------------------------------------------
+
+struct IMF_EXPORT DeepSlice : public Slice
+{
+    //---------------------------------------------------------------------
+    // The stride for each sample in this slice.
+    //
+    // Memory layout:  The address of sample i in pixel (x, y) is
+    //
+    //  base + (xp / xSampling) * xStride + (yp / ySampling) * yStride
+    //       + i * sampleStride
+    //
+    // where xp and yp are computed as follows:
+    //
+    //  * If we are reading or writing a scanline-based file:
+    //
+    //      xp = x
+    //      yp = y
+    //
+    //  * If we are reading a tile whose upper left coorner is at (xt, yt):
+    //
+    //      if xTileCoords is true then xp = x - xt, else xp = x
+    //      if yTileCoords is true then yp = y - yt, else yp = y
+    //
+    //---------------------------------------------------------------------
+
+    int sampleStride;
+
+    //------------
+    // Constructor
+    //------------
+    DeepSlice (PixelType type = HALF,
+               char * base = 0,
+               size_t xStride = 0,
+               size_t yStride = 0,
+               size_t sampleStride = 0,
+               int xSampling = 1,
+               int ySampling = 1,
+               double fillValue = 0.0,
+               bool xTileCoords = false,
+               bool yTileCoords = false);
+};
+
+//-----------------
+// DeepFrameBuffer.
+//-----------------
+
+class IMF_EXPORT DeepFrameBuffer
+{
+  public:
+
+
+    //------------
+    // Add a slice
+    //------------
+
+    void                        insert (const char name[],
+                                        const DeepSlice &slice);
+
+    void                        insert (const std::string &name,
+                                        const DeepSlice &slice);
+
+    //----------------------------------------------------------------
+    // Access to existing slices:
+    //
+    // [n]              Returns a reference to the slice with name n.
+    //                  If no slice with name n exists, an IEX_NAMESPACE::ArgExc
+    //                  is thrown.
+    //
+    // findSlice(n)     Returns a pointer to the slice with name n,
+    //                  or 0 if no slice with name n exists.
+    //
+    //----------------------------------------------------------------
+
+    DeepSlice &                 operator [] (const char name[]);
+    const DeepSlice &           operator [] (const char name[]) const;
+
+    DeepSlice &                 operator [] (const std::string &name);
+    const DeepSlice &           operator [] (const std::string &name) const;
+
+    DeepSlice *                 findSlice (const char name[]);
+    const DeepSlice *           findSlice (const char name[]) const;
+
+    DeepSlice *                 findSlice (const std::string &name);
+    const DeepSlice *           findSlice (const std::string &name) const;
+
+
+    //-----------------------------------------
+    // Iterator-style access to existing slices
+    //-----------------------------------------
+
+    typedef std::map <Name, DeepSlice> SliceMap;
+
+    class Iterator;
+    class ConstIterator;
+
+    Iterator                    begin ();
+    ConstIterator               begin () const;
+
+    Iterator                    end ();
+    ConstIterator               end () const;
+
+    Iterator                    find (const char name[]);
+    ConstIterator               find (const char name[]) const;
+
+    Iterator                    find (const std::string &name);
+    ConstIterator               find (const std::string &name) const;
+
+    //----------------------------------------------------
+    // Public function for accessing a sample count slice.
+    //----------------------------------------------------
+
+    void                        insertSampleCountSlice(const Slice & slice);
+    const Slice &               getSampleCountSlice() const;
+
+  private:
+
+    SliceMap                    _map;
+    Slice                       _sampleCounts;
+};
+
+//----------
+// Iterators
+//----------
+
+class DeepFrameBuffer::Iterator
+{
+  public:
+
+    Iterator ();
+    Iterator (const DeepFrameBuffer::SliceMap::iterator &i);
+
+    Iterator &                  operator ++ ();
+    Iterator                    operator ++ (int);
+
+    const char *                name () const;
+    DeepSlice &                 slice () const;
+
+  private:
+
+    friend class DeepFrameBuffer::ConstIterator;
+
+    DeepFrameBuffer::SliceMap::iterator _i;
+};
+
+
+class DeepFrameBuffer::ConstIterator
+{
+  public:
+
+    ConstIterator ();
+    ConstIterator (const DeepFrameBuffer::SliceMap::const_iterator &i);
+    ConstIterator (const DeepFrameBuffer::Iterator &other);
+
+    ConstIterator &             operator ++ ();
+    ConstIterator               operator ++ (int);
+
+    const char *                name () const;
+    const DeepSlice &           slice () const;
+
+  private:
+
+    friend bool operator == (const ConstIterator &, const ConstIterator &);
+    friend bool operator != (const ConstIterator &, const ConstIterator &);
+
+    DeepFrameBuffer::SliceMap::const_iterator _i;
+};
+
+
+//-----------------
+// Inline Functions
+//-----------------
+
+inline
+DeepFrameBuffer::Iterator::Iterator (): _i()
+{
+    // empty
+}
+
+
+inline
+DeepFrameBuffer::Iterator::Iterator (const DeepFrameBuffer::SliceMap::iterator &i):
+    _i (i)
+{
+    // empty
+}
+
+
+inline DeepFrameBuffer::Iterator &
+DeepFrameBuffer::Iterator::operator ++ ()
+{
+    ++_i;
+    return *this;
+}
+
+
+inline DeepFrameBuffer::Iterator
+DeepFrameBuffer::Iterator::operator ++ (int)
+{
+    Iterator tmp = *this;
+    ++_i;
+    return tmp;
+}
+
+
+inline const char *
+DeepFrameBuffer::Iterator::name () const
+{
+    return *_i->first;
+}
+
+
+inline DeepSlice &
+DeepFrameBuffer::Iterator::slice () const
+{
+    return _i->second;
+}
+
+
+inline
+DeepFrameBuffer::ConstIterator::ConstIterator (): _i()
+{
+    // empty
+}
+
+inline
+DeepFrameBuffer::ConstIterator::ConstIterator
+    (const DeepFrameBuffer::SliceMap::const_iterator &i): _i (i)
+{
+    // empty
+}
+
+
+inline
+DeepFrameBuffer::ConstIterator::ConstIterator (const DeepFrameBuffer::Iterator &other):
+    _i (other._i)
+{
+    // empty
+}
+
+inline DeepFrameBuffer::ConstIterator &
+DeepFrameBuffer::ConstIterator::operator ++ ()
+{
+    ++_i;
+    return *this;
+}
+
+
+inline DeepFrameBuffer::ConstIterator
+DeepFrameBuffer::ConstIterator::operator ++ (int)
+{
+    ConstIterator tmp = *this;
+    ++_i;
+    return tmp;
+}
+
+
+inline const char *
+DeepFrameBuffer::ConstIterator::name () const
+{
+    return *_i->first;
+}
+
+inline const DeepSlice &
+DeepFrameBuffer::ConstIterator::slice () const
+{
+    return _i->second;
+}
+
+
+inline bool
+operator == (const DeepFrameBuffer::ConstIterator &x,
+             const DeepFrameBuffer::ConstIterator &y)
+{
+    return x._i == y._i;
+}
+
+
+inline bool
+operator != (const DeepFrameBuffer::ConstIterator &x,
+             const DeepFrameBuffer::ConstIterator &y)
+{
+    return !(x == y);
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+
+
+
+
+#endif /* IMFDEEPFRAMEBUFFER_H_ */