Add partial functionality to visualisation features in plotting tab (#39612)

This PR contains changes that activate functionality of several buttons
in Plotting tab of Single Crystal Elastic mode of the DNS Reduction
interface. In particular, the following buttons are now functional:
1) "Grid selector", 
2) "Grid style selector", 
3) "Font size selector", 
4) "Reverse color map".

This PR includes a second part of adding advanced plotting capabilities
for the Single Cristal Elastic mode of DNS Reduction GUI. Complete
integration of the Single Cristal Elastic mode into the DNS Reduction
GUI will be implemented in several steps (in order to ensure reasonable
PR sizes and reduce the workload for the reviewers).

Fixes part 6b of #36407

Author: koshchii

docs/source/interfaces/direct/dns_reduction/dns_single_crystal_elastic_plotting_tab.rst

@@ -32,9 +32,8 @@ The buttons below the **Plotting** tab have the following functionality (from le
 +------------------------------------------------+----------------------------------------------------------------------------+
 | |exp-grid| Grid selector                       | Toggle through different grid sizes.                                       |
 +------------------------------------------------+----------------------------------------------------------------------------+
-| |exp-crystal-axes| Grid style selector         | Switch between a) orthogonal axes defined by :math:`n_x` and :math:`n_y`,  |
-|                                                | or b) crystalographic principal axes lying in the horizontal scattering    |
-|                                                | plane. The latter works only if two principle axes change in the           |
+| |exp-crystal-axes| Grid style selector         | Enable/disable crystalographic principal axes laying in the horizontal     |
+|                                                | scattering plane. It works only if two principle axes change in the        |
 |                                                | horizontal plane.                                                          |
 +------------------------------------------------+----------------------------------------------------------------------------+
 | |exp-projections| Projection selector          | Turn on/off projections of the intensity function averaged along           |

qt/python/mantidqtinterfaces/mantidqtinterfaces/dns_powder_tof/helpers/helpers_for_testing.py

@@ -4,8 +4,10 @@
 #     NScD Oak Ridge National Laboratory, European Spallation Source
 #     & Institut Laue - Langevin
 # SPDX - License - Identifier: GPL - 3.0 +
-from mantid.simpleapi import BinMD, FakeMDEventData, CreateMDWorkspace
 
+import numpy as np
+
+from mantid.simpleapi import BinMD, FakeMDEventData, CreateMDWorkspace
 from mantidqtinterfaces.dns_powder_tof.data_structures.object_dict import ObjectDict
 
 dataset_dic = [
@@ -229,8 +231,7 @@ def get_fake_tof_options():
     return tof_opt
 
 
-# OKcomment: not used anywhere
-def get_fake_elastic_sc_options():
+def get_fake_elastic_single_crystal_options():
     el_opt = {
         "a": 2,
         "b": 3,
@@ -294,6 +295,15 @@ def get_elastic_standard_data_dic():
     }
 
 
+def get_fake_elastic_single_crystal_dataset():
+    return {
+        "two_theta_array": [0, 1, 2],
+        "omega_array": [4, 5],
+        "intensity": np.transpose(np.asarray([[8.0, 9.0, 10.0], [11.0, 12.0, 13.0]])),
+        "error": np.transpose(np.asarray([[14.0, 15.0, 16.0], [17.0, 18.0, 19.0]])),
+    }
+
+
 def get_fake_MD_workspace_unique(name="test", factor=1):
     ws = CreateMDWorkspace(
         Dimensions="3",

qt/python/mantidqtinterfaces/mantidqtinterfaces/dns_single_crystal_elastic/data_structures/dns_single_crystal_map.py

@@ -13,16 +13,17 @@
 from matplotlib import path
 from matplotlib import tri
 from mantidqtinterfaces.dns_powder_tof.data_structures.object_dict import ObjectDict
-from mantidqtinterfaces.dns_single_crystal_elastic.plot.elastic_single_crystal_helpers import angle_to_q
+from mantidqtinterfaces.dns_single_crystal_elastic.plot.elastic_single_crystal_helpers import angle_to_q, get_hkl_float_array
 
 
-def _get_mesh(omega, two_theta, z_mesh):
+def _get_mesh(omega, two_theta, z_mesh, z_error_mesh):
     omega_mesh_no_nan, two_theta_mesh_no_nan = np.meshgrid(omega, two_theta)
     not_nan_pos = ~np.isnan(z_mesh)
     omega_mesh_no_nan = omega_mesh_no_nan[not_nan_pos]
     two_theta_mesh_no_nan = two_theta_mesh_no_nan[not_nan_pos]
     z_mesh_no_nan = z_mesh[not_nan_pos]
-    return omega_mesh_no_nan, two_theta_mesh_no_nan, z_mesh_no_nan
+    z_error_mesh_no_nan = z_error_mesh[not_nan_pos]
+    return omega_mesh_no_nan, two_theta_mesh_no_nan, z_mesh_no_nan, z_error_mesh_no_nan
 
 
 def _correct_omega_offset(omega, omega_offset):
@@ -55,7 +56,7 @@ def __init__(self, parameter, two_theta=None, omega=None, z_mesh=None, error_mes
         super().__init__()
         # non interpolated data:
         omega_corrected = _correct_omega_offset(omega, parameter["omega_offset"])
-        omega_mesh, two_theta_mesh, z_mesh = _get_mesh(omega_corrected, two_theta, z_mesh)
+        omega_mesh, two_theta_mesh, z_mesh, z_error_mesh = _get_mesh(omega_corrected, two_theta, z_mesh, error_mesh)
         omega_unique, two_theta_unique = _get_unique(omega_mesh, two_theta_mesh)
         qx_mesh, qy_mesh = _get_q_mesh(omega_mesh, two_theta_mesh, parameter["wavelength"])
         hklx_mesh, hkly_mesh = _get_hkl_mesh(qx_mesh, qy_mesh, parameter["dx"], parameter["dy"])
@@ -67,7 +68,7 @@ def __init__(self, parameter, two_theta=None, omega=None, z_mesh=None, error_mes
         self.hklx_mesh = hklx_mesh
         self.hkly_mesh = hkly_mesh
         self.z_mesh = z_mesh
-        self.error_mesh = error_mesh
+        self.error_mesh = z_error_mesh
         self.dx = parameter["dx"]
         self.dy = parameter["dy"]
         self.hkl1 = parameter["hkl1"]
@@ -115,3 +116,30 @@ def mask_triangles(self, mesh_name):
         maxi = dns_path.contains_points(x_y_triangles)
         self.triangulation.set_mask(np.invert(maxi))
         return self.triangulation
+
+    def get_changing_indexes(self):
+        """
+        Keeps track of the coordinates after transformation to the horizontal
+        scattering plane and returns the list of relevant indices of (x,y)
+        crystallographic coordinates.
+        """
+        hkl1 = get_hkl_float_array(self.hkl1)
+        hkl2 = get_hkl_float_array(self.hkl2)
+        hkl = np.add(np.outer(self.hklx_mesh.flatten()[0:10], hkl1), np.outer(self.hkly_mesh.flatten()[0:10], hkl2))
+        projection_dims = [len(np.unique(hkl[:, 0])), len(np.unique(hkl[:, 1])), len(np.unique(hkl[:, 2]))]
+        basis_indexes = list(range(len(projection_dims)))
+        del basis_indexes[projection_dims.index(min(projection_dims))]
+        return basis_indexes
+
+    def get_changing_hkl_components(self):
+        index = self.get_changing_indexes()
+        hkl1 = get_hkl_float_array(self.hkl1)
+        hkl2 = get_hkl_float_array(self.hkl2)
+        # transformation to crystal axis following
+        # hkl_comp1 = a * x + b * y
+        # hkl_comp2 = c * x + d * y
+        a = hkl1[index[0]]
+        b = hkl2[index[0]]
+        c = hkl1[index[1]]
+        d = hkl2[index[1]]
+        return a, b, c, d

qt/python/mantidqtinterfaces/mantidqtinterfaces/dns_single_crystal_elastic/plot/elastic_single_crystal_helpers.py

@@ -9,7 +9,11 @@
 Helper functions for DNS single crystal elastic calculations.
 """
 
-from numpy import cos, pi, radians, sin
+from numpy import asarray, cos, pi, radians, sin
+
+
+def get_hkl_float_array(hkl_string):
+    return asarray([float(x) for x in hkl_string.split(",")])
 
 
 def angle_to_q(two_theta, omega, wavelength):  # should work with np arrays

qt/python/mantidqtinterfaces/mantidqtinterfaces/dns_single_crystal_elastic/plot/elastic_single_crystal_plot_model.py

@@ -72,6 +72,9 @@ def get_axis_labels(self, axis_type, crystal_axes, switch=False):
         labels = axis_labels[axis_type]
         return labels
 
+    def get_changing_hkl_components(self):
+        return self._single_crystal_map.get_changing_hkl_components()
+
     def get_omega_offset(self):
         return self._single_crystal_map["omega_offset"]
 

qt/python/mantidqtinterfaces/mantidqtinterfaces/dns_single_crystal_elastic/plot/elastic_single_crystal_plot_plot.py

@@ -10,6 +10,7 @@
 """
 
 import matplotlib
+from matplotlib.ticker import AutoMinorLocator, NullLocator
 from mpl_toolkits.axisartist import Subplot
 
 
@@ -44,6 +45,16 @@ def set_shading(self, shading):
         if self._plot is not None:
             self._plot.set_shading(shading)
 
+    def set_grid(self, major=False, minor=False):
+        if minor:
+            self._ax.xaxis.set_minor_locator(AutoMinorLocator(5))
+        else:
+            self._ax.xaxis.set_minor_locator(NullLocator())
+        if major:
+            self._ax.grid(True, which="both", zorder=1000, linestyle="--")
+        else:
+            self._ax.grid(0)
+
     def set_zlim(self, zlim):
         if self._plot is not None:
             self._plot.set_clim(zlim[0], zlim[1])

qt/python/mantidqtinterfaces/mantidqtinterfaces/dns_single_crystal_elastic/plot/elastic_single_crystal_plot_presenter.py

@@ -12,6 +12,7 @@
 from mantidqtinterfaces.dns_powder_tof.data_structures.dns_observer import DNSObserver
 from mantidqtinterfaces.dns_powder_tof.data_structures.object_dict import ObjectDict
 from mantidqtinterfaces.dns_single_crystal_elastic.plot import mpl_helpers
+from mantidqtinterfaces.dns_single_crystal_elastic.plot.grid_locator import get_grid_helper
 
 
 class DNSElasticSCPlotPresenter(DNSObserver):
@@ -24,6 +25,7 @@ def __init__(self, name=None, parent=None, view=None, model=None):
         self._plot_param.grid_state = 0
         self._plot_param.grid_helper = None
         self._plot_param.colormap_name = "jet"
+        self._plot_param.font_size = 1
         self._plot_param.lines = 0
 
     def _datalist_updated(self, workspaces):
@@ -39,12 +41,15 @@ def _plot(self, initial_values=None):
         if not plot_list:
             return
         self._plot_param.plot_name = plot_list[0]
+        self._change_font_size(draw=False)
         generated_dict = self.param_dict["elastic_single_crystal_script_generator"]
         data_array = generated_dict["data_arrays"][self._plot_param.plot_name]
         options = self.param_dict["elastic_single_crystal_options"]
         self.model.create_single_crystal_map(data_array, options, initial_values)
+        self._change_grid_state(draw=False, change=False)
         self.view.create_subfigure(self._plot_param.grid_helper)
         self._want_plot(axis_type["plot_type"])
+        self._set_plotting_grid(self._crystallographical_axes())
         self._set_axis_labels()
         self.view.single_crystal_plot.create_colorbar()
         self.view.single_crystal_plot.on_resize()
@@ -91,11 +96,6 @@ def _plot_triangulation(self, interpolate, axis_type, switch):
         triangulation, z = self.model.get_interpolated_triangulation(interpolate, axis_type, switch)
         self.view.single_crystal_plot.plot_triangulation(triangulation, z, color_map, edge_colors, shading)
 
-    def _set_colormap(self):
-        cmap = self._get_plot_styles()[0]
-        self.view.single_crystal_plot.set_cmap(cmap)
-        self.view.draw()
-
     def _want_plot(self, plot_type):
         axis_type = self.view.get_axis_type()
         self._plot_triangulation(axis_type["interpolate"], axis_type["type"], axis_type["switch"])
@@ -105,15 +105,76 @@ def _get_plot_styles(self):
         shading = "flat"
         edge_colors = ["face", "white", "black"][self._plot_param.lines]
         colormap_name = own_dict["colormap"]
+        if own_dict["invert_cb"]:
+            colormap_name += "_r"
         cmap = mpl_helpers.get_cmap(colormap_name)
         return cmap, edge_colors, shading
 
     def _set_axis_labels(self):
         axis_type = self.view.get_axis_type()
-        own_dict = self.view.get_state()
-        x_label, y_label = self.model.get_axis_labels(axis_type["type"], own_dict["crystal_axes"])
+        x_label, y_label = self.model.get_axis_labels(axis_type["type"], self._crystallographical_axes())
         self.view.single_crystal_plot.set_axis_labels(x_label, y_label)
 
+    def _change_crystal_axes_grid(self):
+        current_state = self._plot_param.grid_state % 4
+        if current_state == 0:
+            self._plot_param.grid_state = 1
+        else:
+            self._plot_param.grid_state = current_state
+        self._set_plotting_grid(crystallographic_axes=True)
+
+    def _change_normal_grid(self):
+        self._plot_param.grid_state = self._plot_param.grid_state % 3
+        self._set_plotting_grid(crystallographic_axes=False)
+
+    def _set_plotting_grid(self, crystallographic_axes=True):
+        if crystallographic_axes:
+            self._plot_param.grid_helper = self._create_grid_helper()
+            self.view.single_crystal_plot.set_grid(major=self._plot_param.grid_state, minor=self._plot_param.grid_state // 3)
+        else:
+            self._plot_param.grid_helper = None
+            self.view.single_crystal_plot.set_grid(major=self._plot_param.grid_state, minor=self._plot_param.grid_state // 2)
+
+    def _change_grid_state(self, draw=True, change=True):
+        if change:
+            self._plot_param.grid_state = self._plot_param.grid_state + 1
+        if self._crystallographical_axes():
+            self._change_crystal_axes_grid()
+        else:
+            self._change_normal_grid()
+        if draw:
+            self.view.draw()
+
+    def _change_crystal_axes(self):
+        if self._crystallographical_axes():
+            self._plot_param.grid_state = 1
+        else:
+            self._plot_param.grid_state = 0
+        self._plot()
+
+    def _create_grid_helper(self):
+        axis_type = self.view.get_axis_type()
+        a, b, c, d = self.model.get_changing_hkl_components()
+        return get_grid_helper(self._plot_param.grid_helper, self._plot_param.grid_state, a, b, c, d, axis_type["switch"])
+
+    def _set_colormap(self):
+        cmap = self._get_plot_styles()[0]
+        self.view.single_crystal_plot.set_cmap(cmap)
+        self.view.draw()
+
+    def _change_font_size(self, draw=True):
+        own_dict = self.view.get_state()
+        font_size = own_dict["fontsize"]
+        if self._plot_param.font_size != font_size:
+            self._plot_param.font_size = font_size
+            self.view.single_crystal_plot.set_fontsize(font_size)
+            if draw:
+                self._plot()
+
+    def _crystallographical_axes(self):
+        own_dict = self.view.get_state()
+        return own_dict["crystal_axes"]
+
     def _attach_signal_slots(self):
         self.view.sig_plot.connect(self._plot)
         self.view.sig_update_omega_offset.connect(self._update_omega_offset)
@@ -122,3 +183,6 @@ def _attach_signal_slots(self):
         self.view.sig_restore_default_dxdy.connect(self._set_default_dx_dy)
         self.view.sig_change_colormap.connect(self._set_colormap)
         self._plotted_script_number = 0
+        self.view.sig_change_grid.connect(self._change_grid_state)
+        self.view.sig_change_crystal_axes.connect(self._change_crystal_axes)
+        self.view.sig_change_font_size.connect(self._change_font_size)

qt/python/mantidqtinterfaces/mantidqtinterfaces/dns_single_crystal_elastic/plot/elastic_single_crystal_plot_view.py

@@ -89,14 +89,27 @@ def __init__(self, parent):
     sig_restore_default_dxdy = Signal()
     sig_update_omega_offset = Signal(float)
     sig_update_dxdy = Signal(float, float)
+    sig_change_grid = Signal()
+    sig_change_crystal_axes = Signal(bool)
     sig_change_colormap = Signal()
+    sig_change_font_size = Signal()
+
+    # emitting custom signals for presenter
+    def _change_font_size(self):
+        self.sig_change_font_size.emit()
 
     def _change_colormap(self):
         self.sig_change_colormap.emit()
 
+    def _change_crystal_axes(self, pressed):
+        self.sig_change_crystal_axes.emit(pressed)
+
     def _plot(self):
         self.sig_plot.emit()
 
+    def _change_grid(self):
+        self.sig_change_grid.emit()
+
     def set_plot_view_menu_visibility(self, visible):
         self.views_menu.menuAction().setVisible(visible)
 
@@ -128,4 +141,8 @@ def draw(self):
         self.canvas.draw()
 
     def _attach_signal_slots(self):
+        self._map["fontsize"].editingFinished.connect(self._change_font_size)
+        self._map["grid"].clicked.connect(self._change_grid)
         self._map["colormap"].currentIndexChanged.connect(self._change_colormap)
+        self._map["crystal_axes"].clicked.connect(self._change_crystal_axes)
+        self._map["invert_cb"].clicked.connect(self._change_colormap)