TCMathBox.h

Go to the documentation of this file.

//*******************************************************************************
//
// *******   ***   ***               *
//    *     *     *                  *
//    *    *      *                *****
//    *    *       ***  *   *   **   *    **    ***
//    *    *          *  * *   *     *   ****  * * *
//    *     *         *   *      *   * * *     * * *
//    *      ***   ***    *     **   **   **   *   *
//                        *
//*******************************************************************************
// see http://sourceforge.net/projects/tcsystem/ for details.
// Copyright (C) 2003 - 2008 Thomas Goessler. All Rights Reserved. 
//*******************************************************************************
//
// TCSystem is the legal property of its developers.
// Please refer to the COPYRIGHT file distributed with this source distribution.
// 
// This library is free software; you can redistribute it and/or             
// modify it under the terms of the GNU Lesser General Public                
// License as published by the Free Software Foundation; either              
// version 2.1 of the License, or (at your option) any later version.        
//                                                                           
// This library 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         
// Lesser General Public License for more details.                           
//                                                                           
// You should have received a copy of the GNU Lesser General Public          
// License along with this library; if not, write to the Free Software       
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
//*******************************************************************************
//  $Id: TCMathBox.h 833 2008-03-27 21:28:38Z the_____tiger $
//*******************************************************************************

#ifndef _TC_MATH_BOX_H_
#define _TC_MATH_BOX_H_

#include "TCMathCoordUtil.h"
#include "TCMathUtil.h"

#include <limits>
#include <vector>

namespace TC
{
   namespace Math
   {
      template <class COORD_TYPE>
      class Box
      {
      private:
         typedef COORD_TYPE CoordType;
         typedef typename COORD_TYPE::DataType DataType;

      public:
         Box()
         {
         }

         Box(const Box& box)
            :m_min(box.m_min),
            m_max(box.m_max)
         {
         }

         Box(const COORD_TYPE& min, const COORD_TYPE& max)
            :m_min(min),
            m_max(max)
         {
         }

         Box& operator=(const Box& box) 
         {
            m_min    = box.m_min;
            m_max = box.m_max;
            return *this;
         }

         const COORD_TYPE& GetMin() const {return m_min;}
         const COORD_TYPE& GetMax() const {return m_max;}

         void SetMin(const COORD_TYPE& top) {m_min=top;}
         void SetMax(const COORD_TYPE& bottom) {m_max=bottom;}

         COORD_TYPE& operator[](uint32 i){ return (&m_min)[i]; }
         const COORD_TYPE& operator[](uint32 i) const { return (&m_min)[i]; }

         bool operator==(const Box& box) const { return m_min==box.m_min && m_max==box.m_max; }
         bool operator!=(const Box& box) const { return m_min!=box.m_min || m_max!=box.m_max; }


         DataType GetWidth() const { return m_max[0] - m_min[0]; }
         DataType GetHeight() const { return m_max[1] - m_min[1]; }
         DataType GetDepth() const { return m_max[2] - m_min[2]; }

         DataType GetLongest() const
         {
            COORD_TYPE diag = GetDiagonal();
            return Util::Max(diag[0], diag[1], diag[2]);
         }

         DataType GetShortest() const
         {
            COORD_TYPE diag = GetDiagonal();
            return Util::Min(diag[0], diag[1], diag[2]);
         }

         double GetDiameter() const 
         {
            return Distance(m_max, m_min); 
         }
         double GetRadius() const 
         {
            return GetDiameter()/static_cast<DataType>(2); 
         }

         COORD_TYPE GetDiagonal() const {return m_max - m_min;}

         COORD_TYPE GetCenter() const {return (m_max + m_min)/static_cast<DataType>(2);}

         bool IsEmpty() const
         {
            return !((m_min.Length2() + m_max.Length2()) > 0);
         }

         bool Contains(const COORD_TYPE& p) const
         {
            for (uint32 i=0; i<COORD_TYPE::NUM_COMPONENTS; i++)
            {
               bool inside = m_min[i] <= p[i] && p[i] < m_max[i];
               if (!inside)
               {
                  return false;
               }

               return true;
            }
         }

         bool Contains(const Box& r) const
         {
            return Contains(r.m_min) && Contains(r.m_max);
         }

         static Box Unite(const Box& box1, const Box& box2)
         {
            if (box1.IsEmpty())
            {
               return box2;
            }
            else if (box2.IsEmpty())
            {
               return box1;
            }

            COORD_TYPE min = Min(box1.GetMin(), box2.GetMin());
            COORD_TYPE max = Max(box1.GetMax(), box2.GetMax());
            return Box(min, max);
         }

         static Box BoundingBox(const std::vector<COORD_TYPE>& coords)
         {
            COORD_TYPE c_min(std::numeric_limits<DataType>::max());
            COORD_TYPE c_max(std::numeric_limits<DataType>::min());

            typename std::vector<COORD_TYPE>::const_iterator c_it;
            for (c_it= coords.begin(); c_it!=coords.end(); c_it++)
            {
               c_min = Min(c_min, *c_it);
               c_max = Max(c_max, *c_it);
            }

            return Box(c_min, c_max);
         }
      private:
         COORD_TYPE m_min;
         COORD_TYPE m_max;
      };
   }
}
#endif