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

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

  void AttachImageFromPointer(float* new_image_data, int nx, int ny);

  void AttachImageFromPointer(double* new_image_data, int nx, int ny);

  void AttachImageFromPointer(int32_t* new_image_data, int nx, int ny);

  void AttachImageFromPointer(uint8_t* new_image_data, int nx, int ny);

  void AttachImageFromPointer(uint16_t* new_image_data, int nx, int ny);

  void AttachImageFromPointer(uint32_t* new_image_data, int nx, int ny);

  void AttachImageFromPointer(int16_t* new_image_data, int nx, int ny);

  ::cpl_image *GetCurrentlyDisplayedImagePtr();

  uintptr_t GetCurrentlyDisplayedImageAsRawPtr();
 
protected:
  // Logger
  ddt::DdtLogger* logger;

  // Graphics Library

  DdtOverlayRendering* overlay_rendering;

  DdtGraphicalElementProperties overlay_properties;
 
 private:
  // Private members
  //
 
 
  cpl_image* displayedImageCopy = nullptr;
 
  // Data Stream access
  QString current_stream_id;
  QString last_stream_id;
  boost::signals2::connection connection;
  boost::signals2::connection connection_cutlevel;
  boost::signals2::connection connection_state_subscription;
 
  // 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_square_size;
  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_vertical_moved_externally;
  bool scrollbar_horizontal_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;

  bool refresh_rate_limit_enabled;

  double refresh_rate_interval_s;

  qint64 last_display_time_ms;

  QString default_bias_image;

  bool show_scrollbars;

  int current_rotation_value;

  QString current_scale_factor;

  QString selected_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 pixel_value, QString ra, QString dec);

  void GetTabularRegion(const double x_image, const double y_image);
 
 private:
  // Private Methods
  //
  void HandleImage();
 
  void setCacheMode(DdtImageGraphicsItem* const item) const;
 
  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;
  QStringList AddDefaultDialogsNameEntries() const;
  void ExecuteDialog(const QString dialog_id);
  QMenu* ComposeDialogsContextMenu(const QString menu_title);
 
  // File access
  void BrowseForFile();
  void BrowseForFileExt();
  void SaveAsFile();
  void ResetDataDialogs();
  void ResetDialogs();
  void ResetDialogsAndGraphics();
  void ClearImage();
  void StaticOverlay();
 
  // Colourmap handling
  void UpdateColourmap();
 
  // FITS Header updates
  void UpdateFitsHeaderDialog();
 
  // Update all Monitor Samples dialog widgets values
  void UpdateMonitorSamplesDialog();
 
  // 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;

  void ResetAndCleanViewBeforeLoad();

  void HandleAndUpdateAfterLoad();
 
 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 SetInitialDialogParametersMonitorSamplesDialog(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 DialogParameterChangedMonitorSamples(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);

  void SetImageRefreshRate(bool enabled, double interval_seconds);

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

  void SetAutoScaleState(const bool new_auto_scale_state);
 
 private slots:
  // Private slots
  //
 
  // Loading rendering plugins
  void LoadRenderingPlugins();
 
  // Scrollbar handling
  void ScrollBarVerticalMoved(int pos);
  void ScrollBarHorizontalMoved(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& image, const QTransform& transform,
                    const double rotation);

  void ImageWidgetViewChanged(QRectF visible_image_rect,
                              int current_image_width,
                              int current_image_height);

  void NewBoostDataEvent();

  void ConnectionStateBoostEvent(int connection_status);

  // 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