ScalarGrid3.h

Go to the documentation of this file.

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

#include <Core/Array/Array3.h>
#include <Core/Array/ArrayAccessor3.h>
#include <Core/Array/ArraySamplers3.h>
#include <Core/Field/ScalarField3.h>
#include <Core/Grid/Grid3.h>

namespace CubbyFlow
{
    class ScalarGrid3 : public ScalarField3, public Grid3
    {
    public:
        using ScalarDataAccessor = ArrayAccessor3<double>;

        using ConstScalarDataAccessor = ConstArrayAccessor3<double>;

        ScalarGrid3();

        virtual ~ScalarGrid3();

        virtual Size3 GetDataSize() const = 0;

        virtual Vector3D GetDataOrigin() const = 0;

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

        void Clear();

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

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

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

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

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

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

        Vector3D GradientAtDataPoint(size_t i, size_t j, size_t k) const;

        double LaplacianAtDataPoint(size_t i, size_t j, size_t k) const;

        ScalarDataAccessor GetDataAccessor();

        ConstScalarDataAccessor GetConstDataAccessor() const;

        DataPositionFunc GetDataPosition() const;

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

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

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

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

        // ScalarField3 implementations

        double Sample(const Vector3D& x) const override;

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

        Vector3D Gradient(const Vector3D& x) const override;

        double Laplacian(const Vector3D& x) const override;

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

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

    protected:
        void SwapScalarGrid(ScalarGrid3* other);

        void SetScalarGrid(const ScalarGrid3& other);

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

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

    private:
        Array3<double> m_data;
        LinearArraySampler3<double, double> m_linearSampler;
        std::function<double(const Vector3D&)> m_sampler;

        void ResetSampler();
    };

    using ScalarGrid3Ptr = std::shared_ptr<ScalarGrid3>;

    class ScalarGridBuilder3
    {
    public:
        ScalarGridBuilder3();

        virtual ~ScalarGridBuilder3();

        virtual ScalarGrid3Ptr Build(
            const Size3& resolution,
            const Vector3D& gridSpacing,
            const Vector3D& gridOrigin,
            double initialVal) const = 0;
    };

    using ScalarGridBuilder3Ptr = std::shared_ptr<ScalarGridBuilder3>;
}

#endif