MarchingCubes.h

Go to the documentation of this file.

#pragma once
 
#include "objects/containers/Array.h"
#include "objects/geometry/Box.h"
#include "objects/geometry/Triangle.h"
#include "objects/wrappers/Function.h"
 
NAMESPACE_SPH_BEGIN
 
class Storage;
class IScheduler;
 
class Cell {
private:
    StaticArray<Vector, 8> points;
    StaticArray<Float, 8> values;
 
public:
    INLINE Float& value(const Size idx) {
        return values[idx];
    }
 
    INLINE Vector& node(const Size idx) {
        return points[idx];
    }
};
 
class IScalarField : public Polymorphic {
public:
    virtual Float operator()(const Vector& pos) = 0;
};
 
class MarchingCubes {
private:
    IScheduler& scheduler;
 
    Float surfaceLevel;
 
    SharedPtr<IScalarField> field;
 
    Array<Triangle> triangles;
 
    struct {
        Array<Float> phi;
    } cached;
 
    Function<bool(Float progress)> progressCallback = nullptr;
 
public:
    MarchingCubes(IScheduler& scheduler,
        const Float surfaceLevel,
        const SharedPtr<IScalarField>& field,
        Function<bool(Float progress)> progressCallback = nullptr);
 
    void addComponent(const Box& box, const Float gridResolution);
 
    INLINE Array<Triangle>& getTriangles() & {
        return triangles;
    }
 
    INLINE Array<Triangle> getTriangles() && {
        return std::move(triangles);
    }
 
private:
    INLINE void intersectCell(Cell& cell, Array<Triangle>& tri);
 
    Vector interpolate(const Vector& v1, const Float p1, const Vector& v2, const Float p2) const;
 
    template <typename TFunctor>
    bool iterateWithIndices(const Box& box, const Vector& step, TFunctor&& functor);
};
 
struct McConfig {
    Float gridResolution = 1.e2_f;
 
    Float surfaceLevel = 0.12_f;
 
    Float smoothingMult = 1._f;
 
    bool useAnisotropicKernels = false;
 
    Function<bool(Float progress)> progressCallback = nullptr;
};
 
Array<Triangle> getSurfaceMesh(IScheduler& scheduler, const Storage& storage, const McConfig& config);
 
 
NAMESPACE_SPH_END