imageHandling.hpp

Go to the documentation of this file.

 
#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);

  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);

  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();

  void AddCustomColorMaps(ddt::colorMap_t const& colourmap,
                          ddt::colorMap_t const& colourmap_inverted,
                          ddt::colorMapARGB_t const& colourmap_argb,
                          ddt::colorMapARGB_t const& colourmap_argb_inverted);

  std::string get_LastSelectedColourmapName() const;

  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_image* DuplicateImage();

  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;

  std::shared_ptr<DdtEncDec> get_MetadataSample();

  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;

  int get_ImageBitsPerPixel() 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);

  void set_InvertColourmap(const bool invert);

  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;

  ddt::DdtStatistics* get_DataStatistics();

  void set_RetrieveStatsFlag(bool value);

  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();

  SignalT* ImageAvailableInBufferSignal();

  DataAcquisition::ConnectionStateSignalT* ConnectionStateSignal();

  SignalT* CutLevelChangedSignal();

  std::vector<std::string> GetPrimaryFITSHeader();

  std::vector<std::vector<std::string>> GetExtensionsFITSHeader();

  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 ProcessImage();

  bool ProcessTempImage();

  bool DetermineCutLevelsAndMinMax();

  bool ApplyBiasImage();

  boost::signals2::connection connect(const SignalT::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;

  std::unique_ptr<ddt::ImageBuffer> image_buffer;

  std::unique_ptr<ddt::BiasBuffer> bias_buffer;

  std::unique_ptr<ddt::ImageColor> image_color;

  std::unique_ptr<ddt::ImageCoords> image_coords;

  boost::signals2::connection connection;

  SignalT image_available_in_buffer;

  SignalT cut_level_changed;

  cpl_image* internal_image;

  cpl_image* temp_image;

  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;

  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;

  std::string last_selected_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;

  std::mutex mtx;
};
 
}  // namespace ddt
 
#endif /* IMAGEHANDLING_HPP */