Disable Stage on Running Pipeline

Disable Stage on Running Pipeline

Hello, Prophesee Team!
I am trying to make FrameGenerationStage to be able to be:
  1. disabled (and free all resources and processing time),
  2. enabled back
  3. reset (new accumulation_time_ms and fps),
Questions:
  1. Does all resources and processing time get free in the Disable()?
  2. Does all resources get reset in the Reset() without excess?
  3. Any recommendation to the code?  

  1. #pragma once
  2. #include <memory>
  3. #include <assert.h>
  4. #include <opencv2/opencv.hpp>
  5. #include "metavision/sdk/base/utils/sdk_log.h"
  6. #include "metavision/sdk/core/pipeline/base_stage.h"
  7. #include "metavision/sdk/core/algorithms/periodic_frame_generation_algorithm.h"

  9. class FrameGenerationStage : public Metavision::BaseStage{
  10. public:
  11.     using FramePool = Metavision::SharedObjectPool<cv::Mat>;
  12.     using FramePtr  = FramePool::ptr_type;
  13.     using Output    = std::pair<Metavision::timestamp, FramePtr>;

  15.     FrameGenerationStage(int width, int height, uint32_t accumulation_time_ms = 10, double fps = 0.,
  16.         const Metavision::ColorPalette& palette = Metavision::BaseFrameGenerationAlgorithm::default_palette()) :
  17.         frame_pool_(FramePool::make_bounded(2)),
  18.         width_(width), height_(height), accumulation_time_ms_(accumulation_time_ms), fps_(fps), palette_(palette) {

  20.         SetCallbacks();
  21.     }

  23.     void SetCallbacks() {
  24.         const uint32_t accumulation_time_us = accumulation_time_ms_ * 1000;
  25.         algo_ = std::make_unique<Metavision::PeriodicFrameGenerationAlgorithm>(width_, height_, accumulation_time_us, fps_, palette_);
  26.         algo_->set_output_callback([this](const Metavision::timestamp ts, cv::Mat& f) {
  27.             crt_frame_ptr_ = frame_pool_.acquire();
  28.             cv::swap(f, *crt_frame_ptr_);

  30.             produce(std::make_pair(ts, crt_frame_ptr_));
  31.             });

  33.         set_consuming_callback([this](const boost::any& data) { consume_cd_events(data); });
  34.     }

  36.     void Reset(uint32_t accumulation_time_ms = 10, double fps = 0.) {
  37.         accumulation_time_ms_ = accumulation_time_ms;
  38.         fps_ = fps;

  40.         SetCallbacks();
  41.     }

  43.     void Disable() {
  44.         algo_->set_output_callback([this](const Metavision::timestamp ts, cv::Mat& f) {});
  45.         set_consuming_callback([this](const boost::any& data) {});
  46.     }

  48.     void Enable() {
  49.         SetCallbacks();
  50.     }

  52. private:
  53.     void consume_cd_events(const boost::any &data) {
  54.         try {
  55.             auto buffer = boost::any_cast<EventBufferPtr>(data);
  56.             algo_->process_events(buffer->cbegin(), buffer->cend());
  57.         } catch (boost::bad_any_cast &c) { MV_SDK_LOG_ERROR() << c.what(); }
  58.     }

  60.     FramePtr crt_frame_ptr_;
  61.     FramePool frame_pool_;
  62.     std::unique_ptr<Metavision::PeriodicFrameGenerationAlgorithm> algo_;

  64.     int width_;
  65.     int height_;
  66.     uint32_t accumulation_time_ms_;
  67.     double fps_;
  68.     const Metavision::ColorPalette& palette_;
  69. };