meshing.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
 
#include <smgl/Node.hpp>
 
#include "vc/core/filesystem.hpp"
#include "vc/core/types/ITKMesh.hpp"
#include "vc/core/types/Volume.hpp"
#include "vc/core/util/MeshMath.hpp"
#include "vc/meshing/ACVD.hpp"
#include "vc/meshing/LaplacianSmooth.hpp"
#include "vc/meshing/OrderedPointSetMesher.hpp"
#include "vc/meshing/OrientNormals.hpp"
#include "vc/meshing/UVMapToITKMesh.hpp"
 
namespace volcart
{
 
class MeshingNode : public smgl::Node
{
private:
    using Mesher = meshing::OrderedPointSetMesher;
    Mesher mesher_;
    ITKMesh::Pointer mesh_;
 
public:
    smgl::InputPort<Mesher::PointSet> points;
    smgl::OutputPort<ITKMesh::Pointer> mesh;
 
    MeshingNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class ScaleMeshNode : public smgl::Node
{
private:
    ITKMesh::Pointer input_;
    double scaleFactor_{1};
    ITKMesh::Pointer output_;
 
public:
    smgl::InputPort<ITKMesh::Pointer> input;
    smgl::InputPort<double> scaleFactor;
    smgl::OutputPort<ITKMesh::Pointer> output;
 
    ScaleMeshNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class CalculateNumVertsNode : public smgl::Node
{
private:
    ITKMesh::Pointer mesh_{nullptr};
    double voxelSize_{100};
    double density_{50};
    std::size_t numVerts_{0};
 
public:
    smgl::InputPort<ITKMesh::Pointer> mesh;
    smgl::InputPort<double> voxelSize;
    smgl::InputPort<double> density;
    smgl::OutputPort<std::size_t> numVerts;
 
    CalculateNumVertsNode();
 
private:
    auto serialize_(bool /*useCache*/, const filesystem::path& /*cacheDir*/)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class LaplacianSmoothMeshNode : public smgl::Node
{
private:
    using Smoother = meshing::LaplacianSmooth;
    Smoother smoother_;
    ITKMesh::Pointer mesh_;
 
public:
    smgl::InputPort<ITKMesh::Pointer> input;
    smgl::OutputPort<ITKMesh::Pointer> output;
 
    LaplacianSmoothMeshNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class ResampleMeshNode : public smgl::Node
{
private:
    using ACVD = meshing::ACVD;
    ACVD acvd_;
    ITKMesh::Pointer mesh_;
 
public:
    using Mode = ACVD::Mode;
 
    smgl::InputPort<ITKMesh::Pointer> input;
    smgl::InputPort<Mode> mode;
    smgl::InputPort<std::size_t> numVertices;
    smgl::InputPort<double> gradation;
    smgl::InputPort<std::size_t> subsampleThreshold;
    smgl::InputPort<std::size_t> quadricsOptimizationLevel;
    smgl::OutputPort<ITKMesh::Pointer> output;
 
    ResampleMeshNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class UVMapToMeshNode : public smgl::Node
{
private:
    meshing::UVMapToITKMesh mesher_{};
    bool scaleDims_{false};
    ITKMesh::Pointer output_{nullptr};
 
public:
    smgl::InputPort<ITKMesh::Pointer> inputMesh;
    smgl::InputPort<UVMap::Pointer> uvMap;
    smgl::InputPort<bool> scaleToUVDimensions;
    smgl::OutputPort<ITKMesh::Pointer> outputMesh;
 
    UVMapToMeshNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class OrientNormalsNode : public smgl::Node
{
private:
    using OrientNormals = meshing::OrientNormals;
    OrientNormals orientNormals_{};
    ITKMesh::Pointer output_{nullptr};
 
public:
    using ReferenceMode = OrientNormals::ReferenceMode;
 
    smgl::InputPort<ITKMesh::Pointer> input;
    smgl::InputPort<ReferenceMode> referenceMode;
    smgl::InputPort<cv::Vec3d> referencePoint;
    smgl::OutputPort<ITKMesh::Pointer> output;
 
    OrientNormalsNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
}  // namespace volcart