texturing.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <limits>
 
#include <opencv2/core.hpp>
#include <smgl/Node.hpp>
 
#include "vc/core/filesystem.hpp"
#include "vc/core/neighborhood/NeighborhoodGenerator.hpp"
#include "vc/core/types/ITKMesh.hpp"
#include "vc/core/types/PerPixelMap.hpp"
#include "vc/core/types/UVMap.hpp"
#include "vc/core/types/Volume.hpp"
#include "vc/core/types/VolumePkg.hpp"
#include "vc/texturing/AngleBasedFlattening.hpp"
#include "vc/texturing/CompositeTexture.hpp"
#include "vc/texturing/FlatteningError.hpp"
#include "vc/texturing/IntegralTexture.hpp"
#include "vc/texturing/IntersectionTexture.hpp"
#include "vc/texturing/LayerTexture.hpp"
#include "vc/texturing/OrthographicProjectionFlattening.hpp"
#include "vc/texturing/PPMGenerator.hpp"
#include "vc/texturing/ThicknessTexture.hpp"
 
namespace volcart
{
 
class ABFNode : public smgl::Node
{
    using ABF = texturing::AngleBasedFlattening;
    ABF abf_{};
    UVMap::Pointer uvMap_{};
    ITKMesh::Pointer mesh_{nullptr};
 
public:
    smgl::InputPort<ITKMesh::Pointer> input;
    smgl::InputPort<bool> useABF;
    smgl::InputPort<bool> useHLSCM;
    smgl::InputPort<ABF::Solver> solver;
    smgl::OutputPort<ITKMesh::Pointer> output;
    smgl::OutputPort<UVMap::Pointer> uvMap;
 
    ABFNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class OrthographicFlatteningNode : public smgl::Node
{
private:
    using Ortho = texturing::OrthographicProjectionFlattening;
    Ortho ortho_{};
    UVMap::Pointer uvMap_{};
    ITKMesh::Pointer mesh_{nullptr};
 
public:
    smgl::InputPort<ITKMesh::Pointer> input;
    smgl::OutputPort<ITKMesh::Pointer> output;
    smgl::OutputPort<UVMap::Pointer> uvMap;
 
    OrthographicFlatteningNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class FlatteningErrorNode : public smgl::Node
{
private:
    using Metrics = texturing::LStretchMetrics;
    ITKMesh::Pointer mesh3D_{nullptr};
    ITKMesh::Pointer mesh2D_{nullptr};
    Metrics error_{};
 
public:
    smgl::InputPort<ITKMesh::Pointer> mesh3D;
    smgl::InputPort<ITKMesh::Pointer> mesh2D;
    smgl::OutputPort<Metrics> error;
 
    FlatteningErrorNode();
 
private:
    auto serialize_(bool /*useCache*/, const filesystem::path& /*cacheDir*/)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class PlotLStretchErrorNode : public smgl::Node
{
private:
    using Metrics = texturing::LStretchMetrics;
    Metrics error_{};
    cv::Mat cellMap_{};
    ColorMap colorMap_{ColorMap::Plasma};
    bool drawLegend_{false};
    cv::Mat l2Plot_{};
    cv::Mat lInfPlot_{};
 
public:
    smgl::InputPort<Metrics> error;
    smgl::InputPort<cv::Mat> cellMap;
    smgl::InputPort<ColorMap> colorMap;
    smgl::InputPort<bool> drawLegend;
    smgl::OutputPort<cv::Mat> l2Plot;
    smgl::OutputPort<cv::Mat> lInfPlot;
 
    PlotLStretchErrorNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class PPMGeneratorNode : public smgl::Node
{
private:
    using PPMGen = texturing::PPMGenerator;
    PPMGen ppmGen_;
    PPMGen::Shading shading_{PPMGen::Shading::Smooth};
    PerPixelMap::Pointer ppm_;
 
public:
    using Shading = PPMGen::Shading;
    smgl::InputPort<ITKMesh::Pointer> mesh;
    smgl::InputPort<UVMap::Pointer> uvMap;
    smgl::InputPort<Shading> shading;
    smgl::OutputPort<PerPixelMap::Pointer> ppm;
 
    PPMGeneratorNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class CalculateNeighborhoodRadiusNode : public smgl::Node
{
private:
    double thickness_{300};
    double voxelSize_{100};
    cv::Vec3d radius_;
 
public:
    smgl::InputPort<double> thickness;
    smgl::InputPort<double> voxelSize;
    smgl::OutputPort<cv::Vec3d> radius;
 
    CalculateNeighborhoodRadiusNode();
 
private:
    auto serialize_(bool /*useCache*/, const filesystem::path& /*cacheDir*/)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class NeighborhoodGeneratorNode : public smgl::Node
{
public:
    enum class Shape {
        Line = 0,
        Cuboid
    };
 
private:
    using Generator = NeighborhoodGenerator;
    Shape shape_{Shape::Line};
    cv::Vec3d radius_{1, 1, 1};
    double interval_{1};
    Direction dir_{Direction::Bidirectional};
    Generator::Pointer gen_;
 
public:
    smgl::InputPort<Shape> shape;
    smgl::InputPort<cv::Vec3d> radius;
    smgl::InputPort<double> interval;
    smgl::InputPort<Direction> direction;
    smgl::OutputPort<Generator::Pointer> generator;
 
    NeighborhoodGeneratorNode();
 
private:
    auto serialize_(bool /*useCache*/, const filesystem::path& /*cacheDir*/)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta,
        const filesystem::path& /*cacheDir*/) override;
};
 
class CompositeTextureNode : public smgl::Node
{
private:
    using TAlgo = texturing::CompositeTexture;
    using Generator = NeighborhoodGenerator::Pointer;
    TAlgo textureGen_;
    TAlgo::Filter filter_{TAlgo::Filter::Maximum};
    cv::Mat texture_;
 
public:
    using Filter = TAlgo::Filter;
 
    smgl::InputPort<PerPixelMap::Pointer> ppm;
    smgl::InputPort<Volume::Pointer> volume;
    smgl::InputPort<Generator> generator;
    smgl::InputPort<Filter> filter;
    smgl::OutputPort<cv::Mat> texture;
 
    CompositeTextureNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class IntersectionTextureNode : public smgl::Node
{
private:
    using TAlgo = texturing::IntersectionTexture;
    TAlgo textureGen_;
    cv::Mat texture_;
 
public:
    smgl::InputPort<PerPixelMap::Pointer> ppm;
    smgl::InputPort<Volume::Pointer> volume;
    smgl::OutputPort<cv::Mat> texture;
 
    IntersectionTextureNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class IntegralTextureNode : public smgl::Node
{
private:
    using TAlgo = texturing::IntegralTexture;
    using Generator = NeighborhoodGenerator::Pointer;
    TAlgo textureGen_;
    cv::Mat texture_;
 
public:
    using WeightMethod = texturing::IntegralTexture::WeightMethod;
    using WeightDirection = texturing::IntegralTexture::LinearWeightDirection;
    using ExpoDiffBaseMethod = texturing::IntegralTexture::ExpoDiffBaseMethod;
 
    smgl::InputPort<PerPixelMap::Pointer> ppm;
    smgl::InputPort<Volume::Pointer> volume;
    smgl::InputPort<Generator> generator;
    smgl::InputPort<bool> clampValuesToMax;
    smgl::InputPort<std::uint16_t> clampMax;
    smgl::InputPort<WeightMethod> weightMethod;
    smgl::InputPort<WeightDirection> linearWeightDirection;
    smgl::InputPort<int> exponentialDiffExponent;
    smgl::InputPort<ExpoDiffBaseMethod> exponentialDiffBaseMethod;
    smgl::InputPort<double> exponentialDiffBaseValue;
    smgl::InputPort<bool> exponentialDiffSuppressBelowBase;
    smgl::OutputPort<cv::Mat> texture;
 
    IntegralTextureNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class ThicknessTextureNode : public smgl::Node
{
private:
    using TAlgo = texturing::ThicknessTexture;
    TAlgo textureGen_;
    cv::Mat texture_;
 
public:
    smgl::InputPort<PerPixelMap::Pointer> ppm;
    smgl::InputPort<Volume::Pointer> volume;
    smgl::InputPort<VolumetricMask::Pointer> volumetricMask;
    smgl::InputPort<double> samplingInterval;
    smgl::InputPort<bool> normalizeOutput;
    smgl::OutputPort<cv::Mat> texture;
 
    ThicknessTextureNode();
 
private:
    auto serialize_(bool useCache, const filesystem::path& cacheDir)
        -> smgl::Metadata override;
 
    void deserialize_(
        const smgl::Metadata& meta, const filesystem::path& cacheDir) override;
};
 
class LayerTextureNode : public smgl::Node
{
private:
    using ImageList = std::vector<cv::Mat>;
    using TAlgo = texturing::LayerTexture;
    using Generator = NeighborhoodGenerator::Pointer;
    TAlgo textureGen_;
    ImageList texture_;
 
public:
    smgl::InputPort<PerPixelMap::Pointer> ppm;
    smgl::InputPort<Volume::Pointer> volume;
    smgl::InputPort<Generator> generator;
    smgl::OutputPort<ImageList> texture;
 
    LayerTextureNode();
 
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