ddtPublisherSimulator.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 ddtPublisherSimulator.hpp
// @brief Simulator for sending data.
//
// This is a simulator for publishing data. Data is read from a directory
// containing FITS files.
//
// @author Carsten Mannel, CGI
// @since  2020/09/25
//
 
#ifndef DDTPUBLISHERSIMULATOR_HPP_
#define DDTPUBLISHERSIMULATOR_HPP_
 
#include <boost/bind/bind.hpp>
#include <boost/filesystem.hpp>
#include <boost/signals2/signal.hpp>
#include <random>
 
#include "ddt/commandLineParserBuilder.hpp"
#include "ddt/ddtDataPublisher.hpp"
#include "ddt/ddtDataPublisherApplication.hpp"
#include "ddt/ddtDataTransferFactory.hpp"
#include "ddt/ddtLogger.hpp"
 
#include <cpl.h>
 
#include "ddt/ddtEncDecBinaryxD.hpp"
#include "ddt/ddtEncDecImage2D.hpp"
#include "ddt/ddtEncDecImage3D.hpp"
 
namespace datatransfer = ::elt::ddt::datatransfer;
 
using namespace ddt;
using namespace boost::filesystem;
 
namespace ddt {
 
enum PublisherModes {
  IMAGETRANSFER = 1,
  OSCILLOSCOPE = 2,
  MULTIDIM = 3,
  CONFIGURATIONMAP = 4,
  SEGMENTEDIMAGE = 5,
  UNSIGNEDINT16 = 6,
  UNSIGNEDINT32 = 7
};
 
class DdtPublisherSimulator : public DdtDataPublisherApplication {
 public:
  DdtPublisherSimulator();
 
  ~DdtPublisherSimulator() final;
 
  int Run();
 
  bool Init(const int argc, char** argv);
 
  int RunImageTransfer();
 
  int RunOscilloscopeTransfer();
 
  int RunMultiDimensionalArrayTransfer();
 
  int RunNumericalSampleArrayTransfer();
 
  int RunSegmentedImageTransfer();
 
  int RunUnsignedIntegerTransfer(const unsigned int numBits);
 
 private:
  DdtLogger* logger;
  CommandLineParserBuilder* builder;
 
  std::string broker_uri;
  std::string data_stream_identifier;
  int publishing_interval;
  int num_samples_in_buffer;
  std::string image_folder;
  int mode;
  bool checksum;
 
  const int LATENCY = 10000;  
  const int DEADLINE = 10;    
 
  bool CheckBytesPerPixel(std::vector<std::string>& file_list);
 
  void DetermineBytesPerPixelAndDataType(
      const cpl_propertylist* const property_list, const cpl_image* const image,
      int* const bytes_per_pixel, uint32_t* const data_type,
      cpl_type* const cplImageType);
 
  bool GetSimulationData(std::vector<std::string>& file_list,
                         std::vector<cpl_image*>& images);
 
  void FillDataVectors(std::vector<std::vector<uint8_t>>& datavecs,
                       int& max_sample_size, std::vector<cpl_image*>& images,
                       const int num_images, const cpl_type cplImageType,
                       const int bytes_per_pixel) const;
 
  void FillDataVectorInt(std::vector<std::vector<uint8_t>>& datavecs,
                         cpl_image* const image, const int vec_elems,
                         const int bytes_per_pixel) const;
 
  void FillDataVectorFloat(std::vector<std::vector<uint8_t>>& datavecs,
                           cpl_image* const image, const int vec_elems,
                           const int bytes_per_pixel) const;
 
  void FillDataVectorDouble(std::vector<std::vector<uint8_t>>& datavecs,
                            cpl_image* const image, const int vec_elems,
                            const int bytes_per_pixel) const;
 
  void FillMetaDataWCSItems(const cpl_propertylist* const property_list,
                            MetaDataElementsImage3D& meta_data_img_3d);
 
  void FillMetadataBase(MetaDataElementsImage3D& meta_data_img_3d,
                        const int bytes_per_pixel,
                        const uint32_t number_dimensions,
                        const bool complete_flag, const bool last_segment,
                        const bool byte_order_little_endian,
                        const uint32_t data_type) const;
 
  void FillMetadataBase(MetaDataElementsImage2D& meta_data_img_2d,
                        const int bytes_per_pixel,
                        const uint32_t number_dimensions,
                        const bool complete_flag,
                        const bool byte_order_little_endian,
                        const uint32_t data_type) const;
 
  void FillMetadataSpecific(MetaDataElementsImage3D& meta_data_img_3d,
                            const uint32_t number_pixels_x,
                            const uint32_t number_pixels_y,
                            const int32_t binning_factor_x,
                            const int32_t binning_factor_y,
                            const uint32_t number_layers,
                            const uint32_t item_size) const;
 
  void FillMetadataSpecific(MetaDataElementsImage2D& meta_data_img_2d,
                            const uint32_t number_pixels_x,
                            const uint32_t number_pixels_y,
                            const int32_t binning_factor_x,
                            const int32_t binning_factor_y,
                            const uint32_t number_chunks_x,
                            const uint32_t number_chunks_y) const;
 
  void CompleteMetadataSpecific(MetaDataElementsImage2D& meta_data_img_2d,
                                const uint32_t first_pixel_x,
                                const uint32_t first_pixel_y,
                                const bool last_segment,
                                const int32_t image_id) const;
 
  void PublishData_ImageTransfer(std::vector<cpl_image*>& images,
                                 const int bytes_per_pixel,
                                 const uint32_t data_type, const int num_images,
                                 const int max_sample_size,
                                 MetaDataElementsImage3D& meta_data_img_3d,
                                 std::vector<std::vector<uint8_t>>& datavecs);
 
  void PublishData_SegmentedImageTransfer(const int bytes_per_pixel,
                                          const uint32_t number_pixels_x,
                                          const uint32_t number_pixels_y,
                                          const int vec_elems);
 
  void PublishData_MultiDimension(const uint32_t bytes_per_value,
                                  const int number_dimensions,
                                  const uint32_t data_type,
                                  const std::string array_dimensions,
                                  const int vec_elems,
                                  const std::vector<uint8_t>& datavec,
                                  std::vector<std::string>& descriptions);
 
  void PublishData_UnsignedIntegerTransfer(
      const uint32_t bytes_per_value, const int dim1, const int dim2,
      const int number_dimensions, const uint32_t data_type,
      const int vec_elems, const std::vector<uint8_t>& datavec,
      std::vector<std::string>& descriptions);
 
  cpl_propertylist* LoadPropertyList(const std::string file_name);
 
  void LogNoSimDataFolder();
  void LogNoDirectory();
  void LogNoSimDataFiles();
 
  int CreateAndRegPublisher(const int vec_elems);
  void TransferData(DdtEncDecBinaryxD* const enc_dec_binary_xd,
                    const MetaDataElementsBinaryxD& meta_data_binary_xD,
                    const std::vector<uint8_t>& datavec,
                    const int32_t sample_id);
  void InitMetaDataBinaryXD(MetaDataElementsBinaryxD* const meta_data_binary_xD,
                            const uint32_t bytes_per_pixel,
                            const uint32_t number_dimensions,
                            const bool byte_order_little_endian,
                            const bool complete_flag, const bool last_segment,
                            const uint32_t data_type,
                            const std::string array_dimensions) const;
 
  std::vector<uint8_t> GetDataVectorOscilloscope(const int dim1);
  std::vector<uint8_t> GetDataVectorMultiDimension(const int dim1,
                                                   const int dim2,
                                                   const int dim3,
                                                   const int dim4);
  void FillDataVectorNumericalSample(const int dim1, const int cnt,
                                     std::vector<uint8_t>& datavec);
  void FillDataVectorSegmentedImage(const uint32_t number_pixels_x,
                                    const uint32_t number_pixels_y,
                                    const int chunk_cnt_x,
                                    const int chunk_cnt_y,
                                    const uint32_t number_chunks_x,
                                    std::vector<uint8_t>& datavec) const;
 
  std::unique_ptr<DdtDataPublisher> publisher;
};
 
}  // namespace ddt
 
#endif /* DDTPUBLISHERSIMULATOR_HPP_ */