OpticalFlowSegmentation.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <optional>
 
#include "vc/core/types/OrderedPointSet.hpp"
#include "vc/core/types/VolumePkg.hpp"
#include "vc/segmentation/ChainSegmentationAlgorithm.hpp"
#include "vc/segmentation/lrps/FittedCurve.hpp"
 
namespace volcart::segmentation
{
class OpticalFlowSegmentation : public ChainSegmentationAlgorithm
{
public:
    using Pointer = std::shared_ptr<OpticalFlowSegmentation>;
 
    OpticalFlowSegmentation() = default;
 
    ~OpticalFlowSegmentation() override = default;
 
    template <typename... Args>
    static auto New(Args... args) -> Pointer
    {
        return std::make_shared<OpticalFlowSegmentation>(
            std::forward<Args>(args)...);
    }
 
    void setStartZIndex(int z);
 
    [[nodiscard]] auto getStartZIndex() const -> int;
 
    void setTargetZIndex(int z);
 
    [[nodiscard]] auto getTargetZIndex() const -> int;
 
    void setOutsideThreshold(std::uint8_t outside);
 
    void setOFThreshold(std::uint8_t ofThr);
 
    void setOFDispThreshold(std::uint32_t ofDispThrs);
 
    void setSmoothBrightnessThreshold(std::uint8_t brightness);
 
    void setEnableSmoothOutliers(bool enable);
 
    void setEnableEdgeDetection(bool enable);
 
    void setEdgeJumpDistance(std::uint32_t distance);
 
    void setEdgeBounceDistance(std::uint32_t distance);
 
    void setInterpolate(bool b);
 
    void setInterpolationWindow(std::uint32_t window);
 
    [[nodiscard]] auto getInterpolationWindow() const -> std::uint32_t;
 
    void setInterpolationDistance(std::uint32_t distance);
 
    [[nodiscard]] auto getInterpolationDistance() const -> std::uint32_t;
 
    void setMasterCloud(PointSet masterCloud);
 
    void setReSegmentationChain(Chain c);
 
    void setMaterialThickness(double m);
 
    void setMaxThreads(std::uint32_t t);
 
    void resetMaxThreads();
 
    void setVisualize(bool b);
 
    void setDumpVis(bool b);
 
    auto compute() -> PointSet override;
 
    [[nodiscard]] auto progressIterations() const -> std::size_t override;
 
private:
    [[nodiscard]] auto compute_curve_(
        const FittedCurve& currentCurve, int zIndex) const
        -> std::vector<Voxel>;
 
    auto interpolate_(
        int interpStart, int interpEnd, int startChain, int startResegChain)
        -> std::vector<std::vector<Voxel>>;
 
    auto run_ofs_(
        Chain currentVs,
        int startChainIndex,
        int anchorEndIdx,
        int targetIndex,
        int stepAdjustment,
        std::size_t& iteration,
        bool backwards,
        const filesystem::path& debugDir)
        -> std::tuple<std::vector<std::vector<Voxel>>, Status>;
 
    int startIndex_{0};
    int endIndex_{0};
    std::uint8_t outsideThreshold_{80};
    std::uint8_t opticalFlowPixelThreshold_{80};
    std::uint32_t opticalFlowDisplacementThreshold_{10};
    std::uint8_t smoothByBrightness_{180};
    bool enableSmoothenOutlier_{true};
    bool enableEdge_{false};
    std::uint32_t edgeJumpDistance_{6};
    std::uint32_t edgeBounceDistance_{3};
    bool requestInterp_{false};
    std::uint32_t interpWindow_{5};
    std::uint32_t interpDist_{25};
    Chain resegStartingChain_;
    PointSet masterCloud_;
    double materialThickness_{100};
    std::optional<std::uint32_t> maxThreads_;
    bool dumpVis_{false};
    bool visualize_{false};
};
}  // namespace volcart::segmentation