///////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2004-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_IMATHBOX_H

#define INCLUDED_IMATHBOX_H

//-------------------------------------------------------------------

//

//  class Imath::Box<class T>

//  --------------------------------

//

//  This class imposes the following requirements on its 

//  parameter class:

//  

//  1) The class T must implement these operators:

//      + - < > <= >= = 

//     with the signature (T,T) and the expected 

//     return values for a numeric type. 

//

//  2) The class T must implement operator=

//     with the signature (T,float and/or double)

//

//  3) The class T must have a constructor which takes

//     a float (and/or double) for use in initializing the box.

//

//  4) The class T must have a function T::dimensions()

//     which returns the number of dimensions in the class

//     (since its assumed its a vector) -- preferably, this

//     returns a constant expression.

//

//-------------------------------------------------------------------

#include "ImathVec.h"

#include "ImathNamespace.h"

IMATH_INTERNAL_NAMESPACE_HEADER_ENTER

template <class T>  

class Box

{

  public:

    //-------------------------

    //  Data Members are public

    //-------------------------

    T       min;

    T       max;

    //-----------------------------------------------------

    //  Constructors - an "empty" box is created by default

    //-----------------------------------------------------

    Box (); 

    Box (const T &point);

    Box (const T &minT, const T &maxT);

    //--------------------

    //  Operators:  ==, !=

    //--------------------

    bool    operator == (const Box<T> &src) const;

    bool    operator != (const Box<T> &src) const;

    //------------------

    //  Box manipulation

    //------------------

    void    makeEmpty ();

    void    extendBy (const T &point);

    void    extendBy (const Box<T> &box);

    void    makeInfinite ();    

    //---------------------------------------------------

    //  Query functions - these compute results each time

    //---------------------------------------------------

    T     size () const;

    T     center () const;

    bool    intersects (const T &point) const;

    bool    intersects (const Box<T> &box) const;

    unsigned int  majorAxis () const;

    //----------------

    //  Classification

    //----------------

    bool    isEmpty () const;

    bool    hasVolume () const;

    bool    isInfinite () const;

};

//--------------------

// Convenient typedefs

//--------------------

typedef Box <V2s> Box2s;

typedef Box <V2i> Box2i;

typedef Box <V2f> Box2f;

typedef Box <V2d> Box2d;

typedef Box <V3s> Box3s;

typedef Box <V3i> Box3i;

typedef Box <V3f> Box3f;

typedef Box <V3d> Box3d;

//----------------

//  Implementation

template <class T>

inline Box<T>::Box()

{

    makeEmpty();

}

template <class T>

inline Box<T>::Box (const T &point)

{

    min = point;

    max = point;

}

template <class T>

inline Box<T>::Box (const T &minT, const T &maxT)

{

    min = minT;

    max = maxT;

}

template <class T>

inline bool

Box<T>::operator == (const Box<T> &src) const

{

    return (min == src.min && max == src.max);

}

template <class T>

inline bool

Box<T>::operator != (const Box<T> &src) const

{

    return (min != src.min || max != src.max);

}

template <class T>

inline void Box<T>::makeEmpty()

{

    min = T(T::baseTypeMax());

    max = T(T::baseTypeMin());

}

template <class T>

inline void Box<T>::makeInfinite()

{

    min = T(T::baseTypeMin());

    max = T(T::baseTypeMax());

}

template <class T>

inline void

Box<T>::extendBy(const T &point)

{

    for (unsigned int i = 0; i < min.dimensions(); i++)

    {

  if (point[i] < min[i])

      min[i] = point[i];

  if (point[i] > max[i])

      max[i] = point[i];

    }

}

template <class T>

inline void

Box<T>::extendBy(const Box<T> &box)

{

    for (unsigned int i = 0; i < min.dimensions(); i++)

    {

  if (box.min[i] < min[i])

      min[i] = box.min[i];

  if (box.max[i] > max[i])

      max[i] = box.max[i];

    }

}

template <class T>

inline bool

Box<T>::intersects(const T &point) const

{

    for (unsigned int i = 0; i < min.dimensions(); i++)

    {

        if (point[i] < min[i] || point[i] > max[i])

      return false;

    }

    return true;

}

template <class T>

inline bool

Box<T>::intersects(const Box<T> &box) const

{

    for (unsigned int i = 0; i < min.dimensions(); i++)

    {

        if (box.max[i] < min[i] || box.min[i] > max[i])

      return false;

    }

    return true;

}

template <class T> 

inline T

Box<T>::size() const 

{ 

    if (isEmpty())

  return T (0);

    return max - min;

}

template <class T> 

inline T

Box<T>::center() const 

{ 

    return (max + min) / 2;

}

template <class T>

inline bool

Box<T>::isEmpty() const

{

    for (unsigned int i = 0; i < min.dimensions(); i++)

    {

        if (max[i] < min[i])

      return true;

    }

    return false;

}

template <class T>

inline bool

Box<T>::isInfinite() const

{

    for (unsigned int i = 0; i < min.dimensions(); i++)

    {

        if (min[i] != T::baseTypeMin() || max[i] != T::baseTypeMax())

      return false;

    }

    return true;

}

template <class T>

inline bool

Box<T>::hasVolume() const

{

    for (unsigned int i = 0; i < min.dimensions(); i++)

    {

        if (max[i] <= min[i])

      return false;

    }

    return true;

}

template<class T>

inline unsigned int

Box<T>::majorAxis() const

{

    unsigned int major = 0;

    T s = size();

    for (unsigned int i = 1; i < min.dimensions(); i++)

    {

  if (s[i] > s[major])

      major = i;

    }

    return major;

}

//-------------------------------------------------------------------

//

//  Partial class specializations for Imath::Vec2<T> and Imath::Vec3<T>

//

//-------------------------------------------------------------------

template <typename T> class Box;

template <class T>

class Box<Vec2<T> >

{

  public:

    //-------------------------

    //  Data Members are public

    //-------------------------

    Vec2<T>   min;

    Vec2<T>   max;

    //-----------------------------------------------------

    //  Constructors - an "empty" box is created by default

    //-----------------------------------------------------

    Box(); 

    Box (const Vec2<T> &point);

    Box (const Vec2<T> &minT, const Vec2<T> &maxT);

    //--------------------

    //  Operators:  ==, !=

    //--------------------

    bool    operator == (const Box<Vec2<T> > &src) const;

    bool    operator != (const Box<Vec2<T> > &src) const;

    //------------------

    //  Box manipulation

    //------------------

    void    makeEmpty();

    void    extendBy (const Vec2<T> &point);

    void    extendBy (const Box<Vec2<T> > &box);

    void    makeInfinite();

    //---------------------------------------------------

    //  Query functions - these compute results each time

    //---------------------------------------------------

    Vec2<T>   size() const;

    Vec2<T>   center() const;

    bool    intersects (const Vec2<T> &point) const;

    bool    intersects (const Box<Vec2<T> > &box) const;

    unsigned int  majorAxis() const;

    //----------------

    //  Classification

    //----------------

    bool    isEmpty() const;

    bool    hasVolume() const;

    bool    isInfinite() const;

};

//----------------

//  Implementation

template <class T>

inline Box<Vec2<T> >::Box()

{

    makeEmpty();

}

Unexecuted instantiation: Imath_2_2::Box<Imath_2_2::Vec2<int> >::Box()

Unexecuted instantiation: Imath_2_2::Box<Imath_2_2::Vec2<float> >::Box()

template <class T>

inline Box<Vec2<T> >::Box (const Vec2<T> &point)

{

    min = point;

    max = point;

}

template <class T>

inline Box<Vec2<T> >::Box (const Vec2<T> &minT, const Vec2<T> &maxT)

{

    min = minT;

    max = maxT;

}

template <class T>

inline bool

Box<Vec2<T> >::operator ==  (const Box<Vec2<T> > &src) const

{

    return (min == src.min && max == src.max);

}

template <class T>

inline bool

Box<Vec2<T> >::operator != (const Box<Vec2<T> > &src) const

{

    return (min != src.min || max != src.max);

}

template <class T>

inline void Box<Vec2<T> >::makeEmpty()

{

    min = Vec2<T>(Vec2<T>::baseTypeMax());

    max = Vec2<T>(Vec2<T>::baseTypeMin());

}

Unexecuted instantiation: Imath_2_2::Box<Imath_2_2::Vec2<int> >::makeEmpty()

Unexecuted instantiation: Imath_2_2::Box<Imath_2_2::Vec2<float> >::makeEmpty()

template <class T>

inline void Box<Vec2<T> >::makeInfinite()

{

    min = Vec2<T>(Vec2<T>::baseTypeMin());

    max = Vec2<T>(Vec2<T>::baseTypeMax());

}

template <class T>

inline void

Box<Vec2<T> >::extendBy (const Vec2<T> &point)

{

    if (point[0] < min[0])

        min[0] = point[0];

    if (point[0] > max[0])

        max[0] = point[0];

    if (point[1] < min[1])

        min[1] = point[1];

    if (point[1] > max[1])

        max[1] = point[1];

}

template <class T>

inline void

Box<Vec2<T> >::extendBy (const Box<Vec2<T> > &box)

{

    if (box.min[0] < min[0])

        min[0] = box.min[0];

    if (box.max[0] > max[0])

        max[0] = box.max[0];

    if (box.min[1] < min[1])

        min[1] = box.min[1];

    if (box.max[1] > max[1])

        max[1] = box.max[1];

}

template <class T>

inline bool

Box<Vec2<T> >::intersects (const Vec2<T> &point) const

{

    if (point[0] < min[0] || point[0] > max[0] ||

        point[1] < min[1] || point[1] > max[1])

        return false;

    return true;

}

template <class T>

inline bool

Box<Vec2<T> >::intersects (const Box<Vec2<T> > &box) const

{

    if (box.max[0] < min[0] || box.min[0] > max[0] ||

        box.max[1] < min[1] || box.min[1] > max[1])

        return false;

    return true;

}

template <class T> 

inline Vec2<T>

Box<Vec2<T> >::size() const 

{ 

    if (isEmpty())

        return Vec2<T> (0);

    return max - min;

}

template <class T> 

inline Vec2<T>

Box<Vec2<T> >::center() const 

{ 

    return (max + min) / 2;

}

template <class T>

inline bool

Box<Vec2<T> >::isEmpty() const

{

    if (max[0] < min[0] ||

        max[1] < min[1])

        return true;

    return false;

}

template <class T>

inline bool

Box<Vec2<T> > ::isInfinite() const

{

    if (min[0] != limits<T>::min() || max[0] != limits<T>::max() ||

        min[1] != limits<T>::min() || max[1] != limits<T>::max())

        return false;

    return true;

}

template <class T>

inline bool

Box<Vec2<T> >::hasVolume() const

{

    if (max[0] <= min[0] ||

        max[1] <= min[1])

        return false;

    return true;

}

template <class T>

inline unsigned int

Box<Vec2<T> >::majorAxis() const

{

    unsigned int major = 0;

    Vec2<T>  s     = size();

    if (s[1] > s[major])

        major = 1;

    return major;

}

template <class T>

class Box<Vec3<T> >

{

  public:

    //-------------------------

    //  Data Members are public

    //-------------------------

    Vec3<T>     min;

    Vec3<T>     max;

    //-----------------------------------------------------

    //  Constructors - an "empty" box is created by default

    //-----------------------------------------------------

    Box(); 

    Box (const Vec3<T> &point);

    Box (const Vec3<T> &minT, const Vec3<T> &maxT);

    //--------------------

    //  Operators:  ==, !=

    //--------------------

    bool    operator == (const Box<Vec3<T> > &src) const;

    bool    operator != (const Box<Vec3<T> > &src) const;

    //------------------

    //  Box manipulation

    //------------------

    void    makeEmpty();

    void    extendBy (const Vec3<T> &point);

    void    extendBy (const Box<Vec3<T> > &box);

    void    makeInfinite ();

    //---------------------------------------------------

    //  Query functions - these compute results each time

    //---------------------------------------------------

    Vec3<T>   size() const;

    Vec3<T>   center() const;

    bool    intersects (const Vec3<T> &point) const;

    bool    intersects (const Box<Vec3<T> > &box) const;

    unsigned int  majorAxis() const;

    //----------------

    //  Classification

    //----------------

    bool    isEmpty() const;

    bool    hasVolume() const;

    bool    isInfinite() const;

};

//----------------

//  Implementation

template <class T>

inline Box<Vec3<T> >::Box()

{

    makeEmpty();

}

template <class T>

inline Box<Vec3<T> >::Box (const Vec3<T> &point)

{

    min = point;

    max = point;

}

template <class T>

inline Box<Vec3<T> >::Box (const Vec3<T> &minT, const Vec3<T> &maxT)

{

    min = minT;

    max = maxT;

}

template <class T>

inline bool

Box<Vec3<T> >::operator == (const Box<Vec3<T> > &src) const

{

    return (min == src.min && max == src.max);

}

template <class T>

inline bool

Box<Vec3<T> >::operator != (const Box<Vec3<T> > &src) const

{

    return (min != src.min || max != src.max);

}

template <class T>

inline void Box<Vec3<T> >::makeEmpty()

{

    min = Vec3<T>(Vec3<T>::baseTypeMax());

    max = Vec3<T>(Vec3<T>::baseTypeMin());

}

template <class T>

inline void Box<Vec3<T> >::makeInfinite()

{

    min = Vec3<T>(Vec3<T>::baseTypeMin());

    max = Vec3<T>(Vec3<T>::baseTypeMax());

}

template <class T>

inline void

Box<Vec3<T> >::extendBy (const Vec3<T> &point)

{

    if (point[0] < min[0])

        min[0] = point[0];

    if (point[0] > max[0])

        max[0] = point[0];

    if (point[1] < min[1])

        min[1] = point[1];

    if (point[1] > max[1])

        max[1] = point[1];

    if (point[2] < min[2])

        min[2] = point[2];

    if (point[2] > max[2])

        max[2] = point[2];

}

template <class T>

inline void

Box<Vec3<T> >::extendBy (const Box<Vec3<T> > &box)

{

    if (box.min[0] < min[0])

        min[0] = box.min[0];

    if (box.max[0] > max[0])

        max[0] = box.max[0];

    if (box.min[1] < min[1])

        min[1] = box.min[1];

    if (box.max[1] > max[1])

        max[1] = box.max[1];

    if (box.min[2] < min[2])

        min[2] = box.min[2];

    if (box.max[2] > max[2])

        max[2] = box.max[2];

}

template <class T>

inline bool

Box<Vec3<T> >::intersects (const Vec3<T> &point) const

{

    if (point[0] < min[0] || point[0] > max[0] ||

        point[1] < min[1] || point[1] > max[1] ||

        point[2] < min[2] || point[2] > max[2])

        return false;

    return true;

}

template <class T>

inline bool

Box<Vec3<T> >::intersects (const Box<Vec3<T> > &box) const

{

    if (box.max[0] < min[0] || box.min[0] > max[0] ||

        box.max[1] < min[1] || box.min[1] > max[1] ||

        box.max[2] < min[2] || box.min[2] > max[2])

        return false;

    return true;

}

template <class T> 

inline Vec3<T>

Box<Vec3<T> >::size() const 

{ 

    if (isEmpty())

        return Vec3<T> (0);

    return max - min;

}

template <class T> 

inline Vec3<T>

Box<Vec3<T> >::center() const 

{ 

    return (max + min) / 2;

}

template <class T>

inline bool

Box<Vec3<T> >::isEmpty() const

{

    if (max[0] < min[0] ||

        max[1] < min[1] ||

        max[2] < min[2])

        return true;

    return false;

}

template <class T>

inline bool

Box<Vec3<T> >::isInfinite() const

{

    if (min[0] != limits<T>::min() || max[0] != limits<T>::max() ||

        min[1] != limits<T>::min() || max[1] != limits<T>::max() ||

        min[2] != limits<T>::min() || max[2] != limits<T>::max())

        return false;

    return true;

}

template <class T>

inline bool

Box<Vec3<T> >::hasVolume() const

{

    if (max[0] <= min[0] ||

        max[1] <= min[1] ||

        max[2] <= min[2])

        return false;

    return true;

}

template <class T>

inline unsigned int

Box<Vec3<T> >::majorAxis() const

{

    unsigned int major = 0;

    Vec3<T>  s     = size();

    if (s[1] > s[major])

        major = 1;

    if (s[2] > s[major])

        major = 2;

    return major;

}

IMATH_INTERNAL_NAMESPACE_HEADER_EXIT

#endif // INCLUDED_IMATHBOX_H