ddtImageWidget.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 ddtImageWidget.hpp
// @brief DDT Widgets. Class for the DDT Image Widget.
//
// Class for the Image Widget. The widget is used to display data of various
// types (e.g. image, plots, etc.)
//
// @author Carsten Mannel, CGI
// @since  2020/01/16
//
 
#ifndef DDT_DATAVISUALISATION_DDTWIDGETS_IMAGEWIDGET_HPP
#define DDT_DATAVISUALISATION_DDTWIDGETS_IMAGEWIDGET_HPP
 
#include <boost/bind.hpp>
#include <boost/signals2/signal.hpp>
 
// Subscriber Library
#include <QList>
#include <QtUiPlugin/QDesignerExportWidget>
#include <QtWidgets>
 
#include "ddt/ddtDataSubscriber.hpp"
#include "ddt/ddtDataTransferFactory.hpp"
#include "ddt/ddtDatavisualisationDefines.hpp"
#include "ddt/ddtGraphicalElementProperties.hpp"
#include "ddt/ddtGraphicalElementRefLine.hpp"
#include "ddt/ddtGraphicalElementSlit.hpp"
#include "ddt/ddtGraphicalElementStatRectangle.hpp"
#include "ddt/ddtGraphicsTextItem.hpp"
#include "ddt/ddtLogger.hpp"
#include "ddt/ddtOverlayRendering.hpp"
#include "ddt/ddtRenderingPlugin.hpp"
#include "ddt/dialogs/ddtDialog.hpp"
#include "ddt/dialogs/ddtDialogFactory.hpp"
#include "ddt/dialogs/ddtDialogIds.hpp"
#include "ddt/imageHandling.hpp"
#include "ddt/widgets/ddtWidget.hpp"
 
class DdtImageWidget;
 
class DdtGraphicsView : public QGraphicsView {
  Q_OBJECT
 
 public:
  explicit DdtGraphicsView(QWidget* parent = nullptr);
 
  void SetConvertPixelToDegrees(const double convPixelDegrees);
 
  void SetDrawMode(const QString mode);
 
  void SetDrawSlitLine(const bool drawLine);
 
  void SetStatisticRect(const double x1, const double y1, const double x2,
                        const double y2);
 
  void AddStatisticRectToScene();
 
  void AddSlitElementToScene();
 
  void AddReferenceLineElementToScene();
 
  void UpdateAllStatistics();
 
 protected:
  void mouseMoveEvent(QMouseEvent* event);
 
  void mousePressEvent(QMouseEvent* event);
 
  void mouseReleaseEvent(QMouseEvent* event);
 
  void mouseDoubleClickEvent(QMouseEvent* event);
 
  void keyPressEvent(QKeyEvent* event);
 
  void wheelEvent(QWheelEvent* event);
 
  void drawForeground(QPainter* painter, const QRectF& rect);
 
  void AddTextItem();
 
 signals:
  void CursorPosition(double x, double y, bool mouse_clicked);
 
  void GraphicalElement(double x1, double y1, double x2, double y2,
                        QString drawMode);
 
  void GraphicalTextElement(double x1, double y1, double x2, double y2,
                            QString drawMode, QString text);
 
  void StatisticRectangle(double x1, double y1, double x2, double y2);
 
  void SlitElement(double target_x, double target_y, double slit_x,
                   double slit_y, double x_offset, double y_offset);
 
  void CalculateHistogramReferenceLine(const QPointF p1, const QPointF p2);
 
  void MouseDecrementScale();
 
  void MouseIncrementScale();
 
 private:
  DdtImageWidget* parent;
 
  bool drawing_enabled = false;
 
  QString draw_mode = "none";
 
  QPointF orig_point;
 
  QPointF cur_point;
 
  double convert_pixel_to_degrees = 0.0;
 
  DdtGraphicsTextItem* text_item = nullptr;
  QString current_text = "";
  QPointF current_text_pos;
 
  DdtGraphicalElementStatRectangle* statistic_rect = nullptr;
  DdtGraphicalElementSlit* slit_element = nullptr;
  DdtGraphicalElementRefLine* ref_line_element = nullptr;
  bool draw_slit_line = false;
  bool slit_config_read = false;
 
  // Configurable properties of slit overlay
  double config_slit_x;
  double config_slit_y;
  double config_slit_size_x;
  double config_slit_size_y;
  double config_slit_angle;
  QString config_slit_color;
 
  void DrawMeasurements(QPainter& painter, const QPointF start,
                        const QPointF end);
 
  void DrawStatisticRectangle(QPainter& painter, const QPointF start,
                              const QPointF end);
 
  void CreateStatisticRect(const double x1, const double y1, const double x2,
                           const double y2);
 
  void DrawRefLine(QPainter& painter, const QPointF start, const QPointF end);
 
  void CreateRefLine(const QPointF start, const QPointF end);
 
  void DrawSlit(QPainter& painter, const QPointF start);
 
  void ReadSlitParameter(const std::string config_file, double* slit_x,
                         double* slit_y, double* slit_size_x,
                         double* slit_size_y, double* slit_angle,
                         QString* slit_color) const;
  void CreateSlit(const QColor line_color, const double slit_x,
                  const double slit_y, const double slit_size_x,
                  const double slit_size_y, const double slit_angle);
 
  void DrawGraphicalElement(QPainter& painter, const QPointF start,
                            const QPointF end);
 
  QPolygonF ConstructArrowHead(QLineF const& line, const qreal arrowSize) const;
 
  QString DegreesToString(double deg) const;
 
  QString ConstructDegreesString(const qreal length) const;
 
  std::string GetConfigPath() const;
};
 
class QDESIGNER_WIDGET_EXPORT DdtImageWidget : public DdtWidget {
  Q_OBJECT
 
  Q_PROPERTY(bool UseOpenGL READ get_use_open_gl WRITE set_use_open_gl)
  Q_PROPERTY(
      bool UseAntialiasing READ get_use_antialiasing WRITE set_use_antialiasing)
  Q_PROPERTY(bool AutoScale READ get_auto_scale WRITE set_auto_scale)
  Q_PROPERTY(QString DefaultScale READ get_default_scale_factor WRITE
                 set_default_scale_factor)
  Q_PROPERTY(QString ScaleFactorList READ get_define_scale_factor WRITE
                 set_define_scale_factor)
  Q_PROPERTY(QString DefaultColourmap READ get_default_colourmap WRITE
                 set_default_colourmap)
  Q_PROPERTY(QString ListContextMenu READ get_list_context_menu WRITE
                 set_list_context_menu)
  Q_PROPERTY(QString DefautBiasImage READ get_default_bias_image WRITE
                 set_default_bias_image)
  Q_PROPERTY(
      bool ShowScrollbars READ get_show_scrollbars WRITE set_show_scrollbars)
 
 public:
  // Constructors / Destructors
  //
 
  explicit DdtImageWidget(QWidget* parent = nullptr);
 
  virtual ~DdtImageWidget();
 
  // Getters and Setters for properties
  //
 
  bool get_use_open_gl();
 
  void set_use_open_gl(bool use_open_gl);
 
  bool get_use_antialiasing();
 
  void set_use_antialiasing(bool use_antialiasing);
 
  bool get_auto_scale();
 
  void set_auto_scale(bool auto_scale);
 
  void ReadScaleFactors();
 
  QList<QString> SortedScaleFactors(QMap<QString, float> scale_map);
 
  QString get_define_scale_factor() const;
 
  void set_define_scale_factor(const QString new_values);
 
  QString get_default_scale_factor() const;
 
  void set_default_scale_factor(const QString new_default_scale_factor);
 
  QString get_default_colourmap() const;
 
  void set_default_colourmap(const QString new_default_colourmap);
 
  void set_list_context_menu(const QString new_list_context_menu);
 
  QString get_list_context_menu() const;
 
  QString get_default_bias_image() const;
 
  void set_default_bias_image(const QString set_bias_image);
 
  bool get_show_scrollbars() const;
 
  void set_show_scrollbars(const bool set_show_scrollbars);
 
  // Graphical Elements
  //
 
  DdtGraphicalElementProperties get_overlay_properties();
 
  // Further getters and setters
  //
 
  void set_logger(ddt::DdtLogger* logger);
 
  // Utility functions
  //
 
  float ParseFractionString(QString fraction_str);
 
  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);
 
  // Event handling
  //
 
  bool eventFilter(QObject* obj, QEvent* event);
 
  void HandleNewBoostDataEvent();
 
  void CutLevelChanged();
 
  void ReloadGraphicsItem();
 
  void UpdateThumbnailImages();
 
  void UpdateAllStatistics();
 
  void CloseAllDialogs();
 
  void MarkPositions();
 
  QString EndMarkPositions();
 
  void RegisterLastSegmentCallback(
      std::function<void()> const& lastSegmentFunction);
 
 protected:
  // Logger
  ddt::DdtLogger* logger;
 
  // Graphics Library
 
  DdtOverlayRendering* overlay_rendering;
 
  DdtGraphicalElementProperties overlay_properties;
 
 private:
  // Private members
  //
 
  // Data Stream access
  QString current_stream_id;
  boost::signals2::connection connection;
  boost::signals2::connection connection_cutlevel;
 
  // Data file access
  QString last_image_path;
  QString last_selected_file;
 
  // Image display
  DdtGraphicsView* view;
  QGraphicsScene* scene;
  QGraphicsItem* current_image_item;
 
  ddt::ImageHandling* imgHandling;
 
  int current_image_width;
  int current_image_height;
 
  // Pick mode
  PickMode current_pick_mode;
  int current_pick_pixels_size;
  int current_pick_object_no_samples;
 
  // Tabular region
  int current_tab_region_x_size;
  int current_tab_region_y_size;
 
  // Flags
  bool scrollbar_moved_externally;
 
  bool current_flip_state_vertical;
  bool current_flip_state_horizontal;
 
  bool defaults_set;
 
  // Rendering plugins
  QList<DdtRenderingPlugin*> rendering_plugins;
 
  // Map for access to dialogs
  QMap<QString, DdtDialog*> dialog_map;
  QMap<QString, QString> dialogname_map;
 
  // Context menu
  QStringList context_menu_entries;
 
  // Set of image points selected by user
  QList<QPointF> point_list;
  bool mark_position_mode;
 
  // Last segment callback
  std::function<void()> last_segment_callback;
 
 protected:
  // Protected members
  //
 
  // Image Widget Properties
  //
 
  bool use_open_gl;
 
  bool use_antialiasing;
 
  bool auto_scale;
 
  QString default_scale_factor;
 
  QString default_bias_image;
 
  bool show_scrollbars;
 
  QString current_scale_factor;
 
  QString current_magnification_factor;
 
  QString current_pick_object_magnification_factor;
 
  int last_magnify_x;
 
  int last_magnify_y;
 
  QMap<QString, float> scale_factor_pool;
 
  QMap<QString, float> scale_factor_favorites;
 
  QString define_scale_factor;
 
  QString default_colourmap;
 
  QString list_context_menu;
 
  // Configuration items
  //
 
  QString colourmap_directory;
 
  QString configurationmap_directory;
 
  // Image handling
  //
 
  QTransform scaling_transform;
 
  QTransform rotation_transform;
 
  void resizeEvent(QResizeEvent* event);
 
  void RemoveAllItemsFromScene();
 
  void RemoveAllOverlayItemsFromScene();
 
 protected:
  // Image statistics
  //
 
  void CalculatePickStatistics(PickMode pick_mode, double x, double y,
                               double pixelvalue, QString ra, QString decl);
 
  void GetTabularRegion(const double x_image, const double y_image);
 
 private:
  // Private Methods
  //
 
  // Widget setup
  void Initialize();
  void CreateWidget();
  void SetDefaultSettings();
  void SetDefaultColourmapSettings();
  void SetDefaultConfigurationmapSettings();
  void SetDefaultBiasImageSettings();
 
  // Context Menu and Dialogs
  void InitializeContextMenu();
  void InitializeDialogMap();
 
  // File access
  void BrowseForFile();
  void BrowseForFileExt();
  void SaveAsFile();
 
  // Colourmap handling
  void UpdateColourmap();
 
  // FITS Header updates
  void UpdateFitsHeaderDialog();
 
  // BIAS handling
  void StoreCurrentImage();
  void DisplaySelected(const QVariant parameter);
  void LoadFromDisc(const QVariant parameter);
 
  // PVCM handling
  void SendCutValuesAndHistogram();
 
  // HDU handling
  void CheckHDUs();
 
  // Binary Table handling
  void CheckBinaryTable(const QString extensionName);
  void FillTable(cpl_table* const table, const cpl_array* const column_names,
                 int* const ncol, int* const nrow, const QString extensionName);
  void FillSingleTable(cpl_table* const table, const char* const col_name,
                       QList<QVariant>& singleTable,
                       QList<QVariant>& singleColNames, const int rows,
                       int* const numVals, int* const cols) const;
  void FillSingleTableString(cpl_table* const table, const char* const col_name,
                             QList<QVariant>& singleTable,
                             const int rows) const;
  void FillSingleTableInt(cpl_table* const table, const char* const col_name,
                          QList<QVariant>& singleTable, const int rows) const;
  void FillSingleTableIntArr(cpl_table* const table, const char* const col_name,
                             QList<QVariant>& singleTable, const int rows,
                             int* const numVals) const;
  void FillSingleTableFloat(cpl_table* const table, const char* const col_name,
                            QList<QVariant>& singleTable, const int rows) const;
  void FillSingleTableFloatArr(cpl_table* const table,
                               const char* const col_name,
                               QList<QVariant>& singleTable, const int rows,
                               int* const numVals) const;
  void FillSingleTableDouble(cpl_table* const table, const char* const col_name,
                             QList<QVariant>& singleTable,
                             const int rows) const;
  void FillSingleTableDoubleArr(cpl_table* const table,
                                const char* const col_name,
                                QList<QVariant>& singleTable, const int rows,
                                int* const numVals) const;
 
  void SetFitsTableParameter(const int tableNumber, const int rows,
                             const int cols, const QList<QVariant> singleTable,
                             const QList<QVariant> singleColNames);
 
 protected:
  // Protected Methods
  //
 
  // Widget interface
 
  // Magnification widget
 
  void MagnifyImage(int x, int y, const bool pick_mode = false);
 
  void MagnifyImageWithFactor(const QString mag_factor_str,
                              const int mag_fact_index, const int x,
                              const int y);
 
  // Dialog interfaces
  void SetInitialDialogParameters(DdtDialog* dialog, const QString dialog_id);
  void SetInitialDialogParametersColourmapDialog(DdtDialog* dialog,
                                                 const QString dialog_id);
  void SetInitialDialogParametersPickObjectDialog(DdtDialog* dialog,
                                                  const QString dialog_id);
  void SetInitialDialogParametersFITSHeaderDialog(DdtDialog* dialog,
                                                  const QString dialog_id);
 
  void SetInitialDialogParametersHDUDialog(DdtDialog* dialog,
                                           const QString dialog_id);
 
  void SetInitialDialogParametersTabularRegionDialog(DdtDialog* dialog,
                                                     const QString dialog_id);
 
  void SetInitialDialogParametersGraphicalDialog(DdtDialog* dialog,
                                                 const QString dialog_id);
 
  void SetInitialDialogParametersCutValuesDialog(DdtDialog* dialog,
                                                 const QString dialog_id);
 
  void SetInitialDialogParametersBiasDialog(DdtDialog* dialog,
                                            const QString dialog_id);
 
  void SetInitialDialogParametersScaleRotateCutValuesDialog(
      DdtDialog* dialog, const QString dialog_id);
 
  void SetInitialDialogParametersStatisticDialog(DdtDialog* dialog,
                                                 const QString dialog_id);
 
  void SetInitialDialogParametersPVCMDialog(DdtDialog* dialog,
                                            const QString dialog_id);
 
  void SetInitialDialogParametersReferenceLineDialog(DdtDialog* dialog,
                                                     const QString dialog_id);
 
  void SetInitialDialogParametersDataStreamDialog(DdtDialog* dialog,
                                                  const QString dialog_id);
 
  void DialogParameterChangedColourmapDialog(const QString parameter_id,
                                             const QVariant parameter);
  void DialogParameterChangedPickObject(const QString parameter_id,
                                        const QVariant parameter);
 
  void DialogParameterChangedTabularRegion(const QString parameter_id,
                                           const QVariant parameter);
 
  void DialogParameterChangedGraphicalElements(const QString parameter_id,
                                               const QVariant parameter);
 
  void DialogParameterChangedCutValues(const QString parameter_id,
                                       const QVariant parameter);
 
  void DialogParameterChangedScaleRotateCutValues(const QString parameter_id,
                                                  const QVariant parameter);
 
  void DialogParameterChangedBias(const QString parameter_id,
                                  const QVariant parameter);
 
  void DialogParameterChangedStatistic(const QString parameter_id,
                                       const QVariant parameter);
 
  void DialogParameterChangedSlit(const QString parameter_id,
                                  const QVariant parameter);
 
  void DialogParameterChangedPVCM(const QString parameter_id,
                                  const QVariant parameter);
 
  void DialogParameterChangedReferenceLine(const QString parameter_id,
                                           const QVariant parameter);
 
  void DialogParameterChangedDataStream(const QString parameter_id,
                                        const QVariant parameter);
 
  void DialogParameterChangedHDU(const QString parameter_id,
                                 const QVariant parameter);
 
 public slots:
  // Public slots
  //
 
  // Dialog interface
  //
 
  void DialogParameterChanged(const QString dialog_id,
                              const QString parameter_id,
                              const QVariant parameter);
 
  // Data Stream Widget interface
  //
 
  void AttachDataStream(const QString data_stream_id);
 
  void DetachDataStream(const QString data_stream_id);
 
  void AttachDataFile(QString filename);
 
  void AttachImageExtensionsAsOne(QString filename);
 
  // Flip Rotate Widget interface
  //
 
  void FlipImage(bool vertical_axis, bool horizontal_axis);
 
  void RotateImage(int rotation_angle);
 
  // Panning Widget interface
  //
 
  void UpdatePosition(double scroll_fraction_x, double scroll_fraction_y);
 
  // Scale Buttons Widget interface
  void IncrementScale();
 
  void DecrementScale();
 
  void SetToDefaultScale();
 
  void SelectNewScale(QString nextScale);
 
  void ScaleFactorForNewImage();
 
  QString FindAutoScale();
 
  // Graphical Elements Dialog
 
  void GraphicalElement(double x1, double y1, double x2, double y2,
                        const QString draw_mode);
 
  void GraphicalTextElement(double x1, double y1, double x2, double y2,
                            const QString draw_mode, QString text);
 
  // Statistics Dialog
 
  void StatisticRectangle(const double x1, const double y1, const double x2,
                          const double y2);
 
  // Slit Dialog
 
  void SlitElement(const double target_x, const double target_y,
                   const double slit_x, const double slit_y,
                   const double x_offset, const double y_offset);
 
  // Reference Line Dialog
 
  void CalculateHistogramReferenceLine(QPointF p1, QPointF p2);
 
  // Magnification Widget interface
  //
  void SetMagnificationFactor(QString magnification_factor);
 
  // Cursor Information Widget interface
  //
 
  void CursorPosition(double x, double y, bool mouse_clicked);
 
  // Cut Values Widget interface
  //
 
  void SetCutValues(double low, double high);
 
  void SetAutoCuts();
 
  void SetMinMaxCuts();
 
  // Internal slots
  //
 
  void DetachStream();
 
  void HandleNewDataEvent();
 
  void SetAutoScaleState(const bool new_auto_scale_state);
 
 private slots:
  // Private slots
  //
 
  // Loading rendering plugins
  void LoadRenderingPlugins();
 
  // Scrollbar handling
  void ScrollBarMoved(int pos);
 
  // Context menu related
  void DisplayContextMenu(const QPoint& pos);
  void ExecuteContextMenuCommand(QString command);
 
 signals:
 
  // Signals
  //
 
  // Dialogs
  //
 
  void SetChangedDialogParameter(QString param_id, QVariant parameter);
 
  // Panning Widget interface
  //
 
  void UpdatedImage(QImage*);
 
  void ImageWidgetViewChanged(QRectF visible_image_rect,
                              int current_image_width,
                              int current_image_height);
 
  void NewBoostDataEvent();
 
  // Cursor Information Widget Interface
  //
 
  void CursorInfo(double x, double y, double pixelvalue, QString ra,
                  QString decl);
 
  // Flip Rotate Widget Interface
  //
  void UpdateFlipStatus(bool vertical, bool horizontal);
 
  // Magnification Widget interface
  //
 
  void MagnifiedImage(QImage magnified_image);
 
  // Cut Values Widget interface
  //
 
  void CurrentCutValues(double cutvalue_min, double cutvalue_max,
                        ddt::ImageHandling::CutLevelType cutvalue_type);
 
  // Colourmap Widget interface
  //
 
  void SetCurrentColourmap(QVector<QRgb> colourtable);
 
  void UpdateColourbarAxis(double min_value, double max_value,
                           int scaling_function);
 
  // Data Stream Widget
  //
 
  void CurrentConnectStatus(QString data_stream_id, ConnectionStatus status);
 
  // Image Widget interface - internal slots
  //
 
  void ContextMenuCommandSelected(QString menu_entry);
 
  // Image Scale Widget interface
  //
 
  void ScaleFactorListChanged(QList<QString> scale_factor_list);
 
  void UpdateScaleFactor(QString new_scale_factor);
 
  void UpdateAutoScale(bool new_state);
};
 
#endif  // DDT_DATAVISUALISATION_DDTWIDGETS_IMAGEWIDGET_HPP