GriddedMesh.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Design
File: GriddedMesh
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/Model.h>
#include <NDEVR/Geometry.h>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief Converts 1 dimensional index into N dimensional index based on size of each dimension.
    **/
    template<uint01 t_dims>
    class GridIndexing
    {
    public:
        uint04 convertToIndex(const Vector<t_dims, uint04>& location) const
        {
            lib_assert(location < m_size, "Out of bounds grid conversion lookup");
            switch (t_dims)
            {
            case 1: return location[X];
            case 2: return m_size[X] * location[Y] + location[X];
            case 3: return m_size[X] * m_size[Y] * location[Z] + m_size[X] * location[Y] + location[X];
            }
            return Constant<uint04>::Invalid;
        }
        Vector<t_dims, uint04> convertFromIndex(const uint04& location) const
        {
            Vector<t_dims, uint04> vec_location;
            switch (t_dims)
            {
            case 1:
                vec_location[X] = location;
                break;
            case 2:
                vec_location[Y] = location / m_size[X];
                vec_location[X] = location % m_size[X];
                break;
            case 3:
                vec_location[Z] = location / (m_size[X] * m_size[Y]);
                vec_location[Y] = (location / m_size[X]) % m_size[Y];
                vec_location[X] = location % m_size[X];
                break;
            }
            lib_assert(vec_location < m_size, "Out of bounds grid conversion lookup");
            return vec_location;
        }
        static constexpr uint01 getNumberOfCorners()
        {
            switch (t_dims)
            {
            case 1: return 2;
            case 2: return 4;
            case 3: return 8;
            }
            return Constant<uint01>::Invalid;
        }
        void setSize(Vector<t_dims, uint04> index_size)
        {
            m_size = index_size;
        }
    protected:
        Vector<t_dims, uint04> m_size;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Stores a uniform grid of data in N dimensions into a Geometry object
    **/
    template<uint01 t_dims>
    class GridMesh : public GridIndexing<t_dims>
    {
    public:
        GridMesh()
        {}
        explicit GridMesh(const Geometry& model)
            : m_geo(model)
        {}
        bool isValid() const
        {
            return m_geo.isValid();
        }
        void setupVertexTable(Vector<t_dims, uint04> index_size
            , Geometry::VertexMode position
            , Geometry::VertexMode normal    = Geometry::VertexMode::e_no_vertex
            , Geometry::VertexMode color     = Geometry::VertexMode::e_no_vertex
            , Geometry::VertexMode texture   = Geometry::VertexMode::e_no_vertex
            , Geometry::VertexMode tangent   = Geometry::VertexMode::e_no_vertex
            , Geometry::VertexMode bitangent = Geometry::VertexMode::e_no_vertex
            , Geometry::VertexMode bones     = Geometry::VertexMode::e_no_vertex)
        {
            GridIndexing<t_dims>::setSize(index_size);
            //m_geo.setGeometryType(t_dims == 2 ? GeometryType::e_grids : GeometryType::e_block_models);
            m_geo.setGeometryType(GeometryType::e_points);
            uint04 count = index_size.product();
            m_geo.setupVertexTable(count, position, normal, color, texture, tangent, bitangent, bones);
            BitFlag flag(0);
            flag(cast<uint01>(VertexFlags::e_is_hidden), true);
            flag(cast<uint01>(VertexFlags::e_is_filtered), true);
            //flag(VertexBitFlags::e_, true);
            VertexIterator<Vector<t_dims, uint04>> iterator(VertexProperty::Position, m_geo);
            for (uint04 i = 0; i < count; i++)
            {
                iterator.setFlag(i, flag);
                iterator.setVertex(i, GridIndexing<t_dims>::convertFromIndex(i));
            }
            m_geo.updateVertexColumns();
            //m_geo.addPrimitive(PrimitiveProperty::Solid, index_size);
        }
        inline const Vector<t_dims, uint04>& getIndexSize() const
        {
            return GridIndexing<t_dims>::m_size;
        }
 
        
        template<class t_type>
        void setVertex(VertexProperty property, Vector<t_dims, uint04> index, const t_type& vector)
        {
            m_geo.setVertex(property, GridIndexing<t_dims>::convertToIndex(index), vector);
        }
 
        template<class t_type>
        t_type vertex(VertexProperty property, Vector<t_dims, uint04> index) const
        {
            return m_geo.vertex<t_type>(property, GridIndexing<t_dims>::convertToIndex(index));
        }
 
        template<class t_type>
        void setVertexProperty(uint04 property_index, Vector<t_dims, uint04> index, const t_type& value)
        {
            m_geo.setProperty(property_index, GridIndexing<t_dims>::convertToIndex(index), value);
        }
 
        template<class t_type>
        t_type getVertexProperty(uint04 property_index, Vector<t_dims, uint04> index) const
        {
            m_geo.getProperty(property_index, GridIndexing<t_dims>::convertToIndex(index));
        }
 
        template<class t_type>
        t_type interpolateVertex(VertexProperty property, const Vector<t_dims, fltp08>& index, InterpolationValues interpolation = InterpolationValues::e_linear) const
        {
            Vector<t_dims, uint04> size = getIndexSize();
            for (uint01 dim = 0; dim < t_dims; dim++)
            {
                if (index[dim] < 0 || index[dim] > size[dim])
                    return Constant<t_type>::Invalid;
            }
            Vector<t_dims, uint04> discrete = index.template as<t_dims, uint04>();
            Vector<t_dims, fltp08> dt = index - discrete.template as<t_dims, fltp08>();
 
            if (dt == Vector<t_dims, fltp08>(0.0) || interpolation == InterpolationValues::nearest_neighbor)
                return vertex<t_type>(property, discrete);
 
            Vector<GridIndexing<t_dims>::getNumberOfCorners(), fltp08> center;
            for (uint01 i = 0; i < GridIndexing<t_dims>::getNumberOfCorners(); i++)
            {
                Vector<t_dims, uint04> location_sum(0);
                if constexpr (t_dims >= 3)
                    location_sum[Z] = (i / 4) % 2;
                if constexpr (t_dims >= 2)
                    location_sum[Y] = (i / 2) % 2;
                if constexpr (t_dims >= 1)
                    location_sum[X] = (i / 1) % 2;
                if (discrete[X] == size[X] - 1)
                    location_sum[X] = 0;
                if (discrete[Y] == size[Y] - 1)
                    location_sum[Y] = 0;
                center[i] = vertex<t_type>(property, discrete + location_sum);
            }
 
            if (IsInvalid(center))
            {
                return Constant<t_type>::Invalid;
            }
            else if (interpolation == InterpolationValues::e_linear)
            {
                t_type value = 0;
                for (uint01 i = 0; i < GridIndexing<t_dims>::getNumberOfCorners(); i++)
                {
                    Vector<t_dims, uint04> location_sum(0);
                    if constexpr (t_dims >= 3)
                        location_sum[Z] = (i / 4) % 2;
                    if constexpr (t_dims >= 2)
                        location_sum[Y] = (i / 2) % 2;
                    if constexpr (t_dims >= 1)
                        location_sum[X] = (i / 1) % 2;
                    Vector<t_dims, fltp08> location_s = (discrete + location_sum).template as<t_dims, fltp08>();
                    Vector<t_dims, fltp08> difference = (1.0 - abs(location_s - index));
                    value += center[i] * difference.product();
                }
                return value;
            }
            else//bicubic
            {
                /*const uint04 d10 = getZ(discrete_x - 1, discrete_y + 0, d11);
                const uint04 d13 = getZ(discrete_x + 2, discrete_y + 0, d12);
                const uint04 d20 = getZ(discrete_x - 1, discrete_y + 1, d21);
                const uint04 d23 = getZ(discrete_x + 2, discrete_y + 1, d22);
 
                const uint04 d00 = getZ(discrete_x - 1, discrete_y - 1, d10);
                const uint04 d01 = getZ(discrete_x - 0, discrete_y - 1, d11);
                const uint04 d02 = getZ(discrete_x + 1, discrete_y - 1, d12);
                const uint04 d03 = getZ(discrete_x + 2, discrete_y - 1, d02);
 
                const uint04 d30 = getZ(discrete_x - 1, discrete_y + 2, d20);
                const uint04 d31 = getZ(discrete_x - 0, discrete_y + 2, d21);
                const uint04 d32 = getZ(discrete_x + 1, discrete_y + 2, d22);
                const uint04 d33 = getZ(discrete_x + 2, discrete_y + 2, d23);
 
                const fltp08 p0 = (d01 + 0.5 * dx
                * (d02 - d00 + dx * (2.0 * d00 - 5.0 * d01 + 4.0 * d02 - d03 + dx * (3.0 * (d01 - d02) + d03 - d00))));
                const fltp08 p1 = (d11 + 0.5 * dx
                * (d12 - d10 + dx * (2.0 * d10 - 5.0 * d11 + 4.0 * d12 - d13 + dx * (3.0 * (d11 - d12) + d13 - d10))));
                const fltp08 p2 = (d21 + 0.5 * dx
                * (d22 - d20 + dx * (2.0 * d20 - 5.0 * d21 + 4.0 * d22 - d23 + dx * (3.0 * (d21 - d22) + d23 - d20))));
                const fltp08 p3 = (d31 + 0.5 * dx
                * (d32 - d30 + dx * (2.0 * d30 - 5.0 * d31 + 4.0 * d32 - d33 + dx * (3.0 * (d31 - d32) + d33 - d30))));
 
                return (p1 + 0.5f * dy * (p2 - p0 + dy * (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3 + dy * (3.0 * (p1 - p2) + p3 - p0))));*/
            }
            return Constant<t_type>::Invalid;
        }
        Geometry geometry() const { return m_geo; };
    protected:
        Geometry m_geo;
    };
};