Region.h

Go to the documentation of this file.

/*******************************************************************************
Copyright (c) 2005-2009 David Williams

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

    1. The origin of this software must not be misrepresented; you must not
    claim that you wrote the original software. If you use this software
    in a product, an acknowledgment in the product documentation would be
    appreciated but is not required.

    2. Altered source versions must be plainly marked as such, and must not be
    misrepresented as being the original software.

    3. This notice may not be removed or altered from any source
    distribution.   
*******************************************************************************/

#ifndef __PolyVox_Region_H__
#define __PolyVox_Region_H__

#include "Impl/TypeDef.h"

#include "PolyVoxCore/Vector.h"

namespace PolyVox
{
#ifdef SWIG
    class Region
#else
    class POLYVOX_API Region
#endif
    {
    public:

        static const Region MaxRegion;
        static const Region InvertedRegion;

        Region();
        Region(const Vector3DInt32& v3dLowerCorner, const Vector3DInt32& v3dUpperCorner);
        Region(int32_t iLowerX, int32_t iLowerY, int32_t iLowerZ, int32_t iUpperX, int32_t iUpperY, int32_t iUpperZ);

        bool operator==(const Region& rhs) const;
        bool operator!=(const Region& rhs) const;

        int32_t getLowerX(void) const;
        int32_t getLowerY(void) const;
        int32_t getLowerZ(void) const;
        int32_t getUpperX(void) const;
        int32_t getUpperY(void) const;
        int32_t getUpperZ(void) const;

        Vector3DInt32 getLowerCorner(void) const;
        Vector3DInt32 getUpperCorner(void) const;

        int32_t getWidthInVoxels(void) const;
        int32_t getHeightInVoxels(void) const;
        int32_t getDepthInVoxels(void) const;
        Vector3DInt32 getDimensionsInVoxels(void) const;

        int32_t getWidthInCells(void) const;
        int32_t getHeightInCells(void) const;
        int32_t getDepthInCells(void) const;
        Vector3DInt32 getDimensionsInCells(void) const;

        void setLowerX(int32_t iX);
        void setLowerY(int32_t iY);
        void setLowerZ(int32_t iZ);
        void setUpperX(int32_t iX);
        void setUpperY(int32_t iY);
        void setUpperZ(int32_t iZ);

        void setLowerCorner(const Vector3DInt32& v3dLowerCorner);
        void setUpperCorner(const Vector3DInt32& v3dUpperCorner);

        bool containsPoint(float fX, float fY, float fZ, float boundary = 0.0f) const;
        bool containsPoint(const Vector3DFloat& pos, float boundary = 0.0f) const;
        bool containsPoint(int32_t iX, int32_t iY, int32_t iZ, uint8_t boundary = 0) const;
        bool containsPoint(const Vector3DInt32& pos, uint8_t boundary = 0) const;
        bool containsPointInX(float pos, float boundary = 0.0f) const;
        bool containsPointInX(int32_t pos, uint8_t boundary = 0) const;
        bool containsPointInY(float pos, float boundary = 0.0f) const;
        bool containsPointInY(int32_t pos, uint8_t boundary = 0) const;
        bool containsPointInZ(float pos, float boundary = 0.0f) const;
        bool containsPointInZ(int32_t pos, uint8_t boundary = 0) const;

        void accumulate(int32_t iX, int32_t iY, int32_t iZ);
        void accumulate(const Vector3DInt32& v3dPos);
        void accumulate(const Region& reg);

        void cropTo(const Region& other);

        void grow(int32_t iAmount);
        void grow(int32_t iAmountX, int32_t iAmountY, int32_t iAmountZ);
        void grow(const Vector3DInt32& v3dAmount);

        bool isValid(void) const;

        void shift(int32_t iAmountX, int32_t iAmountY, int32_t iAmountZ);
        void shift(const Vector3DInt32& v3dAmount);
        void shiftLowerCorner(int32_t iAmountX, int32_t iAmountY, int32_t iAmountZ);
        void shiftLowerCorner(const Vector3DInt32& v3dAmount);
        void shiftUpperCorner(int32_t iAmountX, int32_t iAmountY, int32_t iAmountZ);
        void shiftUpperCorner(const Vector3DInt32& v3dAmount);      

        void shrink(int32_t iAmount);
        void shrink(int32_t iAmountX, int32_t iAmountY, int32_t iAmountZ);
        void shrink(const Vector3DInt32& v3dAmount);

    private:
        int32_t m_iLowerX;
        int32_t m_iLowerY;
        int32_t m_iLowerZ;
        int32_t m_iUpperX;
        int32_t m_iUpperY;
        int32_t m_iUpperZ;
    };

    // Functions to be inlined to to be in the header rather than the .cpp.
    // 'inline' keyword is used for the definition rather than the declaration.
    // See also http://www.parashift.com/c++-faq-lite/inline-functions.html

    inline int32_t Region::getLowerX(void) const
    {
        return m_iLowerX;
    }

    inline int32_t Region::getLowerY(void) const
    {
        return m_iLowerY;
    }

    inline int32_t Region::getLowerZ(void) const
    {
        return m_iLowerZ;
    }

    inline int32_t Region::getUpperX(void) const
    {
        return m_iUpperX;
    }

    inline int32_t Region::getUpperY(void) const
    {
        return m_iUpperY;
    }

    inline int32_t Region::getUpperZ(void) const
    {
        return m_iUpperZ;
    }

    inline Vector3DInt32 Region::getLowerCorner(void) const
    {
        return Vector3DInt32(m_iLowerX, m_iLowerY, m_iLowerZ);
    }

    inline Vector3DInt32 Region::getUpperCorner(void) const
    {
        return Vector3DInt32(m_iUpperX, m_iUpperY, m_iUpperZ);
    }

    inline int32_t Region::getWidthInVoxels(void) const
    {
        return getWidthInCells() + 1;
    }

    inline int32_t Region::getHeightInVoxels(void) const
    {
        return getHeightInCells() + 1;
    }

    inline int32_t Region::getDepthInVoxels(void) const
    {
        return getDepthInCells() + 1;
    }

    inline Vector3DInt32 Region::getDimensionsInVoxels(void) const
    {
        return getDimensionsInCells() + Vector3DInt32(1, 1, 1);
    }

    inline int32_t Region::getWidthInCells(void) const
    {
        return m_iUpperX - m_iLowerX;
    }

    inline int32_t Region::getHeightInCells(void) const
    {
        return m_iUpperY - m_iLowerY;
    }

    inline int32_t Region::getDepthInCells(void) const
    {
        return m_iUpperZ - m_iLowerZ;
    }

    inline Vector3DInt32 Region::getDimensionsInCells(void) const
    {
        return Vector3DInt32(getWidthInCells(), getHeightInCells(), getDepthInCells());
    }

    inline void Region::setLowerX(int32_t iX)
    {
        m_iLowerX = iX;
    }

    inline void Region::setLowerY(int32_t iY)
    {
        m_iLowerY = iY;
    }

    inline void Region::setLowerZ(int32_t iZ)
    {
        m_iLowerZ = iZ;
    }

    inline void Region::setUpperX(int32_t iX)
    {
        m_iUpperX = iX;
    }

    inline void Region::setUpperY(int32_t iY)
    {
        m_iUpperY = iY;
    }

    inline void Region::setUpperZ(int32_t iZ)
    {
        m_iUpperZ = iZ;
    }

    inline void Region::setLowerCorner(const Vector3DInt32& v3dLowerCorner)
    {
        m_iLowerX = v3dLowerCorner.getX();
        m_iLowerY = v3dLowerCorner.getY();
        m_iLowerZ = v3dLowerCorner.getZ();
    }

    inline void Region::setUpperCorner(const Vector3DInt32& v3dUpperCorner)
    {
        m_iUpperX = v3dUpperCorner.getX();
        m_iUpperY = v3dUpperCorner.getY();
        m_iUpperZ = v3dUpperCorner.getZ();
    }
}

#endif