ScalarGrid.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_SCALAR_GRID_HPP
#define CUBBYFLOW_SCALAR_GRID_HPP
 
#include <Core/Array/Array.hpp>
#include <Core/Array/ArraySamplers.hpp>
#include <Core/Array/ArrayView.hpp>
#include <Core/Field/ScalarField.hpp>
#include <Core/Grid/Grid.hpp>
 
namespace CubbyFlow
{
template <size_t N>
class ScalarGrid : public ScalarField<N>, public Grid<N>
{
 public:
    using ScalarDataView = ArrayView<double, N>;
 
    using ConstScalarDataView = ArrayView<const double, N>;
 
    // Import Grid members
    using Grid<N>::GridSpacing;
    using Grid<N>::Origin;
    using Grid<N>::Resolution;
 
    ScalarGrid();
 
    ~ScalarGrid() override = default;
 
    ScalarGrid(const ScalarGrid& other);
 
    ScalarGrid(ScalarGrid&& other) noexcept;
 
    ScalarGrid& operator=(const ScalarGrid& other);
 
    ScalarGrid& operator=(ScalarGrid&& other) noexcept;
 
    [[nodiscard]] virtual Vector<size_t, N> DataSize() const = 0;
 
    [[nodiscard]] virtual Vector<double, N> DataOrigin() const = 0;
 
    [[nodiscard]] virtual std::shared_ptr<ScalarGrid> Clone() const = 0;
 
    void Clear();
 
    void Resize(const Vector<size_t, N>& resolution,
                const Vector<double, N>& gridSpacing =
                    Vector<double, N>::MakeConstant(1),
                const Vector<double, N>& origin = Vector<double, N>{},
                double initialValue = 0.0);
 
    void Resize(const Vector<double, N>& gridSpacing,
                const Vector<double, N>& origin);
 
    const double& operator()(const Vector<size_t, N>& idx) const;
 
    double& operator()(const Vector<size_t, N>& idx);
 
    template <typename... Indices>
    const double& operator()(size_t i, Indices... indices) const
    {
        return (*this)(Vector<size_t, N>(i, indices...));
    }
 
    template <typename... Indices>
    double& operator()(size_t i, Indices... indices)
    {
        return (*this)(Vector<size_t, N>(i, indices...));
    }
 
    [[nodiscard]] Vector<double, N> GradientAtDataPoint(
        const Vector<size_t, N>& idx) const;
 
    template <typename... Indices>
    [[nodiscard]] Vector<double, N> GradientAtDataPoint(
        size_t i, Indices... indices) const
    {
        return GradientAtDataPoint(Vector<size_t, N>(i, indices...));
    }
 
    [[nodiscard]] double LaplacianAtDataPoint(
        const Vector<size_t, N>& idx) const;
 
    template <typename... Indices>
    [[nodiscard]] double LaplacianAtDataPoint(size_t i,
                                              Indices... indices) const
    {
        return LaplacianAtDataPoint(Vector<size_t, N>(i, indices...));
    }
 
    [[nodiscard]] ScalarDataView DataView();
 
    [[nodiscard]] ConstScalarDataView DataView() const;
 
    [[nodiscard]] GridDataPositionFunc<N> DataPosition() const;
 
    void Fill(double value, ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
    void Fill(const std::function<double(const Vector<double, N>&)>& func,
              ExecutionPolicy policy = ExecutionPolicy::Parallel);
 
    void ForEachDataPointIndex(
        const std::function<void(const Vector<size_t, N>&)>& func) const;
 
    template <size_t M = N>
    std::enable_if_t<M == 2, void> ForEachDataPointIndex(
        const std::function<void(size_t, size_t)>& func) const
    {
        ForEachDataPointIndex(
            [&func](const Vector2UZ& idx) { func(idx.x, idx.y); });
    }
 
    template <size_t M = N>
    std::enable_if_t<M == 3, void> ForEachDataPointIndex(
        const std::function<void(size_t, size_t, size_t)>& func) const
    {
        ForEachDataPointIndex(
            [&func](const Vector3UZ& idx) { func(idx.x, idx.y, idx.z); });
    }
 
    void ParallelForEachDataPointIndex(
        const std::function<void(const Vector<size_t, N>&)>& func) const;
 
    template <size_t M = N>
    std::enable_if_t<M == 2, void> ParallelForEachDataPointIndex(
        const std::function<void(size_t, size_t)>& func) const
    {
        ParallelForEachDataPointIndex(
            [&func](const Vector2UZ& idx) { func(idx.x, idx.y); });
    }
 
    template <size_t M = N>
    std::enable_if_t<M == 3, void> ParallelForEachDataPointIndex(
        const std::function<void(size_t, size_t, size_t)>& func) const
    {
        ParallelForEachDataPointIndex(
            [&func](const Vector3UZ& idx) { func(idx.x, idx.y, idx.z); });
    }
 
    [[nodiscard]] double Sample(const Vector<double, N>& x) const override;
 
    [[nodiscard]] std::function<double(const Vector<double, N>&)> Sampler()
        const override;
 
    [[nodiscard]] Vector<double, N> Gradient(
        const Vector<double, N>& x) const override;
 
    [[nodiscard]] double Laplacian(const Vector<double, N>& x) const override;
 
    void Serialize(std::vector<uint8_t>* buffer) const override;
 
    void Deserialize(const std::vector<uint8_t>& buffer) override;
 
 protected:
    using Grid<N>::SetSizeParameters;
    using Grid<N>::SwapGrid;
    using Grid<N>::SetGrid;
 
    void SwapScalarGrid(ScalarGrid* other);
 
    void SetScalarGrid(const ScalarGrid& other);
 
    void GetData(Array1<double>& data) const override;
 
    void SetData(const ConstArrayView1<double>& data) override;
 
 private:
    void ResetSampler();
 
    Array<double, N> m_data;
    LinearArraySampler<double, N> m_linearSampler;
    std::function<double(const Vector<double, N>&)> m_sampler;
};
 
using ScalarGrid2 = ScalarGrid<2>;
 
using ScalarGrid3 = ScalarGrid<3>;
 
using ScalarGrid2Ptr = std::shared_ptr<ScalarGrid2>;
 
using ScalarGrid3Ptr = std::shared_ptr<ScalarGrid3>;
 
template <size_t N>
class ScalarGridBuilder
{
 public:
    ScalarGridBuilder() = default;
 
    virtual ~ScalarGridBuilder() = default;
 
    ScalarGridBuilder(const ScalarGridBuilder& other) = delete;
 
    ScalarGridBuilder(ScalarGridBuilder&& other) noexcept = delete;
 
    ScalarGridBuilder& operator=(const ScalarGridBuilder& other) = delete;
 
    ScalarGridBuilder& operator=(ScalarGridBuilder&& other) noexcept = delete;
 
    virtual std::shared_ptr<ScalarGrid<N>> Build(
        const Vector<size_t, N>& resolution,
        const Vector<double, N>& gridSpacing,
        const Vector<double, N>& gridOrigin, double initialVal) const = 0;
};
 
using ScalarGridBuilder2 = ScalarGridBuilder<2>;
 
using ScalarGridBuilder3 = ScalarGridBuilder<3>;
 
using ScalarGridBuilder2Ptr = std::shared_ptr<ScalarGridBuilder2>;
 
using ScalarGridBuilder3Ptr = std::shared_ptr<ScalarGridBuilder3>;
}  // namespace CubbyFlow
 
#endif