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 setTargetZIndex(int z);
 
    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 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:
    auto compute_curve_(const FittedCurve& currentCurve, int zIndex)
        -> std::vector<Voxel>;
 
    [[nodiscard]] auto draw_particle_on_slice_(
        const FittedCurve& curve,
        int sliceIndex,
        int particleIndex = -1,
        bool showSpline = false) const -> cv::Mat;
 
    auto create_final_pointset_(const std::vector<std::vector<Voxel>>& points)
        -> PointSet;
 
    int endIndex_{0};
    std::uint8_t outsideThreshold_{80};
    std::uint8_t opticalFlowPixelThreshold_{80};
    std::uint32_t opticalFlowDisplacementThreshold_{10};
    std::uint8_t smoothByBrightness_{180};
    double materialThickness_{100};
    std::optional<std::uint32_t> maxThreads_;
    bool dumpVis_{false};
    bool visualize_{false};
};
}  // namespace volcart::segmentation