rfreeimage 0.1.0

data/vendor/FreeImage/Source/OpenEXR/Imath/ImathInterval.h

@@ -0,0 +1,226 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2002-2012, 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_IMATHINTERVAL_H
+#define INCLUDED_IMATHINTERVAL_H
+
+
+//-------------------------------------------------------------------
+//
+//	class Imath::Interval<class T>
+//	--------------------------------
+//
+//	An Interval has a min and a max and some miscellaneous
+//	functions. It is basically a Box<T> that allows T to be
+//	a scalar.
+//
+//-------------------------------------------------------------------
+
+#include "ImathVec.h"
+#include "ImathNamespace.h"
+
+IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+template <class T>	
+class Interval
+{
+  public:
+
+    //-------------------------
+    //  Data Members are public
+    //-------------------------
+
+    T				min;
+    T				max;
+
+    //-----------------------------------------------------
+    //	Constructors - an "empty" Interval is created by default
+    //-----------------------------------------------------
+
+    Interval(); 
+    Interval(const T& point);
+    Interval(const T& minT, const T& maxT);
+
+    //--------------------------------
+    //  Operators:  we get != from STL
+    //--------------------------------
+    
+    bool                        operator == (const Interval<T> &src) const;
+
+    //------------------
+    //	Interval manipulation
+    //------------------
+
+    void			makeEmpty();
+    void			extendBy(const T& point);
+    void			extendBy(const Interval<T>& interval);
+
+    //---------------------------------------------------
+    //	Query functions - these compute results each time
+    //---------------------------------------------------
+
+    T				size() const;
+    T				center() const;
+    bool			intersects(const T &point) const;
+    bool			intersects(const Interval<T> &interval) const;
+
+    //----------------
+    //	Classification
+    //----------------
+
+    bool			hasVolume() const;
+    bool			isEmpty() const;
+};
+
+
+//--------------------
+// Convenient typedefs
+//--------------------
+
+
+typedef Interval <float>  Intervalf;
+typedef Interval <double> Intervald;
+typedef Interval <short>  Intervals;
+typedef Interval <int>    Intervali;
+
+//----------------
+//  Implementation
+//----------------
+
+
+template <class T>
+inline Interval<T>::Interval()
+{
+    makeEmpty();
+}
+
+template <class T>
+inline Interval<T>::Interval(const T& point)
+{
+    min = point;
+    max = point;
+}
+
+template <class T>
+inline Interval<T>::Interval(const T& minV, const T& maxV)
+{
+    min = minV;
+    max = maxV;
+}
+
+template <class T>
+inline bool
+Interval<T>::operator == (const Interval<T> &src) const
+{
+    return (min == src.min && max == src.max);
+}
+
+template <class T>
+inline void
+Interval<T>::makeEmpty()
+{
+    min = limits<T>::max();
+    max = limits<T>::min();
+}
+
+template <class T>
+inline void
+Interval<T>::extendBy(const T& point)
+{
+    if ( point < min )
+	min = point;
+    
+    if ( point > max )
+	max = point;
+}
+
+template <class T>
+inline void
+Interval<T>::extendBy(const Interval<T>& interval)
+{
+    if ( interval.min < min )
+	min = interval.min;
+
+    if ( interval.max > max )
+	max = interval.max;
+}
+
+template <class T>
+inline bool
+Interval<T>::intersects(const T& point) const
+{
+    return point >= min && point <= max;
+}
+
+template <class T>
+inline bool
+Interval<T>::intersects(const Interval<T>& interval) const
+{
+    return interval.max >= min && interval.min <= max;
+}
+
+template <class T> 
+inline T
+Interval<T>::size() const 
+{ 
+    return max-min;
+}
+
+template <class T> 
+inline T
+Interval<T>::center() const 
+{ 
+    return (max+min)/2;
+}
+
+template <class T>
+inline bool
+Interval<T>::isEmpty() const
+{
+    return max < min;
+}
+
+template <class T>
+inline bool Interval<T>::hasVolume() const
+{
+    return max > min;
+}
+
+
+IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif // INCLUDED_IMATHINTERVAL_H

data/vendor/FreeImage/Source/OpenEXR/Imath/ImathLimits.h

@@ -0,0 +1,268 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2002-2012, 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_IMATHLIMITS_H
+#define INCLUDED_IMATHLIMITS_H
+
+//----------------------------------------------------------------
+//
+//	Limitations of the basic C++ numerical data types
+//
+//----------------------------------------------------------------
+
+#include "ImathNamespace.h"
+#include <float.h>
+#include <limits.h>
+
+//------------------------------------------
+// In Windows, min and max are macros.  Yay.
+//------------------------------------------
+
+#if defined _WIN32 || defined _WIN64
+    #ifdef min
+        #undef min
+    #endif
+    #ifdef max
+        #undef max
+    #endif
+#endif
+
+IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+//-----------------------------------------------------------------
+//
+// Template class limits<T> returns information about the limits
+// of numerical data type T:
+//
+//	min()		largest possible negative value of type T
+//
+//	max()		largest possible positive value of type T
+//
+//	smallest()	smallest possible positive value of type T
+//			(for float and double: smallest normalized
+//			positive value)
+//
+//	epsilon()	smallest possible e of type T, for which
+//			1 + e != 1
+//
+//	isIntegral()	returns true if T is an integral type
+//
+//	isSigned()	returns true if T is signed
+//
+// Class limits<T> is useful to implement template classes or
+// functions which depend on the limits of a numerical type
+// which is not known in advance; for example:
+//
+//	template <class T> max (T x[], int n)
+//	{
+//	    T m = limits<T>::min();
+//
+//	    for (int i = 0; i < n; i++)
+//		if (m < x[i])
+//		    m = x[i];
+//
+//	    return m;
+//	}
+//
+// Class limits<T> has been implemented for the following types:
+//
+//	char, signed char, unsigned char
+//	short, unsigned short
+//	int, unsigned int
+//	long, unsigned long
+//	float
+//	double
+//	long double
+//
+// Class limits<T> has only static member functions, all of which
+// are implemented as inlines.  No objects of type limits<T> are
+// ever created.
+//
+//-----------------------------------------------------------------
+
+
+template <class T> struct limits
+{
+    static T	min();
+    static T	max();
+    static T	smallest();
+    static T	epsilon();
+    static bool	isIntegral();
+    static bool	isSigned();
+};
+
+
+//---------------
+// Implementation
+//---------------
+
+template <>
+struct limits <char>
+{
+    static char			min()		{return CHAR_MIN;}
+    static char			max()		{return CHAR_MAX;}
+    static char			smallest()	{return 1;}
+    static char			epsilon()	{return 1;}
+    static bool			isIntegral()	{return true;}
+    static bool			isSigned()	{return (char) ~0 < 0;}
+};
+
+template <>
+struct limits <signed char>
+{
+    static signed char		min()		{return SCHAR_MIN;}
+    static signed char		max()		{return SCHAR_MAX;}
+    static signed char		smallest()	{return 1;}
+    static signed char		epsilon()	{return 1;}
+    static bool			isIntegral()	{return true;}
+    static bool			isSigned()	{return true;}
+};
+
+template <>
+struct limits <unsigned char>
+{
+    static unsigned char	min()		{return 0;}
+    static unsigned char	max()		{return UCHAR_MAX;}
+    static unsigned char	smallest()	{return 1;}
+    static unsigned char	epsilon()	{return 1;}
+    static bool			isIntegral()	{return true;}
+    static bool			isSigned()	{return false;}
+};
+
+template <>
+struct limits <short>
+{
+    static short		min()		{return SHRT_MIN;}
+    static short		max()		{return SHRT_MAX;}
+    static short		smallest()	{return 1;}
+    static short		epsilon()	{return 1;}
+    static bool			isIntegral()	{return true;}
+    static bool			isSigned()	{return true;}
+};
+
+template <>
+struct limits <unsigned short>
+{
+    static unsigned short	min()		{return 0;}
+    static unsigned short	max()		{return USHRT_MAX;}
+    static unsigned short	smallest()	{return 1;}
+    static unsigned short	epsilon()	{return 1;}
+    static bool			isIntegral()	{return true;}
+    static bool			isSigned()	{return false;}
+};
+
+template <>
+struct limits <int>
+{
+    static int			min()		{return INT_MIN;}
+    static int			max()		{return INT_MAX;}
+    static int			smallest()	{return 1;}
+    static int			epsilon()	{return 1;}
+    static bool			isIntegral()	{return true;}
+    static bool			isSigned()	{return true;}
+};
+
+template <>
+struct limits <unsigned int>
+{
+    static unsigned int		min()		{return 0;}
+    static unsigned int		max()		{return UINT_MAX;}
+    static unsigned int		smallest()	{return 1;}
+    static unsigned int		epsilon()	{return 1;}
+    static bool			isIntegral()	{return true;}
+    static bool			isSigned()	{return false;}
+};
+
+template <>
+struct limits <long>
+{
+    static long			min()		{return LONG_MIN;}
+    static long			max()		{return LONG_MAX;}
+    static long			smallest()	{return 1;}
+    static long			epsilon()	{return 1;}
+    static bool			isIntegral()	{return true;}
+    static bool			isSigned()	{return true;}
+};
+
+template <>
+struct limits <unsigned long>
+{
+    static unsigned long	min()		{return 0;}
+    static unsigned long	max()		{return ULONG_MAX;}
+    static unsigned long	smallest()	{return 1;}
+    static unsigned long	epsilon()	{return 1;}
+    static bool			isIntegral()	{return true;}
+    static bool			isSigned()	{return false;}
+};
+
+template <>
+struct limits <float>
+{
+    static float		min()		{return -FLT_MAX;}
+    static float		max()		{return FLT_MAX;}
+    static float		smallest()	{return FLT_MIN;}
+    static float		epsilon()	{return FLT_EPSILON;}
+    static bool			isIntegral()	{return false;}
+    static bool			isSigned()	{return true;}
+};
+
+template <>
+struct limits <double>
+{
+    static double		min()		{return -DBL_MAX;}
+    static double		max()		{return DBL_MAX;}
+    static double		smallest()	{return DBL_MIN;}
+    static double		epsilon()	{return DBL_EPSILON;}
+    static bool			isIntegral()	{return false;}
+    static bool			isSigned()	{return true;}
+};
+
+template <>
+struct limits <long double>
+{
+    static long double		min()		{return -LDBL_MAX;}
+    static long double		max()		{return LDBL_MAX;}
+    static long double		smallest()	{return LDBL_MIN;}
+    static long double		epsilon()	{return LDBL_EPSILON;}
+    static bool			isIntegral()	{return false;}
+    static bool			isSigned()	{return true;}
+};
+
+
+IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif // INCLUDED_IMATHLIMITS_H

data/vendor/FreeImage/Source/OpenEXR/Imath/ImathLine.h

@@ -0,0 +1,185 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2002-2012, 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_IMATHLINE_H
+#define INCLUDED_IMATHLINE_H
+
+//-------------------------------------
+//
+//	A 3D line class template
+//
+//-------------------------------------
+
+#include "ImathVec.h"
+#include "ImathLimits.h"
+#include "ImathMatrix.h"
+#include "ImathNamespace.h"
+
+IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+template <class T>
+class Line3
+{
+  public:
+
+    Vec3<T>			pos;
+    Vec3<T>			dir;
+    
+    //-------------------------------------------------------------
+    //	Constructors - default is normalized units along direction
+    //-------------------------------------------------------------
+
+    Line3() {}
+    Line3(const Vec3<T>& point1, const Vec3<T>& point2);
+
+    //------------------
+    //	State Query/Set
+    //------------------
+
+    void			set(const Vec3<T>& point1, 
+				    const Vec3<T>& point2);
+
+    //-------
+    //	F(t)
+    //-------
+
+    Vec3<T>			operator() (T parameter) const;
+
+    //---------
+    //	Query
+    //---------
+
+    T				distanceTo(const Vec3<T>& point) const;
+    T				distanceTo(const Line3<T>& line) const;
+    Vec3<T>			closestPointTo(const Vec3<T>& point) const;
+    Vec3<T>			closestPointTo(const Line3<T>& line) const;
+};
+
+
+//--------------------
+// Convenient typedefs
+//--------------------
+
+typedef Line3<float> Line3f;
+typedef Line3<double> Line3d;
+
+
+//---------------
+// Implementation
+//---------------
+
+template <class T>
+inline Line3<T>::Line3(const Vec3<T> &p0, const Vec3<T> &p1)
+{
+    set(p0,p1);
+}
+
+template <class T>
+inline void Line3<T>::set(const Vec3<T> &p0, const Vec3<T> &p1)
+{
+    pos = p0; dir = p1-p0;
+    dir.normalize();
+}
+
+template <class T>
+inline Vec3<T> Line3<T>::operator()(T parameter) const
+{
+    return pos + dir * parameter;
+}
+
+template <class T>
+inline T Line3<T>::distanceTo(const Vec3<T>& point) const
+{
+    return (closestPointTo(point)-point).length();
+}
+
+template <class T>
+inline Vec3<T> Line3<T>::closestPointTo(const Vec3<T>& point) const
+{
+    return ((point - pos) ^ dir) * dir + pos;
+}
+
+template <class T>
+inline T Line3<T>::distanceTo(const Line3<T>& line) const
+{
+    T d = (dir % line.dir) ^ (line.pos - pos);
+    return (d >= 0)? d: -d;
+}
+
+template <class T>
+inline Vec3<T> 
+Line3<T>::closestPointTo(const Line3<T>& line) const
+{
+    // Assumes the lines are normalized
+
+    Vec3<T> posLpos = pos - line.pos ;
+    T c = dir ^ posLpos;
+    T a = line.dir ^ dir;
+    T f = line.dir ^ posLpos ;
+    T num = c - a * f;
+
+    T denom = a*a - 1;
+
+    T absDenom = ((denom >= 0)? denom: -denom);
+
+    if (absDenom < 1)
+    {
+	T absNum = ((num >= 0)? num: -num);
+
+	if (absNum >= absDenom * limits<T>::max())
+	    return pos;
+    }
+
+    return pos + dir * (num / denom);
+}
+
+template<class T>
+std::ostream& operator<< (std::ostream &o, const Line3<T> &line)
+{
+    return o << "(" << line.pos << ", " << line.dir << ")";
+}
+
+template<class S, class T>
+inline Line3<S> operator * (const Line3<S> &line, const Matrix44<T> &M)
+{
+    return Line3<S>( line.pos * M, (line.pos + line.dir) * M );
+}
+
+
+IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif // INCLUDED_IMATHLINE_H