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/ddtEncDecBinaryxD.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* const in_logger);
 
  void FreeResources();
 
  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);
 
  void set_CutLevelType(const CutLevelType in_cut_level_type);
 
  CutLevelType get_CutLevelType() const;
 
  std::string get_CutLevelTypeStr() const;
 
  bool ApplyCutLevelsMinMax();
 
  bool ApplyCutLevelsMinMax(const double lowerleftx, const double lowerlefty,
                            const double upperrightx, const double upperrighty);
 
  bool ApplyCutLevelsAuto();
 
  bool ApplyCutLevelsAuto(const double lowerleftx, const double lowerlefty,
                          const double upperrightx, const double upperrighty);
 
  bool ApplyCutLevelsManual(const double min_value, const double max_value);
 
  bool ResetCutLevels();
 
  bool LoadColorMaps(const std::string color_map_folder,
                     std::string color_map_name = "standard");
 
  bool LoadActualColorMap(std::string color_map_name);
 
  bool LoadActualConfigurationMap(const std::string configuration_map_name);
 
  bool LoadConfigurationMaps(const std::string configuration_map_source);
 
  bool LoadInformationMaps(const std::string information_map_source);
 
  int StoreActualImageAsBias(const std::string slot_name = "");
 
  bool StoreActualImageAsBiasInSlot(const std::string slot_name,
                                    const int slot);
 
  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);
 
  int get_CurrentPlane() const;
 
  void set_CurrentPlane(const int plane);
 
  void set_RotateFlag(const bool rot_flag);
 
  bool get_RotateFlag() const;
 
  void set_FlipXFlag(const bool flip_flag);
 
  bool get_FlipXFlag() const;
 
  void set_FlipYFlag(const bool flip_flag);
 
  bool get_FlipYFlag() const;
 
  void* get_ImageData();
 
  cpl_image* get_Image();
 
  cpl_table* get_BinaryTable();
 
  int get_ImageWidth() const;
 
  int get_ImageHeight() const;
 
  int get_NumberExtensions();
 
  int get_NumberAxis() const;
 
  int get_NumberPlanes() const;
 
  bool get_LastSegment() const;
 
  std::string get_Timestamp() const;
 
  FitsExtension* get_FitsExtensionInfo(const int extension_number);
 
  FitsExtension get_PrimaryHDUInfo() const;
 
  bool get_ImageRotation(double* const rotation_angle) const;
 
  void set_CutLevelMin(const double min_value);
 
  void set_CutLevelMax(const double max_value);
 
  double get_CutLevelMin() const;
 
  double get_CutLevelMax() const;
 
  double get_ImagePixelMin() const;
 
  double get_ImagePixelMax() const;
 
  std::list<std::string> get_ColorMaps() const;
 
  ddt::colorMap_t* get_ActualColorMap();
 
  ddt::colorMapARGB_t* get_ActualColorMapARGB();
 
  std::string get_ActualColorMapName() const;
 
  ddt::scalingLut_t* get_ScalingLut();
 
  ddt::scalingLut_t* get_LinearScalingLut();
 
  ddt::scalingLut_t* get_LogarithmicScalingLut();
 
  ddt::scalingLut_t* get_SqrtScalingLut();
 
  ColorScalingType get_ColorScalingType() const;
 
  void set_ColorScalingTypeLinear();
 
  void set_ColorScalingTypeLogarithmic();
 
  void set_ColorScalingTypeSquareRoot();
 
  void set_ColorScalingType(const ColorScalingType scaling_type);
 
  std::string get_ColorScalingTypeStr() const;
 
  double ImagePixelFromImage(const double x_image, double y_image);
 
  double ImagePixelFromCanvas(const double x_canvas, const double y_canvas,
                              double* const x_image, double* const y_image);
 
  void ConvertCanvasToImage(const double x_canvas, const double y_canvas,
                            double* const x_image, double* const y_image) const;
 
  void ConvertImageToCanvas(const double x_image, const double y_image,
                            double* const x_canvas,
                            double* const y_canvas) const;
 
  bool WorldCoordinatesDegreesFromImage(const double x_image,
                                        const double y_image, double* alpha,
                                        double* delta) const;
 
  bool ImageCoordinatesFromWorldCoordinatesDegrees(const double alpha,
                                                   const double delta,
                                                   double* const x_image,
                                                   double* const y_image) const;
 
  bool WorldCoordinatesDegreesFromCanvas(const double x_canvas,
                                         const double y_canvas, double* alpha,
                                         double* delta);
 
  bool CanvasCoordinatesFromWorldCoordinatesDegrees(const double alpha,
                                                    const double delta,
                                                    double* const x_canvas,
                                                    double* const y_canvas);
 
  CplStatistics* GetStatisticsCplImageWindow(int llx, int lly, int urx,
                                             int ury);
 
  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;
 
  bool get_AttachedToStream() const;
 
  bool ReprocessImage();
 
  // Get the histogram from the image, taking all pixel from the range defined
  // by min_value and max_value into account. The resulting pixel distribution
  // vector is returned in the distribution argument
  void GetHistogramFromImage(const int64_t min_value, const int64_t max_value,
                             std::vector<int>& distribution) const;
 
  // Get the histogram (in bins) from the image, taking all pixel from the range
  // defined by min_value and max_value into account. The resulting pixel
  // distribution vector is returned in the distribution argument
  void GetHistogramBinsFromImage(const int64_t min_value,
                                 const int64_t max_value,
                                 std::vector<int>& distribution) const;
 
  // Determine cut values such that a specified percentage of all pixels fall
  // between these cut values
  void GetCutValuesPercentageFromImage(const double percentage,
                                       double* const min_value,
                                       double* const max_value) const;
  void AttachDataStream(const std::string data_stream_id);
 
  void DetachDataStream(const std::string data_stream_id);
 
  cpl_apertures* GetCircularObjects(const double sigma);
 
  bool GetObjectCentroidPos(const cpl_apertures* const apertures,
                            const double x_image, const double y_image,
                            double* const x_centroid,
                            double* const y_centroid) const;
 
  bool GetObjectInformation(const double x_image, const double y_image,
                            const int size, double* const x_axis_angle,
                            double* const background,
                            double* const peak_above_background,
                            double* const fwhm_x, double* const fwhm_y,
                            double* const object_coord_x,
                            double* const object_coord_y);
 
  bool GetGaussianParameters(const double x_image, const double y_image,
                             const int size, double* const background,
                             double* const gaussian_volume,
                             double* const correlation,
                             double* const gaussian_coord_x,
                             double* const gaussian_coord_y,
                             double* const sigma_x, double* const sigma_y);
 
  std::string GetEquinox();
 
  signal_t* ImageAvailableInBufferSignal();
 
  signal_t* CutLevelChangedSignal();
 
  std::vector<std::string> GetFITSHeader();
 
  cpl_propertylist* GetPropertyList();
 
  double GetPixelToDegreesScalingFactor();
 
  double GetImagePixelDistance(const double startx, const double starty,
                               const double endx, const double endy,
                               double* const xoffset = nullptr,
                               double* const yoffset = nullptr) const;
 
  double GetImagePixelDistanceDegrees(const double startx, const double starty,
                                      const double endx, const double endy,
                                      double* const xoffsetdeg = nullptr,
                                      double* const yoffsetdeg = nullptr);
 
  std::vector<int> get_invalid_image_hdus() const;
 
 protected:
  ddt::DdtLogger* logger;
 
 private:
  void initialize();
 
  bool process_image();
 
  bool process_temp_image();
 
  bool determine_cut_levels_and_min_max();
 
  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;
 
  std::string getStringProperty(const std::string string_prop) 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;
 
  std::string last_timestamp;
 
  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 */