Grid.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_GRID_HPP
#define CUBBYFLOW_GRID_HPP
 
#include <Core/Geometry/BoundingBox.hpp>
#include <Core/Matrix/Matrix.hpp>
#include <Core/Utils/Serialization.hpp>
 
#include <string>
 
namespace CubbyFlow
{
template <size_t N>
class GridDataPositionFunc final
{
 public:
    using RawFunctionType =
        std::function<Vector<double, N>(const Vector<size_t, N>&)>;
 
    GridDataPositionFunc(const RawFunctionType& func) : m_func(func)
    {
        // Do nothing
    }
 
    template <typename... Indices>
    Vector<double, N> operator()(size_t i, Indices... indices) const
    {
        return (*this)(Vector<size_t, N>(i, indices...));
    }
 
    Vector<double, N> operator()(const Vector<size_t, N>& idx) const
    {
        return m_func(idx);
    }
 
 private:
    RawFunctionType m_func;
};
 
template <size_t N>
class Grid : public Serializable
{
 public:
    Grid() = default;
 
    ~Grid() override = default;
 
    Grid(const Grid& other);
 
    Grid(Grid&& other) noexcept;
 
    Grid& operator=(const Grid& other);
 
    Grid& operator=(Grid&& other) noexcept;
 
    [[nodiscard]] virtual std::string TypeName() const = 0;
 
    [[nodiscard]] const Vector<size_t, N>& Resolution() const;
 
    [[nodiscard]] const Vector<double, N>& Origin() const;
 
    [[nodiscard]] const Vector<double, N>& GridSpacing() const;
 
    [[nodiscard]] const BoundingBox<double, N>& GetBoundingBox() const;
 
    [[nodiscard]] GridDataPositionFunc<N> CellCenterPosition() const;
 
    void ForEachCellIndex(
        const std::function<void(const Vector<size_t, N>&)>& func) const;
 
    template <size_t M = N>
    std::enable_if_t<M == 2, void> ForEachCellIndex(
        const std::function<void(size_t, size_t)>& func) const
    {
        ForEachCellIndex([&func](const Vector2UZ& idx) { func(idx.x, idx.y); });
    }
 
    template <size_t M = N>
    std::enable_if_t<M == 3, void> ForEachCellIndex(
        const std::function<void(size_t, size_t, size_t)>& func) const
    {
        ForEachCellIndex(
            [&func](const Vector3UZ& idx) { func(idx.x, idx.y, idx.z); });
    }
 
    void ParallelForEachCellIndex(
        const std::function<void(const Vector<size_t, N>&)>& func) const;
 
    template <size_t M = N>
    std::enable_if_t<M == 2, void> ParallelForEachCellIndex(
        const std::function<void(size_t, size_t)>& func) const
    {
        ParallelForEachCellIndex(
            [&func](const Vector2UZ& idx) { func(idx.x, idx.y); });
    }
 
    template <size_t M = N>
    std::enable_if_t<M == 3, void> ParallelForEachCellIndex(
        const std::function<void(size_t, size_t, size_t)>& func) const
    {
        ParallelForEachCellIndex(
            [&func](const Vector3UZ& idx) { func(idx.x, idx.y, idx.z); });
    }
 
    [[nodiscard]] bool HasSameShape(const Grid& other) const;
 
    virtual void Swap(Grid* other) = 0;
 
 protected:
    void SetSizeParameters(const Vector<size_t, N>& resolution,
                           const Vector<double, N>& gridSpacing,
                           const Vector<double, N>& origin);
 
    void SwapGrid(Grid* other);
 
    void SetGrid(const Grid& other);
 
    virtual void GetData(Array1<double>& data) const = 0;
 
    virtual void SetData(const ConstArrayView1<double>& data) = 0;
 
 private:
    Vector<size_t, N> m_resolution;
    Vector<double, N> m_gridSpacing = Vector<double, N>::MakeConstant(1);
    Vector<double, N> m_origin;
    BoundingBox<double, N> m_boundingBox =
        BoundingBox<double, N>{ Vector<double, N>{}, Vector<double, N>{} };
};
 
using Grid2 = Grid<2>;
 
using Grid3 = Grid<3>;
 
using Grid2Ptr = std::shared_ptr<Grid2>;
 
using Grid3Ptr = std::shared_ptr<Grid3>;
 
#define CUBBYFLOW_GRID_TYPE_NAME(DerivedClassName, N)   \
    [[nodiscard]] std::string TypeName() const override \
    {                                                   \
        return #DerivedClassName + std::to_string(N);   \
    }
}  // namespace CubbyFlow
 
#endif