ddtSubscriberSimulator.hpp

Go to the documentation of this file.

 
#ifndef DDTSUBSCRIBERSIMULATOR_HPP_
#define DDTSUBSCRIBERSIMULATOR_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 <iostream>
#include <typeinfo>
 
#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 DdtSubscriberSimulator : public DdtDataSubscriberApplication {
 public:
  DdtSubscriberSimulator();
 
  ~DdtSubscriberSimulator() final;
 
  ddt::InitCodes Init(int argc, char* argv[]);
 
  int Run() final;
 
  int RunTransfer();
 
 private:
  ddt::CommandLineParserResult ParseCommandLine(int argc, char* argv[]);
 
  void ProcessNewData() final;
  void ProcessNewDataOsc();
  void ProcessNewDataMultiDim();
  void PrintStatistics();
  void DumpAsFile(ddt::DataSample* const data_sample, const std::shared_ptr<DdtEncDec> encDec);
 
  cpl_image* 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,
                                          bool* const unwrap_only);
  cpl_propertylist* LoadWCSFromMetadata(const std::shared_ptr<DdtEncDec> enc_dec);
 
  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> processing_active;
 
  boost::signals2::connection connection;
 
  const int BYTES_STEP = 2;
};
 
}  // namespace ddt
 
#endif /* DDTSUBSCRIBERSIMULATOR_HPP_ */