ddtPublisherSimulator.hpp

Go to the documentation of this file.

 
#ifndef DDTPUBLISHERSIMULATOR_HPP_
#define DDTPUBLISHERSIMULATOR_HPP_
 
#include <cpl.h>
 
#include <boost/bind/bind.hpp>
#include <boost/filesystem.hpp>
#include <boost/signals2/signal.hpp>
#include <random>
 
#include "ddt/ddtDataPublisher.hpp"
#include "ddt/ddtDataPublisherApplication.hpp"
#include "ddt/ddtDataTransferFactory.hpp"
#include "ddt/ddtEncDecBinaryxD.hpp"
#include "ddt/ddtEncDecImage2D.hpp"
#include "ddt/ddtEncDecImage3D.hpp"
#include "ddt/ddtLogger.hpp"
#include "ddt/ddtInitCodes.hpp"
#include "ddt/commandLineParser.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;
 
  ddt::InitCodes Init(int argc, char* argv[]);
 
  int Run();
 
  bool RunImageTransfer();
 
  bool RunOscilloscopeTransfer();
 
  bool RunMultiDimensionalArrayTransfer();
 
  bool RunNumericalSampleArrayTransfer();
 
  bool RunSegmentedImageTransfer();
 
  bool RunUnsignedIntegerTransfer(const unsigned int numBits);
 
 private:
  std::unique_ptr<DdtLogger> logger;
 
  std::string broker_uri;
  std::string data_stream_identifier;
  int publishing_interval_milliseconds;
  int num_samples_in_buffer;
  std::string image_folder;
  int mode;
  bool checksum;
 
  bool debug_log_enabled = false;
 
  ddt::CommandLineParserResult ParseCommandLine(int argc, char* argv[]);
 
  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 PublishDataImageTransfer(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 PublishDataSegmentedImageTransfer(const int bytes_per_pixel,
                                         const uint32_t number_pixels_x,
                                         const uint32_t number_pixels_y,
                                         const int vec_elems);
 
  void PublishDataMultiDimension(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 PublishDataUnsignedIntegerTransfer(
      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_ */