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