core.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
 
#include <opencv2/core.hpp>
#include <smgl/Node.hpp>
 
#include "vc/core/filesystem.hpp"
#include "vc/core/io/ImageIO.hpp"
#include "vc/core/io/MeshIO.hpp"
#include "vc/core/types/ITKMesh.hpp"
#include "vc/core/types/PerPixelMap.hpp"
#include "vc/core/types/Segmentation.hpp"
#include "vc/core/types/Transforms.hpp"
#include "vc/core/types/UVMap.hpp"
#include "vc/core/types/Volume.hpp"
#include "vc/core/types/VolumePkg.hpp"
#include "vc/core/types/VolumetricMask.hpp"
 
namespace volcart
{
 
class LoadVolumePkgNode : public smgl::Node
{
private:
    filesystem::path path_{};
    VolumePkg::Pointer vpkg_{nullptr};
 
public:
    smgl::InputPort<filesystem::path> path;
    smgl::OutputPort<VolumePkg::Pointer> volpkg;
 
    LoadVolumePkgNode();
 
private:
    auto serialize_(bool /*useCache*/, const filesystem::path& /*cacheDir*/)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class VolumePkgPropertiesNode : public smgl::Node
{
private:
    VolumePkg::Pointer vpkg_{nullptr};
 
public:
    smgl::InputPort<VolumePkg::Pointer> volpkg;
    smgl::OutputPort<std::string> name;
    smgl::OutputPort<int> version;
    smgl::OutputPort<double> materialThickness;
 
    VolumePkgPropertiesNode();
};
 
class VolumeSelectorNode : public smgl::Node
{
private:
    VolumePkg::Pointer vpkg_{nullptr};
    Volume::Identifier id_{};
    Volume::Pointer vol_{nullptr};
 
public:
    smgl::InputPort<VolumePkg::Pointer> volpkg;
    smgl::InputPort<Volume::Identifier> id;
    smgl::OutputPort<Volume::Pointer> volume;
 
    VolumeSelectorNode();
 
private:
    auto serialize_(bool /*useCache*/, const filesystem::path& /*cacheDir*/)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class VolumePropertiesNode : public smgl::Node
{
private:
    Volume::Pointer volume_{nullptr};
    std::size_t cacheMem_{2'000'000'000};
 
public:
    smgl::InputPort<Volume::Pointer> volumeIn;
    smgl::InputPort<std::size_t> cacheMemory;
 
    smgl::OutputPort<Volume::Bounds> bounds;
    smgl::OutputPort<double> voxelSize;
    smgl::OutputPort<Volume::Pointer> volumeOut;
 
    VolumePropertiesNode();
 
private:
    auto serialize_(bool /*useCache*/, const filesystem::path& /*cacheDir*/)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class SegmentationSelectorNode : public smgl::Node
{
private:
    VolumePkg::Pointer vpkg_{nullptr};
    Segmentation::Identifier id_{};
    Segmentation::Pointer seg_{nullptr};
 
public:
    smgl::InputPort<VolumePkg::Pointer> volpkg;
    smgl::InputPort<Segmentation::Identifier> id;
    smgl::OutputPort<Segmentation::Pointer> segmentation;
 
    SegmentationSelectorNode();
 
private:
    auto serialize_(bool /*useCache*/, const filesystem::path& /*cacheDir*/)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class SegmentationPropertiesNode : public smgl::Node
{
    Segmentation::Pointer seg_{nullptr};
 
public:
    smgl::InputPort<Segmentation::Pointer> segmentation;
    smgl::OutputPort<Segmentation::PointSet> pointSet;
 
    SegmentationPropertiesNode();
};
 
class MeshPropertiesNode : public smgl::Node
{
private:
    ITKMesh::Pointer mesh_{nullptr};
 
public:
    smgl::InputPort<ITKMesh::Pointer> mesh{&mesh_};
    smgl::OutputPort<std::size_t> numVertices;
    smgl::OutputPort<std::size_t> numFaces;
 
    MeshPropertiesNode();
};
 
class LoadMeshNode : public smgl::Node
{
private:
    filesystem::path path_{};
    bool cacheArgs_{false};
    MeshReaderResult loaded_{};
 
public:
    smgl::InputPort<filesystem::path> path;
    smgl::InputPort<bool> cacheArgs;
    smgl::OutputPort<ITKMesh::Pointer> mesh;
    smgl::OutputPort<UVMap::Pointer> uvMap;
    smgl::OutputPort<cv::Mat> texture;
 
    LoadMeshNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class WriteMeshNode : public smgl::Node
{
private:
    filesystem::path path_{};
    ITKMesh::Pointer mesh_{nullptr};
    UVMap::Pointer uv_{};
    cv::Mat texture_{};
    bool cacheArgs_{false};
 
public:
    smgl::InputPort<filesystem::path> path;
    smgl::InputPort<ITKMesh::Pointer> mesh;
    smgl::InputPort<UVMap::Pointer> uvMap;
    smgl::InputPort<cv::Mat> texture;
    smgl::InputPort<bool> cacheArgs;
 
    WriteMeshNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class RotateUVMapNode : public smgl::Node
{
private:
    UVMap::Pointer uvMapIn_;
    double theta_{0};
    UVMap::Pointer uvMapOut_;
 
public:
    smgl::InputPort<UVMap::Pointer> uvMapIn;
    smgl::InputPort<double> theta;
    smgl::OutputPort<UVMap::Pointer> uvMapOut;
 
    RotateUVMapNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class FlipUVMapNode : public smgl::Node
{
private:
    UVMap::Pointer uvMapIn_;
    UVMap::FlipAxis axis_{UVMap::FlipAxis::Vertical};
    UVMap::Pointer uvMapOut_;
 
public:
    using FlipAxis = UVMap::FlipAxis;
    smgl::InputPort<UVMap::Pointer> uvMapIn;
    smgl::InputPort<FlipAxis> flipAxis;
    smgl::OutputPort<UVMap::Pointer> uvMapOut;
 
    FlipUVMapNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class AlignUVMapToAxisNode : public smgl::Node
{
private:
    UVMap::Pointer uvMapIn_;
    ITKMesh::Pointer mesh_;
    UVMap::AlignmentAxis axis_{UVMap::AlignmentAxis::ZPos};
    UVMap::Pointer uvMapOut_;
 
public:
    smgl::InputPort<UVMap::Pointer> uvMapIn;
    smgl::InputPort<ITKMesh::Pointer> mesh;
    smgl::InputPort<UVMap::AlignmentAxis> axis;
    smgl::OutputPort<UVMap::Pointer> uvMapOut;
 
    AlignUVMapToAxisNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class PlotUVMapNode : public smgl::Node
{
private:
    UVMap::Pointer uvMap_;
    ITKMesh::Pointer uvMesh_;
    cv::Mat plot_;
 
public:
    smgl::InputPort<UVMap::Pointer> uvMap;
    smgl::InputPort<ITKMesh::Pointer> uvMesh;
    smgl::OutputPort<cv::Mat> plot;
 
    PlotUVMapNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class LoadImageNode : public smgl::Node
{
private:
    filesystem::path path_{};
    bool cacheArgs_{false};
    cv::Mat image_{};
 
public:
    smgl::InputPort<filesystem::path> path;
    smgl::InputPort<bool> cacheArgs;
    smgl::OutputPort<cv::Mat> image;
 
    LoadImageNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class WriteImageNode : public smgl::Node
{
private:
    filesystem::path path_{};
    cv::Mat image_{};
    WriteImageOpts opts_;
    bool cacheArgs_{false};
 
public:
    smgl::InputPort<filesystem::path> path;
    smgl::InputPort<cv::Mat> image;
    smgl::InputPort<WriteImageOpts> options;
    smgl::InputPort<bool> cacheArgs;
 
    WriteImageNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class WriteImageSequenceNode : public smgl::Node
{
private:
    using ImageSequence = std::vector<cv::Mat>;
    filesystem::path path_{};
    ImageSequence images_;
    WriteImageOpts opts_;
    bool eagerMode_{false};
    bool cacheArgs_{false};
 
public:
    smgl::InputPort<filesystem::path> path;
    smgl::InputPort<ImageSequence> images;
    smgl::InputPort<WriteImageOpts> options;
    smgl::InputPort<bool> eagerMode;
    smgl::InputPort<bool> cacheArgs;
 
    WriteImageSequenceNode();
 
    void eagerWrite(
        std::size_t idx, std::size_t count, const cv::Mat& image) const;
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class LoadPPMNode : public smgl::Node
{
private:
    filesystem::path path_{};
    bool cacheArgs_{false};
    PerPixelMap::Pointer ppm_{};
 
public:
    smgl::InputPort<filesystem::path> path;
    smgl::InputPort<bool> cacheArgs;
    smgl::OutputPort<PerPixelMap::Pointer> ppm;
 
    LoadPPMNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class WritePPMNode : public smgl::Node
{
private:
    filesystem::path path_{};
    PerPixelMap::Pointer ppm_{};
    bool cacheArgs_{false};
 
public:
    smgl::InputPort<filesystem::path> path;
    smgl::InputPort<PerPixelMap::Pointer> ppm;
    smgl::InputPort<bool> cacheArgs;
 
    WritePPMNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class PPMPropertiesNode : public smgl::Node
{
private:
    PerPixelMap::Pointer ppm_;
 
public:
    smgl::InputPort<PerPixelMap::Pointer> ppm;
    smgl::OutputPort<cv::Mat> mask;
    smgl::OutputPort<cv::Mat> cellMap;
 
    PPMPropertiesNode();
};
 
class LoadVolumetricMaskNode : public smgl::Node
{
private:
    filesystem::path path_{};
    bool cacheArgs_{false};
    VolumetricMask::Pointer mask_{};
 
public:
    smgl::InputPort<filesystem::path> path;
    smgl::InputPort<bool> cacheArgs;
    smgl::OutputPort<VolumetricMask::Pointer> volumetricMask;
 
    LoadVolumetricMaskNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class LoadTransformNode : public smgl::Node
{
private:
    filesystem::path path_{};
    bool cacheArgs_{false};
    Transform3D::Pointer tfm_;
 
public:
    smgl::InputPort<filesystem::path> path;
    smgl::InputPort<bool> cacheArgs;
    smgl::OutputPort<Transform3D::Pointer> transform;
 
    LoadTransformNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class TransformSelectorNode : public smgl::Node
{
private:
    VolumePkg::Pointer vpkg_{nullptr};
    Transform3D::Identifier id_{};
    Transform3D::Pointer tfm_{nullptr};
 
public:
    smgl::InputPort<VolumePkg::Pointer> volpkg;
    smgl::InputPort<Transform3D::Identifier> id;
    smgl::OutputPort<Transform3D::Pointer> transform;
 
    TransformSelectorNode();
 
private:
    auto serialize_(bool /*useCache*/, const filesystem::path& /*cacheDir*/)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class InvertTransformNode : public smgl::Node
{
private:
    Transform3D::Pointer input_;
    Transform3D::Pointer output_;
 
public:
    smgl::InputPort<Transform3D::Pointer> input;
    smgl::OutputPort<Transform3D::Pointer> output;
 
    InvertTransformNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
template <class T>
class ApplyTransformNode : public smgl::Node
{
protected:
    T input_;
    Transform3D::Pointer tfm_;
    T output_;
 
public:
    smgl::InputPort<T> input{&input_};
    smgl::InputPort<Transform3D::Pointer> transform{&tfm_};
    smgl::OutputPort<T> output{&output_};
 
    ApplyTransformNode() : Node{true}
    {
        registerInputPort("input", input);
        registerInputPort("transform", transform);
        registerOutputPort("output", output);
 
        compute = [&]() {
            if (tfm_) {
                output_ = ApplyTransform(input_, tfm_);
            }
        };
    }
 
protected:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override
    {
        smgl::Metadata meta;
        if (useCache and tfm_) {
            Transform3D::Save(cacheDir / "transform.json", tfm_);
            meta["transform"] = "transform.json";
        }
        return meta;
    }
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override
    {
        if (meta.contains("transform")) {
            auto tfmFile = meta["transform"].get<std::string>();
            tfm_ = Transform3D::Load(cacheDir / tfmFile);
        }
    }
};
 
class TransformMeshNode : public ApplyTransformNode<ITKMesh::Pointer>
{
private:
    using BaseT = ApplyTransformNode<ITKMesh::Pointer>;
 
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class TransformPPMNode : public ApplyTransformNode<PerPixelMap::Pointer>
{
private:
    using BaseT = ApplyTransformNode<PerPixelMap::Pointer>;
 
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
}  // namespace volcart