Segmentation.h

Go to the documentation of this file.

 
#ifndef _SEFRAMEWORK_PIPELINE_SEGMENTATION_H
#define _SEFRAMEWORK_PIPELINE_SEGMENTATION_H
 
#include <memory>
#include <type_traits>
 
#include "SEFramework/CoordinateSystem/CoordinateSystem.h"
#include "SEFramework/Frame/Frame.h"
#include "SEFramework/Image/Image.h"
#include "SEFramework/Pipeline/PipelineStage.h"
#include "SEFramework/Pipeline/SourceGrouping.h"
#include "SEFramework/Property/DetectionFrame.h"
#include "SEFramework/Source/SourceInterface.h"
 
namespace SourceXtractor {
 
struct SegmentationProgress {
  int position, total;
};
 
class Segmentation : public PipelineEmitter<SourceInterface> , public Observable<SegmentationProgress> {
 
public:
  class LabellingListener;
  class Labelling;
 
  virtual ~Segmentation() = default;
 
  explicit Segmentation(std::shared_ptr<DetectionImageFrame::ImageFilter> image_processing);
 
  template<class LabellingType, typename ... Args>
  void setLabelling(Args... args) {
    static_assert(std::is_base_of<Labelling, LabellingType>::value,
        "LabellingType must inherit from SourceXtractor::Segmentation::Labelling");
    static_assert(std::is_constructible<LabellingType, Args...>::value,
        "LabellingType must be constructible from args");
 
    m_labelling.reset(new LabellingType(std::forward<Args>(args)...));
  }
 
  void processFrame(std::shared_ptr<DetectionImageFrame> frame) const;
 
private:
  std::unique_ptr<Labelling> m_labelling;
  std::shared_ptr<DetectionImageFrame::ImageFilter> m_filter_image_processing;
 
}; /* End of Segmentation class */
 
class Segmentation::LabellingListener {
public:
  LabellingListener(const Segmentation& segmentation, std::shared_ptr<DetectionImageFrame> detection_frame) :
    m_segmentation(segmentation),
    m_detection_frame(detection_frame) {}
 
  void publishSource(std::unique_ptr<SourceInterface> source) const {
    if (m_detection_frame) {
      source->setProperty<DetectionFrame>(m_detection_frame);
    }
    m_segmentation.sendSource(std::move(source));
  }
 
  void notifyProgress(int position, int total) {
    m_segmentation.Observable<SegmentationProgress>::notifyObservers(SegmentationProgress{position, total});
  }
 
  void requestProcessing(const ProcessSourcesEvent& event) {
    m_segmentation.sendProcessSignal(event);
  }
 
private:
  const Segmentation& m_segmentation;
  std::shared_ptr<DetectionImageFrame> m_detection_frame;
};
 
class Segmentation::Labelling {
public:
  virtual ~Labelling() = default;
  Labelling() {}
 
  virtual void labelImage(Segmentation::LabellingListener& listener, std::shared_ptr<const DetectionImageFrame> frame) = 0;
};
 
} /* namespace SourceXtractor */
 
#endif