ddtSubscriber.hpp

Go to the documentation of this file.

 
#ifndef DDTSUBSCRIBER_HPP_
#define DDTSUBSCRIBER_HPP_
 
#include <cpl.h>
#undef I
#undef arg
 
#include <algorithm>
#include <boost/algorithm/string.hpp>
#include <boost/bind/bind.hpp>
#include <boost/signals2/signal.hpp>
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <typeinfo>
#include <vector>
 
#include "ddt/ddtDataSubscriber.hpp"
#include "ddt/ddtDataSubscriberApplication.hpp"
#include "ddt/ddtDataTransferFactory.hpp"
#include "ddt/ddtEncDecBinaryxD.hpp"
#include "ddt/ddtEncDecImage2D.hpp"
#include "ddt/ddtEncDecImage3D.hpp"
#include "ddt/ddtLogger.hpp"
#include "ddt/imageBuffer.hpp"
#include "ddt/imageIO.hpp"
#include "ddt/initCpl.hpp"
#include "ddt/ddtInitCodes.hpp"
#include "ddt/commandLineParser.hpp"
 
namespace mal = ::elt::mal;
namespace datatransfer = ::elt::ddt::datatransfer;
 
namespace ddt {
 
enum SubscriberModes {
  IMAGETRANSFER = 1,    
  OSCILLOSCOPE = 2,     
  MULTIDIM = 3,         
  CONFIGURATIONMAP = 4, 
  SEGMENTEDIMAGE = 5    
};

class DdtSubscriber : public DdtDataSubscriberApplication {
 public:
  struct SignalConnection {
    boost::signals2::connection connection;
 
    SignalConnection() = default;
    explicit SignalConnection(boost::signals2::connection c) : connection(std::move(c)) {}
    SignalConnection(const SignalConnection&) = delete;
    SignalConnection& operator=(const SignalConnection&) = delete;
    SignalConnection(SignalConnection&&) = default;
    SignalConnection& operator=(SignalConnection&&) = default;
    ~SignalConnection() { connection.disconnect(); }

    void disconnect() { connection.disconnect(); }

    bool connected() const { return connection.connected(); }
  };

  DdtSubscriber();

  ~DdtSubscriber() final;

  ddt::InitCodes Init(int argc, char* argv[]);

  ddt::InitCodes Init(const std::vector<std::string>& args);

  int Run() final;

  int RunTransfer();

  void Stop();

  SignalConnection ConnectNewImage(std::function<void()> callback);
 
  ::cpl_image* GetCurrentImageCopy();
  uintptr_t GetCurrentImageCopyAsRawPtr();
 
 private:
  ddt::CommandLineParserResult ParseCommandLine(int argc, char* argv[]);
 
  void ProcessNewData() final;
  void ProcessNewDataOsc();
  void ProcessNewDataMultiDim();
  void PrintStatistics();
  void DumpAsFile(const std::shared_ptr<DdtEncDec> encDec);
 
  void CreateNewImageFromDataSample(ddt::DataSample* const sample,
                                          const int bytes_per_pixel,
                                          const int num_pix_x,
                                          const int num_pix_y,
                                          const uint32_t data_type);
  cpl_propertylist* LoadWCSFromMetadata(const std::shared_ptr<DdtEncDec> enc_dec);
 
  void CleanupTmpImage();
  void CleanupSharedImage();
 
  void LogMetaDataBase(DataSample* const data_sample,
                       const std::shared_ptr<DdtEncDec> enc_dec);
  void LogMetaDataImage2D(DataSample* const data_sample,
                          const std::shared_ptr<DdtEncDecImage2D> enc_dec_2d);
  void LogMetaDataImage3D(DataSample* const data_sample,
                          const std::shared_ptr<DdtEncDecImage3D> enc_dec_3d);
  void LogMetaDataBinaryxD(DataSample* const data_sample,
                           const std::shared_ptr<DdtEncDecBinaryxD> enc_dec_xd);
  void LogSimulatorStart(const std::string use_case);
  void LogWcsInfo(std::shared_ptr<DdtEncDec> enc_dec);
 
  std::vector<std::string> GetDimensions(DataSample* const data_sample);
 
  std::unique_ptr<DdtDataSubscriber> subscriber;
 
  std::unique_ptr<DdtLogger> logger;
 
  bool debug_log_enabled = false;
  std::string broker_uri;
  std::string data_stream_identifier;
  int reading_interval = 10;
  std::string remote_broker_uri;
  int mode = 1;
  bool statistics = false;
  bool dump_data = false;
  std::string dump_folder;
 
  std::atomic<bool> stop_requested{false};
  std::atomic<bool> processing_active;
 
  cpl_image* tmp_image = nullptr;
  bool only_unwrap = false;
 
  std::mutex new_image_mutex;
  cpl_image* shared_image = nullptr;
 
  boost::signals2::signal<void()> new_image_signal;
 
 
  const int BYTES_STEP = 2;
};
 
}  // namespace ddt
 
#endif /* DDTSUBSCRIBER_HPP_ */