ScalarGrid2.h

Go to the documentation of this file.

/*************************************************************************
> File Name: ScalarGrid2.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: Abstract base class for 2-D scalar grid structure.
> Created Time: 2017/07/06
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_SCALAR_GRID2_H
#define CUBBYFLOW_SCALAR_GRID2_H

#include <Core/Array/Array2.h>
#include <Core/Array/ArrayAccessor2.h>
#include <Core/Array/ArraySamplers2.h>
#include <Core/Field/ScalarField2.h>
#include <Core/Grid/Grid2.h>

namespace CubbyFlow
{
    class ScalarGrid2 : public ScalarField2, public Grid2
    {
    public:
        using ScalarDataAccessor = ArrayAccessor2<double>;

        using ConstScalarDataAccessor = ConstArrayAccessor2<double>;

        ScalarGrid2();

        virtual ~ScalarGrid2();

        virtual Size2 GetDataSize() const = 0;

        virtual Vector2D GetDataOrigin() const = 0;

        virtual std::shared_ptr<ScalarGrid2> Clone() const = 0;

        void Clear();

        void Resize(
            size_t resolutionX, size_t resolutionY,
            double gridSpacingX = 1.0, double gridSpacingY = 1.0,
            double originX = 0.0, double originY = 0.0,
            double initialValue = 0.0);

        void Resize(
            const Size2& resolution,
            const Vector2D& gridSpacing = Vector2D(1, 1),
            const Vector2D& origin = Vector2D(),
            double initialValue = 0.0);

        void Resize(
            double gridSpacingX, double gridSpacingY,
            double originX, double originY);

        void Resize(const Vector2D& gridSpacing, const Vector2D& origin);

        const double& operator()(size_t i, size_t j) const;

        double& operator()(size_t i, size_t j);

        Vector2D GradientAtDataPoint(size_t i, size_t j) const;

        double LaplacianAtDataPoint(size_t i, size_t j) const;

        ScalarDataAccessor GetDataAccessor();

        ConstScalarDataAccessor GetConstDataAccessor() const;

        DataPositionFunc GetDataPosition() const;

        void Fill(double value, ExecutionPolicy policy = ExecutionPolicy::Parallel);

        void Fill(const std::function<double(const Vector2D&)>& func, ExecutionPolicy policy = ExecutionPolicy::Parallel);

        void ForEachDataPointIndex(const std::function<void(size_t, size_t)>& func) const;

        void ParallelForEachDataPointIndex(const std::function<void(size_t, size_t)>& func) const;

        // ScalarField2 implementations

        double Sample(const Vector2D& x) const override;

        std::function<double(const Vector2D&)> Sampler() const override;

        Vector2D Gradient(const Vector2D& x) const override;

        double Laplacian(const Vector2D& x) const override;

        void Serialize(std::vector<uint8_t>* buffer) const override;

        void Deserialize(const std::vector<uint8_t>& buffer) override;

    protected:
        void SwapScalarGrid(ScalarGrid2* other);

        void SetScalarGrid(const ScalarGrid2& other);

        void GetData(std::vector<double>* data) const override;

        void SetData(const std::vector<double>& data) override;

    private:
        Array2<double> m_data;
        LinearArraySampler2<double, double> m_linearSampler;
        std::function<double(const Vector2D&)> m_sampler;

        void ResetSampler();
    };

    using ScalarGrid2Ptr = std::shared_ptr<ScalarGrid2>;

    class ScalarGridBuilder2
    {
    public:
        ScalarGridBuilder2();

        virtual ~ScalarGridBuilder2();

        virtual ScalarGrid2Ptr Build(
            const Size2& resolution,
            const Vector2D& gridSpacing,
            const Vector2D& gridOrigin,
            double initialVal) const = 0;
    };

    using ScalarGridBuilder2Ptr = std::shared_ptr<ScalarGridBuilder2>;
}

#endif