imageBuffer.hpp

Go to the documentation of this file.

 
#ifndef IMAGEBUFFER_HPP
#define IMAGEBUFFER_HPP
 
#include <cpl.h>
#include <sys/stat.h>
 
#include <algorithm>
#include <cctype>
#undef I
#undef arg
 
#include "ddt/configurationMaps.hpp"
#include "ddt/dataAcquisition.hpp"
#include "ddt/dataFile.hpp"
#include "ddt/ddtEncDecBinaryxD.hpp"
#include "ddt/ddtEncDecImage2D.hpp"
#include "ddt/ddtEncDecImage3D.hpp"
#include "ddt/ddtLogger.hpp"
#include "ddt/imageColor.hpp"
#include "ddt/imageCoords.hpp"
#include "ddt/imageError.hpp"
#include "ddt/imageIO.hpp"
#include "ddt/imageProc.hpp"
#include "ddt/imageStats.hpp"
#include "ddt/informationMaps.hpp"
 
namespace ddt {

class ImageBuffer {
 public:
  ImageBuffer();

  virtual ~ImageBuffer();

  void set_logger(ddt::DdtLogger* const in_logger);

  bool LoadFile(const std::string& file_name, const int position = 0);

  template <typename TPOINTER>
  bool LoadPointer(TPOINTER* new_image_data, int nx, int ny);

  bool LoadFilePlane(const std::string& file_name, const int position = 0,
                     const int plane = 0);

  bool LoadImageExtensionsAsOne(const std::string& file_name);

  bool LoadCPLImage(cpl_image* const image);

  bool LoadActualConfigurationMap(const std::string configuration_map_name);

  bool LoadConfigurationMaps(const std::string configuration_map_source);

  bool LoadInformationMaps(const std::string information_map_source);

  std::shared_ptr<DdtEncDec> get_MetadataSample();

  cpl_image* get_Image();

  std::string LastTimestampFromBuffer() const;

  cpl_table* get_BinaryTable();

  FitsExtension* get_FitsExtensionInfo(const int extension_number);

  FitsExtension get_PrimaryHDUInfo() const;

  int get_ImageWidth() const;

  int get_ImageHeight() const;

  int get_NumberPlanes() const;

  int get_CurrentPlane() const;

  void set_CurrentPlane(const int plane);

  int get_NumberExtensions();

  int get_NumberAxis() const;

  cpl_wcs* get_Wcs();

  cpl_propertylist* get_PropertyList();

  cpl_apertures* get_CircularObjects(const double sigma);

  double get_PixelValue(const int x_image, const int y_image,
                        int* const is_rejected);

  bool get_AttachedToStream() const;

  bool get_LastSegment() const;

  bool get_FirstSegmentReceived() const;

  bool get_ConfigurationMap_Value(const double x, const double y,
                                  double* const value) const;

  std::list<std::string> get_TextInformation(const double x,
                                             const double y) const;

  std::vector<int> get_invalid_image_hdus() const;

  void AttachDataStream(const std::string data_stream_id);

  void DetachDataStream(const std::string data_stream_id);

  ddt::DdtStatistics* get_DataStatistics();

  void set_RetrieveStatsFlag(bool value);

  SignalT* ImageDataAvailableSignal();

  DataAcquisition::ConnectionStateSignalT* ConnectionStateSignal();
 
  void FreeResources();
 
  // Add meta data items related to the WCS (World Coordinate System)
  // information to the actual property list
  static void AddWCSItemsToPropList(cpl_propertylist* const prop_list,
                                    const std::shared_ptr<DdtEncDec> enc_dec);
 
  // Determine the number of bits per pixel from the data type
  static int32_t BitsPerPixelFromDataType(const uint32_t data_type);
 
 protected:
  ddt::DdtLogger* logger;
 
 private:
 static constexpr size_t InternalBufferImageCount = 2;

 void RotateBufferIndexes();

 void ResetBufferIndexes();

  void Initialize();

  bool LoadFileData();

  bool LoadFileDataVector();

  bool LoadFileDataImage(const int plane_number);

  bool LoadImageExtensionsAsOne();

  bool LoadWCS();

  bool LoadPropertyList();
 
  bool LoadWCSFromMetadata(const std::shared_ptr<DdtEncDecImage2D> enc_dec_2d);
 
  bool LoadWCSFromMetadata(const std::shared_ptr<DdtEncDecImage3D> enc_dec_3d);
 
  bool LoadWCSFromMetadata(const std::shared_ptr<DdtEncDecBinaryxD> enc_dec_xd);
 
  bool AssignPropListAndWcs(cpl_propertylist* const prop_list);

  boost::signals2::connection connect(const SignalT::slot_type& event_listener);

  void DataAvailable();

  void CheckByteOrder(const int topic_id, ddt::DataSample* const data_sample,
                      const std::vector<uint8_t> tmp_data);

  void ChangeByteOrder(ddt::DataSample* const data_sample,
                       const int bytes_per_pixel,
                       const uint32_t data_type) const;

  void HandleMultiLayer(ddt::DataSample* const data_sample);

  void HandleMultiDim(ddt::DataSample* const data_sample);

  void HandleBiDim(ddt::DataSample* const data_sample);

  void HandleSingleDim(ddt::DataSample* const data_sample,
                       const std::string config_map_name,
                       const std::string dimension, const uint32_t data_type);

  void DeleteCplImage(cpl_image** const image, const bool only_unwrap) const;

  void ApplyConfigMap(ddt::DataSample* const data_sample,
                      const cpl_image* const config_map,
                      const uint32_t data_type, const int data_dim);

  std::list<std::string> get_TextInformationForValue(const double value) const;

  void CreateAndInitNewImage(const uint32_t complete_pixels_x,
                             const uint32_t complete_pixels_y,
                             const uint32_t data_type);

  cpl_image* CreateNewImageFromDataSample(ddt::DataSample* const data_sample,
                                          const int bytes_per_pixel,
                                          const int number_pixels_x,
                                          const int number_pixels_y,
                                          const uint32_t data_type,
                                          bool* const only_unwrap);

  cpl_image* CreateNewImageFromLastImage(const int number_pixels_x,
                                         const int number_pixels_y);

  void CopySegmentToImage(const cpl_image* const tmp_image,
                          const uint32_t first_pixel_x,
                          const uint32_t first_pixel_y);

  void FreeAndCreateNew(const uint32_t complete_pixels_x,
                        const uint32_t complete_pixels_y,
                        const uint32_t data_type, const uint32_t image_id,
                        const bool complete_flag);
 
  void LogMetaDataBase(const std::shared_ptr<DdtEncDec> enc_dec);

  void LogMetaDataImage2D(const std::shared_ptr<DdtEncDecImage2D> enc_dec_2d);

  void LogMetaDataImage3D(const std::shared_ptr<DdtEncDecImage3D> enc_dec_3d);

  void LogMetaDataBinaryxD(const std::shared_ptr<DdtEncDecBinaryxD> enc_dec_xd);

  std::unique_ptr<ddt::DataAcquisition> data_acquisition;

  std::unique_ptr<ddt::DataFile> data_file;

  std::unique_ptr<ddt::ConfigurationMaps> configuration_maps;

  std::unique_ptr<ddt::InformationMaps> information_maps;

  boost::signals2::connection connection;

  SignalT image_data_available;

  cpl_image* internal_image[InternalBufferImageCount];
  size_t current_index;
  size_t next_index;

  cpl_vector* internal_vector;

  cpl_table* internal_binary_table;

  int actual_plane[InternalBufferImageCount];

  cpl_wcs* wcs[InternalBufferImageCount];

  int number_axis[InternalBufferImageCount];

  int number_planes[InternalBufferImageCount];

  int current_plane;

  int number_extensions[InternalBufferImageCount];

  int image_width[InternalBufferImageCount];

  int image_height[InternalBufferImageCount];
 
  bool unwrap_only[InternalBufferImageCount];

  std::list<std::string> config_maps;

  cpl_image* actual_configuration_map;

  std::string actual_configuration;

  boost::property_tree::ptree* actual_information_map;

  std::string actual_configuration_map_source;

  std::string actual_information_map_source;

  int actual_image_id;

  std::string last_timestamp;

  bool last_segment;

  bool first_segment_received;
 
  /*
   * Flag indicating if a new image cycle has started
   */
  bool new_image_cycle;

  bool copy_last_segment;

  uint32_t last_first_pixel_x;

  uint32_t last_first_pixel_y;

  cpl_propertylist* property_list[InternalBufferImageCount];

  std::shared_ptr<DdtEncDec> encdec_image_data;

  std::mutex mtx;
};
 
}  // namespace ddt
 
#endif /* IMAGEBUFFER_HPP */