imageHandling.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 imageHandling.hpp
// @brief Image Handling class, offers access to image handling functions.
//
// This file is part of the DDT Image Handling Library and
// provides a class that offers access to the image handling functions for the
// CPL library.
//
// @author Christoph Bortlisz, CGI
// @since  2020/08/14
//
 
#ifndef IMAGEHANDLING_HPP
#define IMAGEHANDLING_HPP
 
#include <sys/stat.h>
 
#include <cpl.h>
#include <algorithm>
#include <cctype>
#undef I
#undef arg
 
#include "ddt/biasBuffer.hpp"
#include "ddt/configurationMaps.hpp"
#include "ddt/dataAcquisition.hpp"
#include "ddt/dataFile.hpp"
#include "ddt/ddtEncDecMultiDim.hpp"
#include "ddt/ddtLogger.hpp"
#include "ddt/imageBuffer.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 ImageHandling {
 public:
  ImageHandling();
 
  virtual ~ImageHandling();
 
  enum CutLevelType {
    AUTO,
    MINMAX,
    USERDEFINED
  };
 
  enum ColorScalingType {
    LINEAR_SCALE,
    LOG_SCALE,
    SQRT_SCALE
  };
 
  void set_logger(ddt::DdtLogger* logger);
 
  bool LoadFile(const std::string& file_name, int position = 0);
 
  bool LoadImageExtensionsAsOne(const std::string& file_name);
 
  void set_CutLevelType(const CutLevelType cut_level_type);
 
  CutLevelType get_CutLevelType();
 
  std::string get_CutLevelTypeStr();
 
  bool ApplyCutLevelsMinMax();
 
  bool ApplyCutLevelsAuto();
 
  bool ApplyCutLevelsManual(const double min_value, const double max_value);
 
  bool ResetCutLevels();
 
  bool LoadColorMaps(std::string color_map_folder,
                     std::string color_map_name = "standard");
 
  bool LoadActualColorMap(std::string color_map_name);
 
  bool LoadActualConfigurationMap(std::string configuration_map_name);
 
  bool LoadConfigurationMaps(std::string configuration_map_source);
 
  int StoreActualImageAsBias(const std::string slot_name = "");
 
  int LoadFileAsBias(const std::string file_name);
 
  bool LoadFileAsBiasInSlot(const std::string file_name, const int slot);
 
  std::string GetBiasSlotName(const int slot);
 
  bool GetBiasEnabled() const;
 
  void EnableBias(const bool enable_bias);
 
  void ApplyBias(const int slot);
 
  int GetCurrentSelectedBiasSlot() const;
 
  void ClearAllBiasImages();
 
  void ClearSelectedBiasImage(const int slot);
 
  void DisplaySelectedBiasImage(const int slot);
 
  void set_RotateFlag(const bool rot_flag);
 
  bool get_RotateFlag();
 
  void set_FlipXFlag(const bool flip_flag);
 
  bool get_FlipXFlag();
 
  void set_FlipYFlag(const bool flip_flag);
 
  bool get_FlipYFlag();
 
  void* get_ImageData();
 
  cpl_image* get_Image();
 
  cpl_table* get_BinaryTable();
 
  int get_ImageWidth();
 
  int get_ImageHeight();
 
  int get_NumberExtensions();
 
  int get_NumberAxis() const;
 
  bool get_LastSegment() const;
 
  FitsExtension* get_FitsExtensionInfo(const int extension_number);
 
  FitsExtension get_PrimaryHDUInfo() const;
 
  void set_CutLevelMin(const double min_value);
 
  void set_CutLevelMax(const double max_value);
 
  double get_CutLevelMin();
 
  double get_CutLevelMax();
 
  double get_ImagePixelMin();
 
  double get_ImagePixelMax();
 
  std::list<std::string> get_ColorMaps();
 
  ddt::colorMap_t* get_ActualColorMap();
 
  ddt::colorMapARGB_t* get_ActualColorMapARGB();
 
  std::string get_ActualColorMapName();
 
  ddt::scalingLut_t* get_ScalingLut();
 
  ddt::scalingLut_t* get_LinearScalingLut();
 
  ddt::scalingLut_t* get_LogarithmicScalingLut();
 
  ddt::scalingLut_t* get_SqrtScalingLut();
 
  ColorScalingType get_ColorScalingType();
 
  void set_ColorScalingTypeLinear();
 
  void set_ColorScalingTypeLogarithmic();
 
  void set_ColorScalingTypeSquareRoot();
 
  void set_ColorScalingType(ColorScalingType scaling_type);
 
  std::string get_ColorScalingTypeStr();
 
  double ImagePixelFromImage(const double x_image, double y_image);
 
  double ImagePixelFromCanvas(const double x_canvas, const double y_canvas,
                              double* x_image, double* y_image);
 
  void ConvertCanvasToImage(const double x_canvas, const double y_canvas,
                            double* x_image, double* y_image);
 
  void ConvertImageToCanvas(const double x_image, const double y_image,
                            double* x_canvas, double* y_canvas);
 
  bool WorldCoordinatesDegreesFromImage(const double x_image,
                                        const double y_image, double* alpha,
                                        double* delta);
 
  bool WorldCoordinatesDegreesFromCanvas(const double x_canvas,
                                         const double y_canvas, double* alpha,
                                         double* delta);
 
  CplStatistics* GetStatisticsCplImageWindow(int llx, int lly, int urx,
                                             int ury);
 
  bool get_AttachedToStream();
 
  bool ReprossImage();
 
  void GetHistogramFromImage(int min_value, int max_value,
                             std::vector<int>& distribution);
 
  void GetHistogramBinsFromImage(int min_value, int max_value,
                                 std::vector<int>& distribution);
 
  void GetCutValuesPercentageFromImage(const double percentage,
                                       double* min_value, double* max_value);
  void AttachDataStream(std::string data_stream_id);
 
  void DetachDataStream(std::string data_stream_id);
 
  cpl_apertures* GetCircularObjects(double sigma);
 
  bool GetObjectCentroidPos(cpl_apertures* apertures, double x_image,
                            double y_image, double* x_centroid,
                            double* y_centroid);
 
  bool GetObjectInformation(double x_image, double y_image, int size,
                            double* x_axis_angle, double* background,
                            double* peak_above_background, double* fwhm_x,
                            double* fwhm_y);
 
  bool GetGaussianParameters(double x_image, double y_image, int size,
                             double* background, double* gaussian_volume,
                             double* correlation, double* gaussian_coord_x,
                             double* gaussian_coord_y, double* sigma_x,
                             double* sigma_y);
 
  std::string GetEquinox();
 
  signal_t* ImageAvailableInBufferSignal();
 
  signal_t* CutLevelChangedSignal();
 
  std::vector<std::string> GetFITSHeader();
 
  double GetPixelToDegreesScalingFactor();
 
 protected:
  ddt::DdtLogger* logger;
 
 private:
  void initialize();
 
  bool process_image();
 
  bool process_temp_image();
 
  bool apply_bias_image();
 
  boost::signals2::connection connect(
      const signal_t::slot_type& event_listener);
 
  void DataAvailable();
 
  std::string readHeaderItem(const cpl_property* const property) const;
 
  void readPropertyValue(std::string& header_item,
                         const cpl_property* const property) const;
 
  ddt::ImageBuffer* image_buffer;
 
  ddt::BiasBuffer* bias_buffer;
 
  ddt::ImageColor* image_color;
 
  ddt::ImageCoords* image_coords;
 
  boost::signals2::connection connection;
 
  signal_t image_available_in_buffer;
 
  signal_t cut_level_changed;
 
  cpl_image* internal_image;
 
  cpl_image* temp_image;
 
  cpl_vector* internal_vector;
 
  cpl_table* internal_binary_table;
 
  int number_axis;
 
  int number_planes;
 
  int number_extensions;
 
  int image_width;
 
  int image_height;
 
  CutLevelType cut_level_type;
 
  double cut_level_min;
 
  double cut_level_max;
 
  double median_filter_size;
  double image_pixel_min;
 
  double image_pixel_max;
 
  bool rotate_flag;
 
  bool flip_x_flag;
 
  bool flip_y_flag;
 
  int actual_plane;
 
  void* internal_image_buffer;
 
  double* internal_vector_buffer;
 
  cpl_wcs* wcs;
 
  std::list<std::string> color_maps;
 
  ddt::colorMap_t* actual_color_map;
 
  ddt::colorMapARGB_t* actual_color_map_argb;
 
  std::string actual_color_map_name;
 
  ColorScalingType color_scaling_type;
 
  bool cut_levels_determined;
 
  bool last_segment;
 
  bool first_segment_received;
 
  int current_bias_selected;
 
  bool bias_enabled;
 
  bool apply_bias;
};
 
}  // namespace ddt
 
#endif /* IMAGEHANDLING_HPP */