AACube.h

Go to the documentation of this file.

#ifndef __AACUBE_HEADER__
#define __AACUBE_HEADER__
#include <algorithm>
#include <limits>
#include <utility>
 
namespace GfxTL
{
 
    template <class Point>
    class AACube
    {
    public:
        typedef Point PointType;
        typedef typename Point::ScalarType ScalarType;
 
        enum
        {
            Dim = Point::Dim,
            NCorners = 1 << Point::Dim
        };
 
        AACube();
        AACube(const Point& backBottomLeft, ScalarType width);
        AACube(const Point* points, size_t size);
        AACube(unsigned int box, const AACube<Point>& cube);
 
        template <class Points>
        void Bound(const Points& points, size_t size);
        template <class IteratorT>
        void Bound(IteratorT begin, IteratorT end);
        template <class IteratorT>
        void BoundNonCentered(IteratorT begin, IteratorT end);
        template <class Points>
        void BoundRotationInvariant(const Points& points, size_t size);
        void DividingPlane(unsigned int axis, Point* n, ScalarType* d) const;
        void DividingPlane(unsigned int axis, ScalarType* s);
        void Center(Point* c) const;
        void Center(const Point& c);
        void SubCube(unsigned int box, AACube<Point>* cube) const;
        bool IsSubCube(unsigned int* box, const AACube<Point>& cube) const;
        bool IsInside(const Point& p) const;
        ScalarType Width() const;
        void Width(ScalarType w);
        const Point& LeftBottomBack() const;
        void LeftBottomBack(const Point& lbb);
        Point operator[](int index) const;
        ScalarType DiagLength() const;
        void Inflate(ScalarType v);
        ScalarType Distance(const PointType& p) const;
        ScalarType SqrDistance(const PointType& p) const;
        void Translate(const PointType& t);
        void Scale(ScalarType s);
 
        const Point&
        Min() const
        {
            return _backBottomLeft;
        }
 
        Point&
        Min()
        {
            return _backBottomLeft;
        }
 
        Point
        Max() const
        {
            Point m(_backBottomLeft);
            for (unsigned int i = 0; i < Dim; ++i)
            {
                m[i] += _width;
            }
            return m;
        }
 
    private:
        Point _backBottomLeft;
        ScalarType _width;
    };
 
    template <class Point>
    template <class Points>
    void
    AACube<Point>::Bound(const Points& points, size_t size)
    {
        _width = 0;
        if (size > 0)
        {
            Point pmax, pmin;
            for (unsigned int u = 0; u < Dim; ++u)
            {
                pmax[u] = pmin[u] = points[0][u];
            }
            for (size_t i = 1; i < size; ++i)
            {
                for (unsigned int j = 0; j < Dim; ++j)
                {
                    if (pmin[j] > points[i][j])
                    {
                        pmin[j] = points[i][j];
                    }
                    else if (pmax[j] < points[i][j])
                    {
                        pmax[j] = points[i][j];
                    }
                }
            }
            Point center = pmin + (ScalarType).5 * (pmax - pmin);
            Point r = pmax - center;
            ScalarType rmax = r[0];
            for (unsigned int u = 1; u < Dim; ++u)
                if (r[u] > rmax)
                {
                    rmax = r[u];
                }
            _backBottomLeft = center;
            for (unsigned int u = 0; u < Dim; ++u)
            {
                _backBottomLeft[u] -= rmax;
            }
            _width = 2 * rmax;
        }
    }
 
    template <class Point>
    template <class IteratorT>
    void
    AACube<Point>::Bound(IteratorT begin, IteratorT end)
    {
        _width = 0;
        if (end - begin > 0)
        {
            Point pmax, pmin;
            for (unsigned int u = 0; u < Dim; ++u)
            {
                pmax[u] = pmin[u] = (*begin)[u];
            }
            IteratorT i = begin;
            for (++i; i != end; ++i)
            {
                for (unsigned int j = 0; j < Dim; ++j)
                {
                    if (pmin[j] > (*i)[j])
                    {
                        pmin[j] = (*i)[j];
                    }
                    else if (pmax[j] < (*i)[j])
                    {
                        pmax[j] = (*i)[j];
                    }
                }
            }
            Point center = pmin + (ScalarType).5 * (pmax - pmin);
            Point r = pmax - center;
            ScalarType rmax = r[0];
            for (unsigned int u = 1; u < Dim; ++u)
                if (r[u] > rmax)
                {
                    rmax = r[u];
                }
            _backBottomLeft = center;
            for (unsigned int u = 0; u < Dim; ++u)
            {
                _backBottomLeft[u] -= rmax;
            }
            _width = 2 * rmax;
        }
    }
 
    template <class Point>
    template <class IteratorT>
    void
    AACube<Point>::BoundNonCentered(IteratorT begin, IteratorT end)
    {
        using namespace std;
        _width = 0;
        if (end - begin > 0)
        {
            Point pmax, pmin;
            for (unsigned int u = 0; u < Dim; ++u)
            {
                pmax[u] = pmin[u] = (*begin)[u];
            }
            IteratorT i = begin;
            for (++i; i != end; ++i)
            {
                for (unsigned int j = 0; j < Dim; ++j)
                {
                    if (pmin[j] > (*i)[j])
                    {
                        pmin[j] = (*i)[j];
                    }
                    else if (pmax[j] < (*i)[j])
                    {
                        pmax[j] = (*i)[j];
                    }
                }
            }
            _backBottomLeft = pmin;
            _width = pmax[0] - pmin[0];
            for (unsigned int i = 1; i < Dim; ++i)
            {
                _width = max(_width, pmax[i] - pmin[i]);
            }
        }
    }
 
    template <class Point>
    template <class Points>
    void
    AACube<Point>::BoundRotationInvariant(const Points& points, size_t size)
    {
        _width = 0;
        if (size > 0)
        {
            Point pmax, pmin;
            pmax = pmin = points[0];
            for (size_t i = 1; i < size; ++i)
            {
                for (unsigned int j = 0; j < Dim; ++j)
                {
                    if (pmin[j] > points[i][j])
                    {
                        pmin[j] = points[i][j];
                    }
                    else if (pmax[j] < points[i][j])
                    {
                        pmax[j] = points[i][j];
                    }
                }
            }
            _width = (pmax - pmin).Length();
            Point center = pmin + (ScalarType).5 * (pmax - pmin);
            _backBottomLeft = center;
            for (unsigned int u = 0; u < Dim; ++u)
            {
                _backBottomLeft[u] -= _width / 2;
            }
        }
    }
 
}; // namespace GfxTL
 
#include "AACube.hpp"
 
#endif