vcglib: box2.h Source File

00001 /****************************************************************************
00002 * VCGLib                                                            o o     *
00003 * Visual and Computer Graphics Library                            o     o   *
00004 *                                                                _   O  _   *
00005 * Copyright(C) 2004                                                \/)\/    *
00006 * Visual Computing Lab                                            /\/|      *
00007 * ISTI - Italian National Research Council                           |      *
00008 *                                                                    \      *
00009 * All rights reserved.                                                      *
00010 *                                                                           *
00011 * This program is free software; you can redistribute it and/or modify      *   
00012 * it under the terms of the GNU General Public License as published by      *
00013 * the Free Software Foundation; either version 2 of the License, or         *
00014 * (at your option) any later version.                                       *
00015 *                                                                           *
00016 * This program is distributed in the hope that it will be useful,           *
00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
00019 * GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
00020 * for more details.                                                         *
00021 *                                                                           *
00022 ****************************************************************************/
00023 /****************************************************************************
00024   History
00025 
00026 $Log: not supported by cvs2svn $
00027 Revision 1.8  2007/07/02 10:01:00  corsini
00028 fix area
00029 
00030 Revision 1.7  2006/10/07 16:50:26  m_di_benedetto
00031 Added Dim() method.
00032 
00033 Revision 1.6  2005/06/14 13:46:20  ponchio
00034 Minibug: Box2f -> Box2 in the template.
00035 
00036 Revision 1.5  2005/05/06 14:02:37  croccia
00037 replaced all the occurences of min.v[0] with min.X(), max.v[0] with max.X() etc.
00038 
00039 Revision 1.3  2005/05/05 10:20:24  croccia
00040 changed  #include <vcg/space/point3>  to #include <vcg/space/point2.h>
00041 croccia
00042 
00043 Revision 1.2  2004/03/10 21:38:39  cignoni
00044 Written some documentation and added to the space module
00045 
00046 Revision 1.1  2004/02/15 23:34:04  cignoni
00047 Initial commit
00048 
00049 
00050 ****************************************************************************/
00051 
00052 #ifndef __VCGLIB_BOX2
00053 #define __VCGLIB_BOX2
00054 
00055 #include <assert.h>
00056 #include <vcg/math/base.h>
00057 #include <vcg/space/point2.h>
00058 
00059 namespace vcg {
00060 
00061 
00062 // needed prototype;
00063 template <class SegScalarType> class Segment2;
00064 
00071 template <class BoxScalarType>
00072 class Box2
00073 {
00074 public:
00076         typedef BoxScalarType ScalarType;
00077 
00079     Point2<BoxScalarType> min;
00081     Point2<BoxScalarType> max;
00083         inline  Box2() { min.X()= 1; max.X()= -1; min.Y()= 1; max.Y()= -1; }
00085         inline  Box2( const Box2 & b ) { min=b.min; max=b.max; }
00087         inline ~Box2() { }
00089         inline bool operator == ( Box2 const & p ) const
00090         {
00091                 return min==p.min && max==p.max;
00092         }
00094         void Set( const Point2<BoxScalarType> & p )
00095         {
00096                 min = max = p;
00097         }
00098                 // Initializing with the values
00099         inline void Set( BoxScalarType minx, BoxScalarType miny, BoxScalarType maxx, BoxScalarType maxy )
00100         {
00101                 min[0] = minx;
00102                 min[1] = miny;
00103                 max[0] = maxx;
00104                 max[1] = maxy;
00105         }
00107         void SetNull()
00108         {
00109                  min.X()= 1; max.X()= -1; min.Y()= 1; max.Y()= -1;
00110         }
00114         void Add( Box2 const & b )
00115         {
00116                 if(IsNull())
00117                 {
00118                         min=b.min;
00119                         max=b.max;
00120                 }
00121                 else
00122                 {
00123                         if(min.X() > b.min.X()) min.X() = b.min.X();
00124                         if(min.Y() > b.min.Y()) min.Y() = b.min.Y();
00125 
00126                         if(max.X() < b.max.X()) max.X() = b.max.X();
00127                         if(max.Y() < b.max.Y()) max.Y() = b.max.Y();
00128                 }
00129         }
00134         void Add( const Point2<BoxScalarType> & p )
00135         {
00136                 if(IsNull()) Set(p);
00137                 else 
00138                 {
00139                         if(min.X() > p.X()) min.X() = p.X();
00140                         if(min.Y() > p.Y()) min.Y() = p.Y();
00141 
00142                         if(max.X() < p.X()) max.X() = p.X();
00143                         if(max.Y() < p.Y()) max.Y() = p.Y();
00144                 }
00145         }
00146 
00150         void Offset(const BoxScalarType s)
00151         {
00152                 Offset(Point2<BoxScalarType>(s, s));
00153         }
00154 
00158         void Offset(const Point2<BoxScalarType> & delta)
00159         {
00160                 min -= delta;
00161                 max += delta;
00162         }
00163 
00167         void Intersect( const Box2 & b )
00168         {
00169                 if(min.X() < b.min.X()) min.X() = b.min.X();
00170                 if(min.Y() < b.min.Y()) min.Y() = b.min.Y();
00171 
00172                 if(max.X() > b.max.X()) max.X() = b.max.X();
00173                 if(max.Y() > b.max.Y()) max.Y() = b.max.Y();
00174 
00175                 if(min.X()>max.X() || min.Y()>max.Y()) SetNull();
00176         }
00177 
00181         void Translate( const Point2<BoxScalarType> & p )
00182         {
00183                 min += p;
00184                 max += p;
00185         }
00190         bool IsIn( Point2<BoxScalarType> const & p ) const
00191         {
00192                 return (
00193                         min.X() <= p.X() && p.X() <= max.X() &&
00194                         min.Y() <= p.Y() && p.Y() <= max.Y()
00195                 );
00196         }
00201         bool IsInEx( Point2<BoxScalarType> const & p ) const
00202         {
00203                 return  (
00204                         min.X() <= p.X() && p.X() < max.X() &&
00205                         min.Y() <= p.Y() && p.Y() < max.Y() 
00206                 );
00207         }
00213         bool Collide( Box2 const &b )
00214         {
00215                 Box2 bb=*this;
00216                 bb.Intersect(b);
00217                 return bb.IsValid();
00218         }
00222         inline bool IsNull() const { return min.X()>max.X() || min.Y()>max.Y(); }
00226         inline bool IsValid() const { return min.X()<max.X() && min.Y()<max.Y(); }
00230         inline bool IsEmpty() const { return min==max; }
00232         BoxScalarType Diag() const
00233         {
00234                 return Distance(min,max);
00235         }
00237         Point2<BoxScalarType> Center() const
00238         {
00239                 return (min+max)/2;
00240         }
00242         inline BoxScalarType Area() const
00243         {
00244                 return (max[0]-min[0])*(max[1]-min[1]);
00245         }
00247         inline BoxScalarType DimX() const { return max.X()-min.X(); }
00249         inline BoxScalarType DimY() const { return max.Y()-min.Y(); }
00250 
00252         inline Point2<BoxScalarType> Dim() const { return max-min; }
00253 
00254         inline void Normalize( Point2<BoxScalarType> & p )
00255         {
00256                 p -= min;
00257                 p[0] /= max[0]-min[0];
00258                 p[1] /= max[1]-min[1];
00259         }
00260 }; // end class definition
00261 
00262 template <class ScalarType> 
00263 ScalarType DistancePoint2Box2(const Point2<ScalarType> &test,
00264                                                           const Box2<ScalarType> &bbox)
00265 {
00267         if (!bbox.IsIn(test)){
00268                 if ((test.X()<=bbox.min.X())&&(test.Y()<=bbox.min.Y()))
00269                         return ((test-bbox.min).Norm());
00270                 else
00271                 if ((test.X()>=bbox.min.X())&&
00272                         (test.X()<=bbox.max.X())&&
00273                         (test.Y()<=bbox.min.Y()))
00274                         return (bbox.min.Y()-test.Y());
00275                 else
00276                 if ((test.X()>=bbox.max.X())&&
00277                         (test.Y()<=bbox.min.Y()))
00278                         return ((test-vcg::Point2<ScalarType>(bbox.max.X(),bbox.min.Y())).Norm());
00279                 else
00280                 if ((test.Y()>=bbox.min.Y())&&
00281                         (test.Y()<=bbox.max.Y())&&
00282                         (test.X()>=bbox.max.X()))
00283                         return (test.X()-bbox.max.X());
00284                 else
00285                 if ((test.X()>=bbox.max.X())&&(test.Y()>=bbox.max.Y()))
00286                         return ((test-bbox.max).Norm());
00287                 else
00288                 if ((test.X()>=bbox.min.X())&&
00289                         (test.X()<=bbox.max.X())&&
00290                         (test.Y()>=bbox.max.Y()))
00291                         return (test.Y()-bbox.max.Y());
00292                 else
00293                 if ((test.X()<=bbox.min.X())&&
00294                         (test.Y()>=bbox.max.Y()))
00295                         return ((test-vcg::Point2<ScalarType>(bbox.min.X(),bbox.max.Y())).Norm());
00296                 else
00297                 if ((test.X()<=bbox.min.X())&&
00298                         (test.Y()<=bbox.max.Y())&&
00299                         (test.Y()>=bbox.min.Y()))
00300                         return (bbox.min.X()-test.X());
00301         }
00302         else
00303         {
00304                 //return minimum distance
00305                 ScalarType dx=std::min<ScalarType>(fabs(test.X()-bbox.min.X()),fabs(bbox.max.X()-test.X()));
00306                 ScalarType dy=std::min<ScalarType>(fabs(test.Y()-bbox.min.Y()),fabs(bbox.max.Y()-test.Y()));
00307                 return(std::min<ScalarType>(dx,dy));
00308         }
00309 }
00310 
00311 template <class ScalarType> 
00312 Point2<ScalarType> ClosestPoint2Box2(const Point2<ScalarType> &test,
00313                                                                                                                                                  const Box2<ScalarType> &bbox)
00314 {
00315         Segment2<ScalarType> Segs[4];
00316         Segs[0].P0()=bbox.min;
00317         Segs[0].P1()=vcg::Point2<ScalarType>(bbox.max.X(),bbox.min.Y());
00318 
00319         Segs[1].P0()=Segs[0].P(1);
00320         Segs[1].P1()=bbox.max;
00321 
00322         Segs[2].P0()=Segs[1].P(1);
00323         Segs[2].P1()=vcg::Point2<ScalarType>(bbox.min.X(),bbox.max.Y());
00324 
00325         Segs[3].P0()=Segs[2].P(1);
00326         Segs[3].P1()=bbox.min;
00327         
00328         Point2<ScalarType> closest=ClosestPoint(Segs[0],test);
00329         ScalarType minDist=(closest-test).Norm();
00330         for (int i=0;i<4;i++)
00331         {
00332                 Point2<ScalarType> test=ClosestPoint(Segs[i],test);
00333                 ScalarType dist=(closest-test).Norm();
00334                 if (dist<minDist)
00335                 {
00336                         minDist=dist;
00337                         closest=test;
00338                 }
00339         }
00340         return closest;
00341 }
00342 
00344 typedef Box2<short>  Box2s;
00346 typedef Box2<int>        Box2i;
00348 typedef Box2<float>  Box2f;
00350 typedef Box2<double> Box2d;
00351 
00353 } // end namespace
00354 
00355 
00356 #endif