ddtImageWidget.hpp

Go to the documentation of this file.

 
#ifndef DDT_DATAVISUALISATION_DDTWIDGETS_IMAGEWIDGET_HPP
#define DDT_DATAVISUALISATION_DDTWIDGETS_IMAGEWIDGET_HPP
 
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
 
#include <boost/bind.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.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/widgets/ddtGraphicsView.hpp"
#include "ddt/widgets/ddtWidget.hpp"
 
class DdtGraphicsView;
 
typedef boost::signals2::signal<void(const std::string&)> signal_response;
 
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 ListDialogsMenu READ get_list_dialogs_menu WRITE
                 set_list_dialogs_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();
 
  DdtOverlayRendering* GetOverlayRendering();
 
  void ProcessRemoteCommand(const std::string& command_name,
                            const std::vector<std::string>& command_arguments);
 
  void InitializeDialogMap(const QMap<QString, DdtDialog*> insert_map);
 
  QString FetchDialogName(const QString dialog_id) const;
 
  signal_response response_signal;
 
  // Getters and Setters for properties
  //
 
  bool get_use_open_gl() const;
 
  void set_use_open_gl(const bool open_gl);
 
  bool get_use_antialiasing() const;
 
  void set_use_antialiasing(const bool antialiasing);
 
  bool get_auto_scale() const;
 
  void set_auto_scale(const bool 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;
 
  void set_list_dialogs_menu(const QString new_list_dialogs_menu);
 
  QString get_list_dialogs_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();
 
  DdtGraphicalOverlay* get_graphical_overlay();
 
  void RedrawOverlay();
 
  // Further getters and setters
  //
 
  void set_logger(ddt::DdtLogger* const in_logger);
 
  // Utility functions
  //
 
  float ParseFractionString(QString fraction_str);
 
  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;
 
  // 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);
 
  void SetOverlayImageFile(const QString overlay_file);
 
  void AddRenderingPlugins(DdtRenderingPlugin* const new_plugin);
 
  void SetActiveRenderingPlugin(const int rendering_plugin_id);
 
  void ActivateTimestampDisplay();
 
 protected:
  // Logger
  ddt::DdtLogger* logger;
 
  // Graphics Library
 
  DdtOverlayRendering* overlay_rendering;
 
  DdtGraphicalElementProperties overlay_properties;
 
 private:
  // Private members
  //
 
  // Data Stream access
  QString current_stream_id;
  QString last_stream_id;
  boost::signals2::connection connection;
  boost::signals2::connection connection_cutlevel;
 
  // Data file access
  QString last_image_path;
  QString last_selected_file;
  int current_extension;
  std::atomic<bool> overlay_file_loaded;
 
  // Image display
  DdtGraphicsView* view;
  QGraphicsScene* scene;
  QGraphicsItem* current_image_item;
 
  ddt::ImageHandling* img_handling;
 
  int current_image_width;
  int current_image_height;
 
  std::atomic<bool> image_cleared;
 
  // Pick mode
  PickMode current_pick_mode;
  bool show_pick_marker;
  int current_pick_pixels_size;
  int current_pick_object_no_samples;
  int last_pick_x;
  int last_pick_y;
  std::atomic<bool> datastream_pick;
  double datastream_picked_x;
  double datastream_picked_y;
 
  // Tabular region
  int current_tab_region_x_size;
  int current_tab_region_y_size;
 
  // Pixel vs Colourmap
  std::atomic<PvcmParameters> pvcm_param;
 
  // Flags
  bool scrollbar_moved_externally;
 
  bool current_flip_state_vertical;
  bool current_flip_state_horizontal;
 
  bool defaults_set;
 
  bool display_timestamp;
 
  // Rendering plugins
  QList<DdtRenderingPlugin*> rendering_plugins;
  int active_rendering_plugin_index;
 
  // Maps for access to dialogs
  QMap<QString, DdtDialog*> dialog_map;
  QMap<QString, bool> dialog_init_map;
  QMap<QString, QString> dialogname_map;
 
  // Context menu
  QStringList context_menu_entries;
  QString static_overlay_entry;
 
  // Set of image points selected by user
  QList<QPointF> point_list;
  bool mark_position_mode;
 
  // Last segment callback
  std::function<void()> last_segment_callback;
 
  // Constants
  const int CLOCKWISE = 90;
  const int ANTICLOCKWISE = -90;
  const int NUM_ARGS_REMOTE_ATTACH = 2;
 
 protected:
  // Protected members
  //
 
  // Image Widget Properties
  //
 
  bool use_open_gl;
 
  bool use_antialiasing;
 
  bool auto_scale;
 
  QString default_scale_factor;
 
  bool no_wait_new_data;
 
  QString default_bias_image;
 
  bool show_scrollbars;
 
  QString current_scale_factor;
 
  QString current_magnification_factor;
 
  QString current_pick_object_magnification_factor;
 
  QString current_dialog_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;
 
  QString list_dialogs_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();
 
  void GraphicsControlCheckTaggedItems(DdtGraphicalOverlay* overlay,
                                       QString tag, bool flag);
 
 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
  //
  void HandleImage();
 
  bool CheckMemAvailability(const QString filename,
                            const int extension_number) const;
  bool CheckMemAvailabilityImageExtensions(const QString filename) const;
  void GetDimensionInfo(const cpl_propertylist* const property_list,
                        int* const number_axis, int* const image_width,
                        int* const image_height, int* const byte_pix) const;
  void ReadMemoryInfo(qint64* const mem_total, qint64* const mem_available,
                      qint64* const swap_free) const;
 
  bool LoadExtension(const QString filename, int& extension_number);
 
  void UpdatePick();
  void StoreDataStreamPick();
  double ConsiderFlipState(double angle) const;
  bool CheckIfPickInactive() const;
  void UpdatePVCMDialog();
  void UpdatePVCMDialogMinMax();
  void UpdatePVCMDialogAutoCuts();
  void UpdatePVCMDialogCutValues();
  void UpdatePVCMDialogPercent();
 
  // Remote commands
  void RemoteAttach(const QStringList args);
  void RemoteDetach();
  void RemoteRotate(const QStringList args);
  void RemoteFlip(const QStringList args);
  void RemoteZoom(const QStringList args);
  void RemoteScale(const QStringList args);
  void RemotePointSelection();
  void RemoteStatistics();
  void RemoteTabularRegion();
  void RemoteScaleRotateCut();
  void RemoteSlit();
  void RemotePick();
  void RemoteLoad(const QStringList args);
  void RemoteDistance();
  void RemoteOverlay(const QStringList args);
 
  bool Xor(const bool state_a, const bool state_b) const;
 
  // Widget setup
  void Initialize();
  void CreateWidget();
  void SetDefaultSettings();
  void SetDefaultColourmapSettings();
  void SetDefaultConfigurationmapSettings();
  void SetDefaultBiasImageSettings();
 
  // Context Menu and Dialogs
  void InitializeContextMenu();
  void InitializeDialogNames();
  QStringList AddDefaultContextMenuEntries() const;
  void ExecuteDialog(const QString dialog_id);
  QMenu* ComposeDialogsContextMenu(const QString menu_title);
 
  // File access
  void BrowseForFile();
  void BrowseForFileExt();
  void SaveAsFile();
  void ClearImage();
  void StaticOverlay();
 
  // Colourmap handling
  void UpdateColourmap();
 
  // FITS Header updates
  void UpdateFitsHeaderDialog();
 
  // Metadata Sample updates
  void UpdateMetadataSampleDialog();
 
  // Update image
  void UpdateImage(const QImage* const image);
 
  // Update current plane
  void UpdateCurrentPlane();
 
  // BIAS handling
  void StoreCurrentImage(const int dest_slot);
  void DisplaySelected(const QVariant parameter);
  void LoadFromDisc(const QVariant parameter);
 
  // PVCM handling
  void SendCutValuesAndHistogram();
 
  // Cut values handling
  void HandleCutValuesParameter(const QString parameter_id,
                                const QVariant parameter,
                                const QString dialog_id);
  // HDU handling
  void CheckHDUs();
 
  // Binary Table handling
  void CheckBinaryTable(const QString extension_name);
  void FillTable(cpl_table* const table, const cpl_array* const column_names,
                 int* const ncol, int* const nrow,
                 const QString extension_name);
  void FillSingleTable(cpl_table* const table, const char* const col_name,
                       QList<QVariant>& single_table,
                       QList<QVariant>& single_col_names, const int rows,
                       int* const num_vals, int* const cols) const;
  void FillSingleTableString(cpl_table* const table, const char* const col_name,
                             QList<QVariant>& single_table,
                             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>& single_table, const int rows,
                             int* const num_vals) const;
  void FillSingleTableFloat(cpl_table* const table, const char* const col_name,
                            QList<QVariant>& single_table,
                            const int rows) const;
  void FillSingleTableFloatArr(cpl_table* const table,
                               const char* const col_name,
                               QList<QVariant>& single_table, const int rows,
                               int* const num_vals) const;
  void FillSingleTableDouble(cpl_table* const table, const char* const col_name,
                             QList<QVariant>& single_table,
                             const int rows) const;
  void FillSingleTableDoubleArr(cpl_table* const table,
                                const char* const col_name,
                                QList<QVariant>& single_table, const int rows,
                                int* const num_vals) const;
 
  void SetBinaryTableParameter(const int table_number, const int rows,
                               const int cols,
                               const QList<QVariant> single_table,
                               const QList<QVariant> single_col_names);
 
  void GetSingleTableDimensions(const cpl_table* const table,
                                const char* const col_name, const int rows,
                                int* const table_rows, int* const table_cols,
                                int* const dim_x) const;
 
  // Statistic handling
  void AdjustMagnificationWidgets(const double x, const double y);
 
  // Get coordinates of visible rectangle
  // The returned coordinates represent the lower left and upper right corners
  // of the visible rectangle, converted into image coordinates
  // coords[0] = lower left x coordinate
  // coords[1] = lower left y coordinate
  // coords[2] = upper right x coordinate
  // coords[3] = upper right y coordinate
  void GetVisibleRectCoordinates(QVector<double>& coords) const;
 
 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 SetInitialDialogParametersMagnificationDialog(DdtDialog* dialog,
                                                     const QString dialog_id);
  void SetInitialDialogParametersFITSHeaderDialog(DdtDialog* dialog,
                                                  const QString dialog_id);
 
  void SetInitialDialogParametersMetadataSampleDialog(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 SetInitialDialogParametersGraphicsControl(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 SetInitialDialogParametersDistanceDialog(DdtDialog* dialog,
                                                const QString dialog_id);
 
  void SetInitialDialogParametersBinaryTableDialog(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 DialogParameterChangedMagnification(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 DialogParameterChangedGraphicsControl(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);
 
  void DialogParameterChangedDistance(const QString parameter_id,
                                      const QVariant parameter);
 
 public slots:
  // Public slots
  //
 
  void ChangeContrast(ddt::colorMap_t const& colourmap,
                      ddt::colorMap_t const& colourmap_inverted,
                      ddt::colorMapARGB_t const& colourmap_argb,
                      ddt::colorMapARGB_t const& colourmap_argb_inverted);
 
  void RestoreColourmap();
 
  // 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);
 
  bool AttachDataFile(QString filename, const bool open_single = false);
 
  void AttachImageExtensionsAsOne(QString filename);
 
  void LastBrokerConnection(const QString data_stream_id);
 
  void CheckInvalidImageHDUs() const;
 
  void SetImageScale(const QString image_scale);
 
  void SetNoWaitNewData(const bool no_wait_flag);
 
  QString LoadOverlayFile(const QString startup_overlay_file,
                          const bool remote = false);
 
  // 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 next_scale);
 
  void ScaleFactorForNewImage();
 
  QString FindAutoScale();
 
  void IncrementLayer(const int inc);
 
  void DecrementLayer(const int dec);
 
  void JumpToLayer(const int num);
 
  // 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);
 
  // Distance Dialog
  void CalculateDistanceLine(QPointF p1, QPointF p2);
 
  // Magnification Widget interface
  //
  void SetMagnificationFactor(const QString magnification_factor);
 
  // Cursor Information Widget interface
  //
 
  void CursorPosition(double x, double y, bool mouse_clicked);
 
  // Cut Values Widget interface
  //
 
  void SetCutValues(const double low, const 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);
  void ScrollBarRangeChanged(int min, int max);
 
  // Context menu related
  void DisplayContextMenu(const QPoint& pos);
  void ExecuteContextMenuCommand(const QString command);
 
 signals:
 
  // Signals
  //
 
  // Dialogs
  //
 
  void SetChangedDialogParameter(QString param_id, QVariant parameter);
 
  void GraphicalElementsDialogClosed();
 
  // Panning Widget interface
  //
 
  void UpdatedImage(const QImage* const image, const QTransform& transform,
                    const double rotation);
 
  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);
 
  void Swap();
 
  // Magnification Widget interface
  //
 
  void MagnifiedImage(QImage magnified_image);
  void ClearMagnifiedImage();
 
  // Cube Navigation Widget Interface
  //
  void CurrentLayer(const int current_layer, const int total_layers);
 
  // Cut Values Widget interface
  //
 
  void CurrentCutValues(double cutvalue_min, double cutvalue_max);
 
  // Colourmap Widget interface
  //
 
  void SetCurrentColourmap(QVector<QRgb> colourtable);
 
  void UpdateColourbarAxis(double min_value, double max_value,
                           int scaling_function);
 
  void InvertColourmap(bool inverted);
 
  // Data Stream Widget
  //
 
  void CurrentConnectStatus(QString data_stream_id, ConnectionStatus status);
 
  // Image Widget interface - internal slots
  //
 
  void ContextMenuCommandSelected(QString menu_entry);
 
  void Reset();
 
  void DefaultDockWidgetsLayout();
 
  // 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