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);
 
  void* get_ImageData();
 
  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();
 
  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:
  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);
 
  ddt::DataAcquisition* data_acquisition;
 
  ddt::DataFile* data_file;
 
  ddt::ConfigurationMaps* configuration_maps;
 
  ddt::InformationMaps* information_maps;
 
  boost::signals2::connection connection;
 
  SignalT image_data_available;
 
  cpl_image* internal_image[2];
  int current_index;
  int next_index;
 
  cpl_vector* internal_vector;
 
  cpl_table* internal_binary_table;
 
  int actual_plane[2];
 
  cpl_wcs* wcs[2];
 
  int number_axis[2];
 
  int number_planes[2];
 
  int current_plane;
 
  int number_extensions[2];
 
  int image_width[2];
 
  int image_height[2];
 
  bool unwrap_only[2];
 
  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[2];
 
  std::shared_ptr<DdtEncDec> encdec_image_data;
 
  std::mutex mtx;
  std::mutex mtx2;
};
 
}  // namespace ddt
 
#endif /* IMAGEBUFFER_HPP */