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 {
    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