Density.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_Density_H__
#define __PolyVox_Density_H__

#include "PolyVoxCore/DefaultMarchingCubesController.h" //We'll specialise the controller contained in here

#include "Impl/TypeDef.h"

#include <limits>

#undef min
#undef max

namespace PolyVox
{
    template <typename Type>
    class Density
    {
    public:
        Density() : m_uDensity(0) {}

        Density(Type uDensity) : m_uDensity(uDensity) {}

        // The LowPassFilter uses this to convert between normal and accumulated types.
        template <typename CastType> explicit Density(const Density<CastType>& density)
        {
            m_uDensity = static_cast<Type>(density.getDensity());
        }

        bool operator==(const Density& rhs) const
        {
            return (m_uDensity == rhs.m_uDensity);
        };

        bool operator!=(const Density& rhs) const
        {
            return !(*this == rhs);
        }

        // For densities we can supply mathematical operators which behave in an intuitive way.
        // In particular the ability to add and subtract densities is important in order to
        // apply an averaging filter. The ability to divide by an integer is also needed for
        // this same purpose.
        Density<Type>& operator+=(const Density<Type>& rhs)
        {
            m_uDensity += rhs.m_uDensity;
            return *this;
        }

        Density<Type>& operator-=(const Density<Type>& rhs)
        {
            m_uDensity -= rhs.m_uDensity;
            return *this;
        }

        Density<Type>& operator/=(uint32_t rhs)
        {
            m_uDensity /= rhs;
            return *this;
        }

        Type getDensity() const { return m_uDensity; }
        void setDensity(Type uDensity) { m_uDensity = uDensity; }

        static Type getMaxDensity() { return (std::numeric_limits<Type>::max)(); } 
        static Type getMinDensity() { return (std::numeric_limits<Type>::min)(); }

    private:
        Type m_uDensity;
    };

    template <typename Type>
    Density<Type> operator+(const Density<Type>& lhs, const Density<Type>& rhs)
    {
        Density<Type> result = lhs;
        result += rhs;
        return result;
    }

    template <typename Type>
    Density<Type> operator-(const Density<Type>& lhs, const Density<Type>& rhs)
    {
        Density<Type> result = lhs;
        result -= rhs;
        return result;
    }

    template <typename Type>
    Density<Type> operator/(const Density<Type>& lhs, uint32_t rhs)
    {
        Density<Type> result = lhs;
        result /= rhs;
        return result;
    }

    // These are the predefined density types. The 8-bit types are sufficient for many purposes (including
    // most games) but 16-bit and float types do have uses particularly in medical/scientific visualisation.
    typedef Density<uint8_t> Density8;
    typedef Density<uint16_t> Density16;
    typedef Density<uint32_t> Density32;
    typedef Density<float> DensityFloat;

    template <typename Type>
    class DefaultMarchingCubesController< Density<Type> >
    {
    public:
        typedef Type DensityType;
        typedef float MaterialType;

        DefaultMarchingCubesController(void)
        {
            // Default to a threshold value halfway between the min and max possible values.
            m_tThreshold = (Density<Type>::getMinDensity() + Density<Type>::getMaxDensity()) / 2;
        }

        DefaultMarchingCubesController(DensityType tThreshold)
        {
            m_tThreshold = tThreshold;
        }

        DensityType convertToDensity(Density<Type> voxel)
        {
            return voxel.getDensity();
        }

        MaterialType convertToMaterial(Density<Type> /*voxel*/)
        {
            return 1;
        }

        DensityType getThreshold(void)
        {           
            return m_tThreshold;
        }

        void setThreshold(DensityType tThreshold)
        {
            m_tThreshold = tThreshold;
        }

    private:
        DensityType m_tThreshold;
    };
}

#endif //__PolyVox_Density_H__