ddtSubscriberSimulator.hpp

Go to the documentation of this file.

// @copyright
// (c) Copyright ESO 2020
// All Rights Reserved
// ESO (eso.org) is an Intergovernmental Organization, and therefore special
// legal conditions apply.
//
// @file ddtSubscriberSimulator.hpp
// @brief Simulator for receiving data.
//
// This is a simulator for receiving data from a publisher application. The
// simulator connects to a local Broker and either receives data from a remote
// publisher or from a local publisher.
//
// @author Matthias Grimm, CGI
// @since  2020/06/30
//
 
#ifndef DDTSUBSCRIBERSIMULATOR_HPP_
#define DDTSUBSCRIBERSIMULATOR_HPP_
 
#include <cpl.h>
#undef I
#undef arg
 
#include <boost/algorithm/string.hpp>
#include <boost/bind/bind.hpp>
#include <boost/signals2/signal.hpp>
#include <iostream>
 
#include "ddt/imageBuffer.hpp"
#include "ddt/imageIO.hpp"
#include "ddt/initCpl.hpp"
 
#include "ddt/commandLineParserBuilder.hpp"
#include "ddt/ddtDataSubscriber.hpp"
#include "ddt/ddtDataSubscriberApplication.hpp"
#include "ddt/ddtDataTransferFactory.hpp"
#include "ddt/ddtLogger.hpp"
 
#include "ddt/ddtEncDecBinaryxD.hpp"
#include "ddt/ddtEncDecImage2D.hpp"
#include "ddt/ddtEncDecImage3D.hpp"
 
namespace mal = ::elt::mal;
namespace datatransfer = ::elt::ddt::datatransfer;
 
namespace ddt {
 
enum SubscriberModes {
  IMAGETRANSFER = 1,
  OSCILLOSCOPE = 2,
  MULTIDIM = 3,
  CONFIGURATIONMAP = 4,
  SEGMENTEDIMAGE = 5
};
 
union R4 {
  float i;
 
  unsigned char c[4];
};
 
class DdtSubscriberSimulator : public DdtDataSubscriberApplication {
 public:
  DdtSubscriberSimulator();
 
  ~DdtSubscriberSimulator() final;
 
  int Run() final;
 
  bool Init(int argc, char** argv);
 
  int RunTransfer();
 
 private:
  void ProcessNewData() final;
  void ProcessNewDataOsc();
  void ProcessNewDataMultiDim();
  void PrintStatistics();
  void DumpAsFile(ddt::DataSample* const data_sample, DdtEncDec* const 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(DdtEncDec* const encDec);
 
  void logMetaDataBase(DataSample* const data_sample,
                       const DdtEncDec* const encDec);
  void logMetaDataImage2D(DataSample* const data_sample,
                          const DdtEncDecImage2D* const encDec2D);
  void logMetaDataImage3D(DataSample* const data_sample,
                          const DdtEncDecImage3D* const encDec3D);
  void logMetaDataBinaryxD(DataSample* const data_sample,
                           const DdtEncDecBinaryxD* const encDecxD);
  void logSimulatorStart(const std::string use_case);
  void logWcsInfo(const DdtEncDec* const encDec);
 
  std::vector<std::string> getDimensions(DataSample* const data_sample);
 
  std::unique_ptr<DdtDataSubscriber> subscriber;
 
  DdtLogger* logger = nullptr;
  CommandLineParserBuilder* builder = nullptr;
 
  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_ */