imageBuffer.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 imageBuffer.hpp
// @brief Image Buffer class, handles internal CPL image.
//
// This file is part of the DDT Image Handling Library and
// provides a class that handles the internal CPL image.
//
// @author Christoph Bortlisz, CGI
// @since  2020/10/01
//
 
#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);
 
  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();
 
  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);
 
  signal_t* 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 DdtEncDec* const encDec);
 
  // 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 DdtEncDecImage2D* const encDec2D);
 
  bool loadWCSFromMetadata(const DdtEncDecImage3D* const encDec3D);
 
  bool loadWCSFromMetadata(const DdtEncDecBinaryxD* const encDecxD);
 
  bool assignPropListAndWcs(cpl_propertylist* const prop_list);
 
  boost::signals2::connection connect(
      const signal_t::slot_type& event_listener);
 
  void dataAvailable();
 
  void checkByteOrder(const int topic_id, ddt::DataSample* const data_sample,
                      const std::vector<uint8_t> tmpData);
 
  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 dataDim);
 
  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 uint32_t complete_pixels_y,
                                         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,
                          const uint32_t complete_pixels_y,
                          const int number_pixels_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 DdtEncDec* const encDec);
 
  void logMetaDataImage2D(DdtEncDecImage2D* const encDec2D);
 
  void logMetaDataImage3D(DdtEncDecImage3D* const encDec3D);
 
  void logMetaDataBinaryxD(DdtEncDecBinaryxD* const encDecxD);
 
  ddt::DataAcquisition* data_acquisition;
 
  ddt::DataFile* data_file;
 
  ddt::ConfigurationMaps* configuration_maps;
 
  ddt::InformationMaps* information_maps;
 
  boost::signals2::connection connection;
 
  signal_t 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::mutex mtx;
  std::mutex mtx2;
};
 
}  // namespace ddt
 
#endif /* IMAGEBUFFER_HPP */