box.h

Go to the documentation of this file.

/****************************************************************************
* VCGLib                                                            o o     *
* Visual and Computer Graphics Library                            o     o   *
*                                                                _   O  _   *
* Copyright(C) 2004                                                \/)\/    *
* Visual Computing Lab                                            /\/|      *
* ISTI - Italian National Research Council                           |      *
*                                                                    \      *
* All rights reserved.                                                      *
*                                                                           *
* This program is free software; you can redistribute it and/or modify      *   
* it under the terms of the GNU General Public License as published by      *
* the Free Software Foundation; either version 2 of the License, or         *
* (at your option) any later version.                                       *
*                                                                           *
* This program is distributed in the hope that it will be useful,           *
* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
* for more details.                                                         *
*                                                                           *
****************************************************************************/
/****************************************************************************
  History

$Log: not supported by cvs2svn $
Revision 1.1  2004/03/16 03:07:38  tarini
"dimensionally unified" version: first commit

Revision 1.5  2004/03/05 17:51:28  tarini
Errorino "ScalarType" -> "S"

Revision 1.4  2004/03/03 14:32:13  cignoni
Yet another cr lf mismatch

Revision 1.3  2004/02/23 23:44:21  cignoni
cr lf mismatch

Revision 1.2  2004/02/19 15:40:56  cignoni
Added doxygen groups

Revision 1.1  2004/02/13 02:16:22  cignoni
First working release.


****************************************************************************/


#ifndef __VCGLIB_BOX
#define __VCGLIB_BOX

#include <vcg/space/point.h>
#include <vcg/space/space.h>
#include <vcg/math/linear.h>

namespace vcg {

template <int N, class S>
class Box : public Space<N,S> , Linear<Box>
{
public:
        typedef S          ScalarType;
        typedef Point<N,S> ParamType;
        typedef Point<N,S> PointType;
        enum {Dimension=N};

protected:
  Point3<S> _min;
        Point3<S> _max;

public:

  inline const PointType &Max() const { return _max; } 
  inline PointType &Max() { return _max; } 
  inline const PointType &Min() const { return _min; } 
  inline PointType &Min() { return _min; } 

        inline  Box() { 
                _min.X()= 1;_max.X()= -1;
                _min.Y()= 1;_max.Y()= -1;
                if (N>2) {_min.Z()= 1;_max.Z()= -1;}
        }
        inline  Box( const PointType & mi, const PointType & ma ) { _min = mi; _max = ma; }
        inline ~Box() { }
        inline bool operator == ( Box const & p ) const
        {
                return _min==p._min && _max==p._max;
        }
        inline bool operator != ( Box const & p ) const
        {
                return _min!=p._min || _max!=p._max;
        }
        void Inflate( const S s )
        {
                Inflate( (_max-_min)*s );
        }
        void InflateFix( const S s )
        {
                S k = Diag()*s;
                 if (N==2) Inflate( PointType (k,k));
                 if (N==3) Inflate( PointType (k,k,k));
        }
        void Inflate( const PointType & delta )
        {
                _min -= delta;
                _max += delta;
        }
        void Set( const PointType & p )
        {
                _min = _max = p;
        }
        void SetNull()
        {
                _min.X()= 1; _max.X()= -1;
                _min.Y()= 1; _max.Y()= -1;
                _min.Z()= 1; _max.Z()= -1;
        }
        void Add( Box const & b )
        {
                if(IsNull()) *this=b;
                else
                        Add(_min); Add(_max);
        }
        void Add( const PointType & p )
        {
                if(IsNull()) Set(p);
                else 
                {
                        if(_min.X() > p.X()) _min.X() = p.X();
                        else if(_max.X() < p.X()) _max.X() = p.X();
                        if(_min.Y() > p.Y()) _min.Y() = p.Y();
                        else if(_max.Y() < p.Y()) _max.Y() = p.Y();
                        if (N>2) {
                                if(_min.Z() > p.Z()) _min.Z() = p.Z();
                                else if(_max.Z() < p.Z()) _max.Z() = p.Z();
                        };
                }
        }
        void Intersect( const Box & b )
        {
                if(_min.X() < b._min.X()) _min.X() = b._min.X();
                if(_min.Y() < b._min.Y()) _min.Y() = b._min.Y();
                if (N>2) if(_min.Z() < b._min.Z()) _min.Z() = b._min.Z();

                if(_max.X() > b._max.X()) _max.X() = b._max.X();
                if(_max.Y() > b._max.Y()) _max.Y() = b._max.Y();
                if (N>2) if(_max.Z() > b._max.Z()) _max.Z() = b._max.Z();

                if(_min.X()>_max.X() || _min.Y()>_max.Y() ) SetNull();
                else if (N>2) if (_min.Z()>_max.Z()) SetNull();
        }
        void Translate( const PointType & p )
        {
                _min += p;
                _max += p;
        }
        bool IsIn( PointType const & p ) const
        {
                if (N==2) return (
                        _min.X() <= p.X() && p.X() <= _max.X() &&
                        _min.Y() <= p.Y() && p.Y() <= _max.Y() 
                ); 
                if (N==3) return (
                        _min.X() <= p.X() && p.X() <= _max.X() &&
                        _min.Y() <= p.Y() && p.Y() <= _max.Y() &&
                        _min.Z() <= p.Z() && p.Z() <= _max.Z()
                );      
        }
        bool IsInEx( PointType const & p ) const
        {
                if (N==2) return (
                        _min.X() <= p.X() && p.X() < _max.X() &&
                        _min.Y() <= p.Y() && p.Y() < _max.Y() 
                ); 
                if (N==3) return (
                        _min.X() <= p.X() && p.X() < _max.X() &&
                        _min.Y() <= p.Y() && p.Y() < _max.Y() &&
                        _min.Z() <= p.Z() && p.Z() < _max.Z()
                );      
        }
        bool Collide(Box const &b)
        {
                return b._min.X()<_max.X() && b._max.X()>_min.X() &&
                           b._min.Y()<_max.Y() && b._max.Y()>_min.Y() &&
                           b._min.Z()<_max.Z() && b._max.Z()>_min.Z() ;
        }
        bool IsNull() const { return _min.X()>_max.X() || _min.Y()>_max.Y() || _min.Z()>_max.Z(); }
        bool IsEmpty() const { return _min==_max; }
        S Diag() const
        {
                return Distance(_min,_max);
        }
        S SquaredDiag() const
        {
                return SquaredDistance(_min,_max);
        }
        PointType Center() const
        {
                return (_min+_max)/2;
        }

        PointType LocalToGlobal(PointType const & p) const{
                return PointType( 
                        _min[0] + p[0]*(_max[0]-_min[0]), 
                        _min[1] + p[1]*(_max[1]-_min[1]),
                        _min[2] + p[2]*(_max[2]-_min[2]));
        }
        PointType GlobalToLocal(PointType const & p) const{
                return PointType( 
                  (p[0]-_min[0])/(_max[0]-_min[0]), 
                  (p[1]-_min[1])/(_max[1]-_min[1]), 
                  (p[2]-_min[2])/(_max[2]-_min[2])
                        );
        }
        inline S Volume() const
        {
                if (N==2) return (_max.X()-_min.X())*(_max.Y()-_min.Y());
                if (N==3) return (_max.X()-_min.X())*(_max.Y()-_min.Y())*(_max.Z()-_min.Z());
        }
        inline S Area() const {
                return Volume();
        };
        PointType Size() const
        {
                return (_max-_min);
        }               
        inline S SizeX() const { return _max.X()-_min.X();}
        inline S SizeY() const { return _max.Y()-_min.Y();}
        inline S SizeZ() const { static_assert(N>2); return _max.Z()-_min.Z();}


        inline void Zero()
        {
                _min.SetZero();
                _max.SetZero();
        }
        inline Box operator + ( Box const & p) const
        {
                return Box(_min+p._min,_max+p._max);
        }
        inline Box operator - ( Box const & p) const
        {
                return Box(_min-p._min,_max-p._max);
        }
        inline Box operator * ( const S s ) const
        {
                return Box(_min*s,_max*s);
        }
        inline Box operator / ( const S s ) const
        {
                S inv=S(1.0)/s;
                return Box(_min*inv,_max*inv);
        }
        inline Box & operator += ( Box const & p)
        {
                _min+=p._min; _max+=p._max;     return *this;
        }
        inline Box & operator -= ( Box const & p)
        {
                _min-=p._min; _max-=p._max;     return *this;
        }
        inline Box & operator *= ( const S s )
        {
                _min*=s; _max*=s;       return *this;
        }
        inline Box & operator /= ( const S s )
        {
                S inv=S(1.0)/s;
                _min*=s; _max*=s;       return *this;
                return *this;
        }
        inline Box operator - () const
        {
                return Box(-_min,-_max);
        }



        template <int N0, class S0>
        inline void Import( const Box<N0,S0> & b )
        { _max.Import( b._max );_min.Import( b._min );
        }
        template <int N0, class S0>
        static Box Construct( const Box<N0,S0> & b )
        { 
                return Box(PointType::Construct(b._min),PointType::Construct(b._max));
        }       


}; // end class definition




typedef Box<3,short>  Box3s;
typedef Box<3,int>        Box3i;
typedef Box<3,float>  Box3f;
typedef Box<3,double> Box3d;

typedef Box<2,short>  Box2s;
typedef Box<2,int>        Box2i;
typedef Box<2,float>  Box2f;
typedef Box<2,double> Box2d;


} // end namespace
#endif