ArraySamplers.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_ARRAY_SAMPLERS_HPP
#define CUBBYFLOW_ARRAY_SAMPLERS_HPP
 
#include <Core/Array/ArrayView.hpp>
 
#include <functional>
 
namespace CubbyFlow
{
template <typename T, size_t N>
class NearestArraySampler final
{
 public:
    static_assert(N > 0, "Dimension should be greater than 0");
 
    using ScalarType = typename GetScalarType<T>::value;
 
    static_assert(std::is_floating_point<ScalarType>::value,
                  "NearestArraySampler only can be instantiated with floating "
                  "point types");
 
    using VectorType = Vector<ScalarType, N>;
    using CoordIndexType = Vector<size_t, N>;
 
    NearestArraySampler() = default;
 
    explicit NearestArraySampler(const ArrayView<const T, N>& view,
                                 const VectorType& gridSpacing,
                                 const VectorType& gridOrigin);
 
    ~NearestArraySampler() = default;
 
    NearestArraySampler(const NearestArraySampler& other);
 
    NearestArraySampler(NearestArraySampler&& other) noexcept;
 
    NearestArraySampler& operator=(const NearestArraySampler& other);
 
    NearestArraySampler& operator=(NearestArraySampler&& other) noexcept;
 
    T operator()(const VectorType& pt) const;
 
    CoordIndexType GetCoordinate(const VectorType& pt) const;
 
    [[nodiscard]] std::function<T(const VectorType&)> Functor() const;
 
 private:
    ArrayView<const T, N> m_view;
    VectorType m_gridSpacing;
    VectorType m_invGridSpacing;
    VectorType m_gridOrigin;
};
 
template <typename T>
using NearestArraySampler1 = NearestArraySampler<T, 1>;
 
template <typename T>
using NearestArraySampler2 = NearestArraySampler<T, 2>;
 
template <typename T>
using NearestArraySampler3 = NearestArraySampler<T, 3>;
 
template <typename T, size_t N>
class LinearArraySampler final
{
 public:
    static_assert(N > 0, "N should be greater than 0");
 
    using ScalarType = typename GetScalarType<T>::value;
 
    static_assert(std::is_floating_point<ScalarType>::value,
                  "LinearArraySampler only can be instantiated with floating "
                  "point types");
 
    using VectorType = Vector<ScalarType, N>;
    using CoordIndexType = Vector<size_t, N>;
 
    static constexpr size_t FLAT_KERNEL_SIZE = 1 << N;
 
    LinearArraySampler() = default;
 
    explicit LinearArraySampler(const ArrayView<const T, N>& view,
                                const VectorType& gridSpacing,
                                const VectorType& gridOrigin);
 
    ~LinearArraySampler() = default;
 
    LinearArraySampler(const LinearArraySampler& other);
 
    LinearArraySampler(LinearArraySampler&& other) noexcept;
 
    LinearArraySampler& operator=(const LinearArraySampler& other);
 
    LinearArraySampler& operator=(LinearArraySampler&& other) noexcept;
 
    T operator()(const VectorType& pt) const;
 
    void GetCoordinatesAndWeights(
        const VectorType& pt,
        std::array<CoordIndexType, FLAT_KERNEL_SIZE>& indices,
        std::array<ScalarType, FLAT_KERNEL_SIZE>& weights) const;
 
    void GetCoordinatesAndGradientWeights(
        const VectorType& pt,
        std::array<CoordIndexType, FLAT_KERNEL_SIZE>& indices,
        std::array<VectorType, FLAT_KERNEL_SIZE>& weights) const;
 
    [[nodiscard]] std::function<T(const VectorType&)> Functor() const;
 
 private:
    ArrayView<const T, N> m_view;
    VectorType m_gridSpacing;
    VectorType m_invGridSpacing;
    VectorType m_gridOrigin;
};
 
template <typename T>
using LinearArraySampler1 = LinearArraySampler<T, 1>;
 
template <typename T>
using LinearArraySampler2 = LinearArraySampler<T, 2>;
 
template <typename T>
using LinearArraySampler3 = LinearArraySampler<T, 3>;
 
template <typename T, size_t N, typename CubicInterpolationOp>
class CubicArraySampler final
{
 public:
    static_assert(N > 0, "N should be greater than 0");
 
    using ScalarType = typename GetScalarType<T>::value;
 
    static_assert(std::is_floating_point<ScalarType>::value,
                  "CubicArraySampler only can be instantiated with floating "
                  "point types");
 
    using VectorType = Vector<ScalarType, N>;
    using CoordIndexType = Vector<size_t, N>;
 
    CubicArraySampler() = default;
 
    explicit CubicArraySampler(const ArrayView<const T, N>& view,
                               const VectorType& gridSpacing,
                               const VectorType& gridOrigin);
 
    ~CubicArraySampler() = default;
 
    CubicArraySampler(const CubicArraySampler& other);
 
    CubicArraySampler(CubicArraySampler&& other) noexcept;
 
    CubicArraySampler& operator=(const CubicArraySampler& other);
 
    CubicArraySampler& operator=(CubicArraySampler&& other) noexcept;
 
    T operator()(const VectorType& pt) const;
 
    [[nodiscard]] std::function<T(const VectorType&)> Functor() const;
 
 private:
    ArrayView<const T, N> m_view;
    VectorType m_gridSpacing;
    VectorType m_invGridSpacing;
    VectorType m_gridOrigin;
};
 
template <typename T>
struct DoCatmullRom
{
    using ScalarType = typename GetScalarType<T>::value;
 
    T operator()(const T& f0, const T& f1, const T& f2, const T& f3,
                 ScalarType t) const
    {
        return CatmullRom(f0, f1, f2, f3, t);
    }
};
 
template <typename T>
struct DoMonotonicCatmullRom
{
    using ScalarType = typename GetScalarType<T>::value;
 
    T operator()(const T& f0, const T& f1, const T& f2, const T& f3,
                 ScalarType t) const
    {
        return MonotonicCatmullRom(f0, f1, f2, f3, t);
    }
};
 
template <typename T>
using CatmullRomArraySampler1 = CubicArraySampler<T, 1, DoCatmullRom<T>>;
 
template <typename T>
using CatmullRomArraySampler2 = CubicArraySampler<T, 2, DoCatmullRom<T>>;
 
template <typename T>
using CatmullRomArraySampler3 = CubicArraySampler<T, 3, DoCatmullRom<T>>;
 
template <typename T>
using MonotonicCatmullRomArraySampler1 =
    CubicArraySampler<T, 1, DoMonotonicCatmullRom<T>>;
 
template <typename T>
using MonotonicCatmullRomArraySampler2 =
    CubicArraySampler<T, 2, DoMonotonicCatmullRom<T>>;
 
template <typename T>
using MonotonicCatmullRomArraySampler3 =
    CubicArraySampler<T, 3, DoMonotonicCatmullRom<T>>;
}  // namespace CubbyFlow
 
#include <Core/Array/ArraySamplers-Impl.hpp>
 
#endif