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/ddtEncDecBiDim.hpp"
#include "ddt/ddtEncDecMultiDim.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"
 
namespace ddt {
 
class ImageBuffer {
 public:
  ImageBuffer();
 
  virtual ~ImageBuffer();
 
  void set_logger(ddt::DdtLogger* logger);
 
  bool LoadFile(const std::string& file_name, int position = 0);
 
  bool LoadImageExtensionsAsOne(const std::string& file_name);
 
  bool LoadCPLImage(cpl_image* image);
 
  bool LoadActualConfigurationMap(std::string configuration_map_name);
 
  bool LoadConfigurationMaps(std::string configuration_map_source);
 
  void* get_ImageData();
 
  cpl_image* get_Image();
 
  cpl_table* get_BinaryTable();
 
  FitsExtension* get_FitsExtensionInfo(const int extension_number);
 
  FitsExtension get_PrimaryHDUInfo() const;
 
  int get_ImageWidth();
 
  int get_ImageHeight();
 
  int get_NumberPlanes();
 
  int get_NumberExtensions();
 
  int get_NumberAxis();
 
  cpl_wcs* get_Wcs();
 
  cpl_propertylist* get_PropertyList();
 
  cpl_apertures* get_CircularObjects(double sigma);
 
  double get_PixelValue(int x_image, int y_image, int* is_rejected);
 
  bool get_AttachedToStream();
 
  bool get_LastSegment();
 
  bool get_FirstSegmentReceived();
 
  void AttachDataStream(std::string data_stream_id);
 
  void DetachDataStream(std::string data_stream_id);
 
  signal_t* ImageDataAvailableSignal();
 
 protected:
  ddt::DdtLogger* logger;
 
 private:
  void initialize();
 
  bool loadFileData();
 
  bool loadFileDataVector();
 
  bool loadFileDataImage(int plane_number);
 
  bool loadImageExtensionsAsOne();
 
  bool loadWCS();
 
  bool loadPropertyList();
 
  boost::signals2::connection connect(
      const signal_t::slot_type& event_listener);
 
  void dataAvailable();
 
  void handleMultiLayer(ddt::DataSample* data_sample);
 
  void handleMultiDim(ddt::DataSample* data_sample);
 
  void handleBiDim(ddt::DataSample* data_sample);
 
  void handleSingleDim(ddt::DataSample* data_sample, int bytes_per_value,
                       std::string description, std::string dimension,
                       uint32_t data_type);
 
  void deleteCplImage(cpl_image** image);
 
  void applyConfigMap(ddt::DataSample* data_sample, cpl_image* config_map,
                      uint32_t data_type, int dataDim);
 
  ddt::DataAcquisition* data_acquisition;
 
  ddt::DataFile* data_file;
 
  ddt::ConfigurationMaps* configuration_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 number_extensions[2];
 
  int image_width[2];
 
  int image_height[2];
 
  std::list<std::string> config_maps;
 
  cpl_image* actual_configuration_map;
 
  int actual_image_id;
 
  bool last_segment;
 
  bool first_segment_received;
 
  cpl_propertylist* property_list[2];
 
  std::mutex mtx;
};
 
}  // namespace ddt
 
#endif /* IMAGEBUFFER_HPP */