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