glc_boundingbox.h

Go to the documentation of this file.

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

 This file is part of the GLC-lib library.
 Copyright (C) 2005-2008 Laurent Ribon (laumaya@users.sourceforge.net)
 Version 2.0.0 Beta 1, packaged on April 2010.

 http://glc-lib.sourceforge.net

 GLC-lib 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.

 GLC-lib 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 for more details.

 You should have received a copy of the GNU General Public License
 along with GLC-lib; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

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


#ifndef GLC_BOUNDINGBOX_
#define GLC_BOUNDINGBOX_

#include "maths/glc_vector3d.h"
#include "maths/glc_utils_maths.h"
#include "maths/glc_matrix4x4.h"
#include <QtDebug>
#include "glc_config.h"




class GLC_LIB_EXPORT GLC_BoundingBox
{
        friend QDataStream &operator<<(QDataStream &, const GLC_BoundingBox &);
        friend QDataStream &operator>>(QDataStream &, GLC_BoundingBox &);



public:
        GLC_BoundingBox();

        GLC_BoundingBox(const GLC_BoundingBox& boundingBox);

        GLC_BoundingBox(const GLC_Point3d& lower, const GLC_Point3d& upper);




public:
        static quint32 chunckID();

        bool isEmpty(void) const
        {
                return m_IsEmpty;
        }

        bool intersect(const GLC_Point3d& point) const;

        inline bool intersect(const GLC_BoundingBox& boundingBox) const;

        bool intersectBoundingSphere(const GLC_Point3d&) const;

        bool intersectBoundingSphere(const GLC_BoundingBox&) const;

        inline const GLC_Point3d& lowerCorner() const
        {return m_Lower;}

        inline const GLC_Point3d& upperCorner() const
        {return m_Upper;}

        inline GLC_Point3d center() const;

        inline double boundingSphereRadius() const
        {return GLC_Vector3d(m_Lower - m_Upper).length() / 2.0;}

        inline bool operator == (const GLC_BoundingBox& boundingBox);

        inline bool operator != (const GLC_BoundingBox& boundingBox)
        {return !(*this == boundingBox);}

        inline double xLength() const
        {return fabs(m_Upper.x() - m_Lower.x());}

        inline double yLength() const
        {return fabs(m_Upper.y() - m_Lower.y());}

        inline double zLength() const
        {return fabs(m_Upper.z() - m_Lower.z());}





public:
        GLC_BoundingBox& combine(const GLC_Point3d& point);

        GLC_BoundingBox& combine(const GLC_Point3df& point);

        GLC_BoundingBox& combine(const GLC_BoundingBox& box);

        GLC_BoundingBox& transform(const GLC_Matrix4x4& matrix);


// Private members
private:
        GLC_Point3d m_Lower;

        GLC_Point3d m_Upper;

        bool m_IsEmpty;

        static quint32 m_ChunkId;
};

QDataStream &operator<<(QDataStream &, const GLC_BoundingBox &);
QDataStream &operator>>(QDataStream &, GLC_BoundingBox &);

// Return true if the given bounding box intersect this bounding box
bool GLC_BoundingBox::intersect(const GLC_BoundingBox& boundingBox) const
{
        // Distance between bounding box center
        GLC_Vector3d thisCenter= center();
        GLC_Vector3d otherCenter= boundingBox.center();
        const double distanceX= fabs(thisCenter.x() - otherCenter.x());
        const double distanceY= fabs(thisCenter.y() - otherCenter.y());
        const double distanceZ= fabs(thisCenter.z() - otherCenter.z());

        bool intersect= distanceX < ((xLength() + boundingBox.xLength()) * 0.5);
        intersect= intersect && (distanceY < ((yLength() + boundingBox.yLength()) * 0.5));
        intersect= intersect && (distanceZ < ((zLength() + boundingBox.zLength()) * 0.5));
        return intersect;
}

bool GLC_BoundingBox::operator == (const GLC_BoundingBox& box)
{
        return (m_Lower == box.m_Lower) && (m_Upper == box.m_Upper);
}

GLC_Point3d GLC_BoundingBox::center(void) const
{
        GLC_Vector3d vectResult = (m_Lower + m_Upper) * 0.5;
        return vectResult;
}

#endif /*GLC_BOUNDINGBOX_*/