def _populate_select_curve_combo_box(self): """ Add curves on selected axes to the 'select curves' combo box. Return False if there are no lines on the axes (this can occur when a user uses the "Remove Curve" button), else return True. """ with block_signals(self.view.select_curve_combo_box): self.view.select_curve_combo_box.clear() selected_ax = self.get_selected_ax() if not selected_ax: self.view.close() return False active_lines = FigureErrorsManager.get_curves_from_ax(selected_ax) for line in active_lines: self._update_selected_curve_name(line) self.view.populate_select_curve_combo_box( sorted(self.curve_names_dict.keys(), key=lambda s: s.lower())) return True
class FigureInteraction(object): """ Defines the behaviour of interaction events on a figure canvas. Note that this currently only works with Qt canvas types. """ ERROR_BARS_MENU_TEXT = "Error Bars" SHOW_ERROR_BARS_BUTTON_TEXT = "Show all errors" HIDE_ERROR_BARS_BUTTON_TEXT = "Hide all errors" def __init__(self, fig_manager): """ Registers handlers for events of interest :param fig_manager: A reference to the figure manager containing the canvas that receives the events """ # Check it looks like a FigureCanvasQT if not hasattr(fig_manager.canvas, "buttond"): raise RuntimeError("Figure canvas does not look like a Qt canvas.") canvas = fig_manager.canvas self._cids = [] self._cids.append( canvas.mpl_connect('button_press_event', self.on_mouse_button_press)) self._cids.append( canvas.mpl_connect('button_release_event', self.on_mouse_button_release)) self._cids.append(canvas.mpl_connect('draw_event', self.draw_callback)) self._cids.append( canvas.mpl_connect('motion_notify_event', self.motion_event)) self._cids.append( canvas.mpl_connect('resize_event', self.mpl_redraw_annotations)) self._cids.append( canvas.mpl_connect('figure_leave_event', self.on_leave)) self._cids.append(canvas.mpl_connect('axis_leave_event', self.on_leave)) self._cids.append(canvas.mpl_connect('scroll_event', self.on_scroll)) self.canvas = canvas self.toolbar_manager = ToolbarStateManager(self.canvas.toolbar) self.toolbar_manager.home_button_connect(self.redraw_annotations) self.fit_browser = fig_manager.fit_browser self.errors_manager = FigureErrorsManager(self.canvas) self.markers = [] self.valid_lines = VALID_LINE_STYLE self.valid_colors = VALID_COLORS self.default_marker_name = 'marker' @property def nevents(self): return len(self._cids) def disconnect(self): """ Disconnects all registered event handlers """ for cid in self._cids: self.canvas.mpl_disconnect(cid) # ------------------------ Handlers -------------------- def on_scroll(self, event): """Respond to scroll events: zoom in/out""" self.canvas.toolbar.push_current() if not getattr(event, 'inaxes', None) or isinstance(event.inaxes, Axes3D) or \ len(event.inaxes.images) == 0 and len(event.inaxes.lines) == 0: return zoom_factor = 1.05 + abs(event.step) / 6 if event.button == 'up': # zoom in zoom(event.inaxes, event.xdata, event.ydata, factor=zoom_factor) elif event.button == 'down': # zoom out zoom(event.inaxes, event.xdata, event.ydata, factor=1 / zoom_factor) event.canvas.draw() def on_mouse_button_press(self, event): """Respond to a MouseEvent where a button was pressed""" # local variables to avoid constant self lookup canvas = self.canvas x_pos = event.xdata y_pos = event.ydata self._set_hover_cursor(x_pos, y_pos) if x_pos is not None and y_pos is not None: marker_selected = [ marker for marker in self.markers if marker.is_above(x_pos, y_pos) ] else: marker_selected = [] # If left button clicked, start moving peaks if self.toolbar_manager.is_tool_active(): for marker in self.markers: marker.remove_all_annotations() elif event.button == 1 and marker_selected is not None: for marker in marker_selected: if len(marker_selected) > 1: marker.set_move_cursor(Qt.ClosedHandCursor, x_pos, y_pos) marker.mouse_move_start(x_pos, y_pos) if (event.button == canvas.buttond.get(Qt.RightButton) and not self.toolbar_manager.is_tool_active()): if not marker_selected: self._show_context_menu(event) else: self._show_markers_menu(marker_selected, event) elif event.dblclick and event.button == canvas.buttond.get( Qt.LeftButton): if not marker_selected: self._show_axis_editor(event) elif len(marker_selected) == 1: self._edit_marker(marker_selected[0]) elif event.button == canvas.buttond.get(Qt.MiddleButton): if self.toolbar_manager.is_zoom_active(): self.toolbar_manager.emit_sig_home_clicked() # Activate pan on middle button press elif not self.toolbar_manager.is_tool_active(): if event.inaxes and event.inaxes.can_pan(): event.button = 1 try: self.canvas.toolbar.press_pan(event) finally: event.button = 3 elif isinstance(event.inaxes, Axes3D): event.inaxes._button_press(event) def on_mouse_button_release(self, event): """ Stop moving the markers when the mouse button is released """ # Release pan on middle button release if event.button == self.canvas.buttond.get(Qt.MiddleButton): if not self.toolbar_manager.is_tool_active(): event.button = 1 try: self.canvas.toolbar.release_pan(event) finally: event.button = 3 elif event.button == self.canvas.buttond.get( Qt.RightButton) and self.toolbar_manager.is_zoom_active(): # Reset the axes limits if you right click while using the zoom tool. self.toolbar_manager.emit_sig_home_clicked() if self.toolbar_manager.is_tool_active(): for marker in self.markers: marker.add_all_annotations() else: x_pos = event.xdata y_pos = event.ydata self._set_hover_cursor(x_pos, y_pos) self.stop_markers(x_pos, y_pos) def on_leave(self, event): """ When leaving the axis or canvas, restore cursor to default one and stop moving the markers """ QApplication.restoreOverrideCursor() if event: self.stop_markers(event.xdata, event.ydata) def set_all_markers_visible(self, visible): for marker in self.markers: marker.set_visible(visible) def stop_markers(self, x_pos, y_pos): """ Stop all markers that are moving and draw the annotations """ if x_pos is None or y_pos is None: return for marker in self.markers: if marker.is_marker_moving(): marker.set_move_cursor(None, x_pos, y_pos) marker.add_all_annotations() marker.mouse_move_stop() def _show_axis_editor(self, event): # We assume this is used for editing axis information e.g. labels # which are outside of the axes so event.inaxes is no use. canvas = self.canvas figure = canvas.figure axes = figure.get_axes() def move_and_show(editor): editor.move(QCursor.pos()) editor.exec_() for ax in axes: if ax.title.contains(event)[0]: move_and_show(LabelEditor(canvas, ax.title)) elif ax.xaxis.label.contains(event)[0]: move_and_show(LabelEditor(canvas, ax.xaxis.label)) elif ax.yaxis.label.contains(event)[0]: move_and_show(LabelEditor(canvas, ax.yaxis.label)) elif (ax.xaxis.contains(event)[0] or any( tick.contains(event)[0] for tick in ax.get_xticklabels())): move_and_show(XAxisEditor(canvas, ax)) elif (ax.yaxis.contains(event)[0] or any( tick.contains(event)[0] for tick in ax.get_yticklabels())): if type(ax) == Axes: move_and_show(ColorbarAxisEditor(canvas, ax)) else: move_and_show(YAxisEditor(canvas, ax)) elif hasattr(ax, 'zaxis'): if ax.zaxis.label.contains(event)[0]: move_and_show(LabelEditor(canvas, ax.zaxis.label)) elif (ax.zaxis.contains(event)[0] or any( tick.contains(event)[0] for tick in ax.get_zticklabels())): move_and_show(ZAxisEditor(canvas, ax)) def _show_markers_menu(self, markers, event): """ This is opened when right-clicking on top of a marker. The menu will have an entry for each marker near the cursor at the time of clicking. The menu will allow deletion and single marker editing :param markers: list of markers close to the cursor at the time of clicking :param event: The MouseEvent that generated this call """ if not event.inaxes: return QApplication.restoreOverrideCursor() fig_type = figure_type(self.canvas.figure) if fig_type == FigureType.Empty or fig_type == FigureType.Image: return menu = QMenu() for marker in markers: self._single_marker_menu(menu, marker) menu.exec_(QCursor.pos()) def _single_marker_menu(self, menu, marker): """ Entry in a menu that allows editing/deleting a single marker :param menu: instance of QMenu to add this submenu to :param marker: marker to be edited with the menu """ marker_menu = QMenu(marker.name, menu) marker_action_group = QActionGroup(marker_menu) delete = marker_menu.addAction("Delete", lambda: self._delete_marker(marker)) edit = marker_menu.addAction("Edit", lambda: self._edit_marker(marker)) for action in [delete, edit]: marker_action_group.addAction(action) menu.addMenu(marker_menu) def _show_context_menu(self, event): """Display a relevant context menu on the canvas :param event: The MouseEvent that generated this call """ if not event.inaxes: # the current context menus are ony relevant for axes return fig_type = figure_type(self.canvas.figure) if fig_type == FigureType.Empty: # Fitting or changing scale types does not make sense in this case return menu = QMenu() if fig_type == FigureType.Image or fig_type == FigureType.Contour: if isinstance(event.inaxes, MantidAxes): self._add_axes_scale_menu(menu, event.inaxes) self._add_normalization_option_menu(menu, event.inaxes) self._add_colorbar_axes_scale_menu(menu, event.inaxes) elif fig_type == FigureType.Surface: self._add_colorbar_axes_scale_menu(menu, event.inaxes) elif fig_type != FigureType.Wireframe: if self.fit_browser.tool is not None: self.fit_browser.add_to_menu(menu) menu.addSeparator() self._add_axes_scale_menu(menu, event.inaxes) if isinstance(event.inaxes, MantidAxes): self._add_normalization_option_menu(menu, event.inaxes) self.add_error_bars_menu(menu, event.inaxes) self._add_marker_option_menu(menu, event) self._add_plot_type_option_menu(menu, event.inaxes) menu.exec_(QCursor.pos()) def _add_axes_scale_menu(self, menu, ax): """Add the Axes scale options menu to the given menu""" axes_menu = QMenu("Axes", menu) axes_actions = QActionGroup(axes_menu) current_scale_types = (ax.get_xscale(), ax.get_yscale()) for label, scale_types in AXES_SCALE_MENU_OPTS.items(): action = axes_menu.addAction( label, partial(self._quick_change_axes, scale_types, ax)) if current_scale_types == scale_types: action.setCheckable(True) action.setChecked(True) axes_actions.addAction(action) menu.addMenu(axes_menu) def _add_normalization_option_menu(self, menu, ax): # Check if toggling normalization makes sense can_toggle_normalization = self._can_toggle_normalization(ax) if not can_toggle_normalization: return None # Create menu norm_menu = QMenu("Normalization", menu) norm_actions_group = QActionGroup(norm_menu) none_action = norm_menu.addAction( 'None', lambda: self._set_normalization_none(ax)) norm_action = norm_menu.addAction( 'Bin Width', lambda: self._set_normalization_bin_width(ax)) for action in [none_action, norm_action]: norm_actions_group.addAction(action) action.setCheckable(True) # Update menu state is_normalized = self._is_normalized(ax) if is_normalized: norm_action.setChecked(True) else: none_action.setChecked(True) menu.addMenu(norm_menu) def _add_colorbar_axes_scale_menu(self, menu, ax): """Add the Axes scale options menu to the given menu""" axes_menu = QMenu("Color bar", menu) axes_actions = QActionGroup(axes_menu) images = ax.get_images() + [ col for col in ax.collections if isinstance(col, Collection) ] for label, scale_type in COLORBAR_SCALE_MENU_OPTS.items(): action = axes_menu.addAction( label, partial(self._change_colorbar_axes, scale_type)) if type(images[0].norm) == scale_type: action.setCheckable(True) action.setChecked(True) axes_actions.addAction(action) menu.addMenu(axes_menu) def add_error_bars_menu(self, menu, ax): """ Add menu actions to toggle the errors for all lines in the plot. Lines without errors are added in the context menu first, then lines containing errors are appended afterwards. This is done so that the context menu always has the same order of curves as the legend is currently showing - and the legend always appends curves with errors after the lines without errors. Relevant source, as of 10 July 2019: https://github.com/matplotlib/matplotlib/blob/154922992722db37a9d9c8680682ccc4acf37f8c/lib/matplotlib/legend.py#L1201 :param menu: The menu to which the actions will be added :type menu: QMenu :param ax: The Axes containing lines to toggle errors on """ # if the ax is not a MantidAxes, and there are no errors plotted, # then do not add any options for the menu if not isinstance(ax, MantidAxes) and len(ax.containers) == 0: return error_bars_menu = QMenu(self.ERROR_BARS_MENU_TEXT, menu) error_bars_menu.addAction( self.SHOW_ERROR_BARS_BUTTON_TEXT, partial(self.errors_manager.update_plot_after, self.errors_manager.toggle_all_errors, ax, make_visible=True)) error_bars_menu.addAction( self.HIDE_ERROR_BARS_BUTTON_TEXT, partial(self.errors_manager.update_plot_after, self.errors_manager.toggle_all_errors, ax, make_visible=False)) menu.addMenu(error_bars_menu) self.errors_manager.active_lines = self.errors_manager.get_curves_from_ax( ax) # if there's more than one line plotted, then # add a sub menu, containing an action to hide the # error bar for each line error_bars_menu.addSeparator() add_later = [] for index, line in enumerate(self.errors_manager.active_lines): if curve_has_errors(line): curve_props = CurveProperties.from_curve(line) # Add lines without errors first, lines with errors are appended later. Read docstring for more info if not isinstance(line, ErrorbarContainer): action = error_bars_menu.addAction( line.get_label(), partial(self.errors_manager.update_plot_after, self.errors_manager.toggle_error_bars_for, ax, line)) action.setCheckable(True) action.setChecked(not curve_props.hide_errors) else: add_later.append( (line.get_label(), partial(self.errors_manager.update_plot_after, self.errors_manager.toggle_error_bars_for, ax, line), not curve_props.hide_errors)) for label, function, visible in add_later: action = error_bars_menu.addAction(label, function) action.setCheckable(True) action.setChecked(visible) def _add_marker_option_menu(self, menu, event): """ Entry in main context menu to: - add horizontal/vertical markers - open a marker editor window. The editor window allows editing of all currently plotted markers :param menu: instance of QMenu to append this submenu to :param event: mpl event that generated the call """ marker_menu = QMenu("Markers", menu) marker_action_group = QActionGroup(marker_menu) x0, x1 = event.inaxes.get_xlim() y0, y1 = event.inaxes.get_ylim() horizontal = marker_menu.addAction( "Horizontal", lambda: self._add_horizontal_marker( event.ydata, y0, y1, event.inaxes)) vertical = marker_menu.addAction( "Vertical", lambda: self._add_vertical_marker( event.xdata, x0, x1, event.inaxes)) edit = marker_menu.addAction("Edit", lambda: self._global_edit_markers()) for action in [horizontal, vertical, edit]: marker_action_group.addAction(action) menu.addMenu(marker_menu) def _add_plot_type_option_menu(self, menu, ax): # Error bar caps are considered lines so they are removed before checking the number of lines on the axes so # they aren't confused for "actual" lines. error_bar_caps = datafunctions.remove_and_return_errorbar_cap_lines(ax) # Able to change the plot type to waterfall if there is only one axes, it is a MantidAxes, and there is more # than one line on the axes. if len(ax.get_figure().get_axes()) > 1 or not isinstance( ax, MantidAxes) or len(ax.get_lines()) <= 1: return # Re-add error bar caps ax.lines += error_bar_caps plot_type_menu = QMenu("Plot Type", menu) plot_type_action_group = QActionGroup(plot_type_menu) standard = plot_type_menu.addAction( "1D", lambda: self._change_plot_type( ax, plot_type_action_group.checkedAction())) waterfall = plot_type_menu.addAction( "Waterfall", lambda: self._change_plot_type( ax, plot_type_action_group.checkedAction())) for action in [waterfall, standard]: plot_type_action_group.addAction(action) action.setCheckable(True) if ax.is_waterfall(): waterfall.setChecked(True) else: standard.setChecked(True) menu.addMenu(plot_type_menu) def _change_plot_type(self, ax, action): if action.text() == "Waterfall": ax.set_waterfall(True) else: ax.set_waterfall(False) def _global_edit_markers(self): """Open a window that allows editing of all currently plotted markers""" def move_and_show(editor): editor.move(QCursor.pos()) editor.exec_() move_and_show( GlobalMarkerEditor(self.canvas, self.markers, self.valid_lines, self.valid_colors)) def _get_free_marker_name(self): """ Generate a unique name for a new marker. The name will have the form: "marker n" Where n is the lowest positive integer that makes the name unique. E.g. suppose there are markers: "marker 0", "marker 2", "marker 3" the function will return "marker 1" """ used_numbers = [] for marker in self.markers: try: word1, word2 = marker.name.split(' ') if word1 == self.default_marker_name: used_numbers.append(int(word2)) except ValueError: continue proposed_number = 0 while True: if proposed_number not in used_numbers: return "{} {}".format(self.default_marker_name, proposed_number) proposed_number += 1 def _add_horizontal_marker(self, y_pos, lower, upper, axis, name=None, line_style='dashed', color=VALID_COLORS['green']): """ Add a horizontal marker to the plot and append it to the list of open markers :param y_pos: position to plot the marker to :param lower: x value to start the marker at :param upper: x value to stop the marker at :param name: label displayed beside the marker :param line_style: 'solid', 'dashed', etc. :param color: 'r', 'g', 'b' etc. or some hex code """ if name is None: name = self._get_free_marker_name() marker = SingleMarker(self.canvas, color, y_pos, lower, upper, name=name, marker_type='YSingle', line_style=line_style, axis=axis) marker.add_name() marker.redraw() self.markers.append(marker) def _add_vertical_marker(self, x_pos, lower, upper, axis, name=None, line_style='dashed', color=VALID_COLORS['green']): """ Add a vertical marker to the plot and append it to the list of open markers :param x_pos: position to plot the marker to :param lower: y value to start the marker at :param upper: y value to stop the marker at :param name: label displayed beside the marker :param line_style: 'solid', 'dashed', etc. :param color: 'r', 'g', 'b' etc. or some hex code """ if name is None: name = self._get_free_marker_name() marker = SingleMarker(self.canvas, color, x_pos, lower, upper, name=name, marker_type='XSingle', line_style=line_style, axis=axis) marker.add_name() marker.redraw() self.markers.append(marker) def _delete_marker(self, marker): """ If marker currently plotted, remove its label and delete the marker. """ if marker in self.markers: marker.remove_all_annotations() marker.marker.remove() self.markers.remove(marker) self.canvas.draw() def _edit_marker(self, marker): """ Open a dialog window to edit the marker properties (position, name, line style, colour) """ def move_and_show(editor): editor.move(QCursor.pos()) editor.exec_() used_names = [str(_marker.name) for _marker in self.markers] QApplication.restoreOverrideCursor() move_and_show( SingleMarkerEditor(self.canvas, marker, self.valid_lines, self.valid_colors, used_names)) def _set_hover_cursor(self, x_pos, y_pos): """ If the cursor is above a single marker make it into a pointing hand. If the cursor is above multiple markers (eg. an intersection) make it into a cross. Otherwise set it to the default one. :param x_pos: cursor x position :param y_pos: cursor y position """ if x_pos is None or y_pos is None: QApplication.restoreOverrideCursor() return is_moving = any([marker.is_marker_moving() for marker in self.markers]) hovering_over = sum( [1 for marker in self.markers if marker.is_above(x_pos, y_pos)]) if not is_moving: if hovering_over == 1: QApplication.setOverrideCursor(Qt.PointingHandCursor) elif hovering_over > 1: QApplication.setOverrideCursor(Qt.CrossCursor) else: QApplication.restoreOverrideCursor() def draw_callback(self, _): """ This is called at every canvas draw. Redraw the markers. """ for marker in self.markers: marker.redraw() def motion_event(self, event): """ Move the marker if the mouse is moving and in range """ if self.toolbar_manager.is_tool_active() or self.toolbar_manager.is_fit_active() \ or event is None: return x = event.xdata y = event.ydata self._set_hover_cursor(x, y) should_move = any([marker.mouse_move(x, y) for marker in self.markers]) if should_move: self.canvas.draw() def redraw_annotations(self): """Remove all annotations and add them again.""" for marker in self.markers: marker.remove_all_annotations() marker.add_all_annotations() def mpl_redraw_annotations(self, event): """Redraws all annotations when a mouse button was clicked""" if hasattr(event, 'button') and event.button is not None: self.redraw_annotations() def _is_normalized(self, ax): artists = [art for art in ax.tracked_workspaces.values()] return all(art[0].is_normalized for art in artists) def _set_normalization_bin_width(self, ax): if self._is_normalized(ax): return self._toggle_normalization(ax) def _set_normalization_none(self, ax): if not self._is_normalized(ax): return self._toggle_normalization(ax) def _toggle_normalization(self, selected_ax): if figure_type(self.canvas.figure) == FigureType.Image and len( self.canvas.figure.get_axes()) > 1: axes = datafunctions.get_axes_from_figure(self.canvas.figure) else: axes = [selected_ax] for ax in axes: waterfall = isinstance(ax, MantidAxes) and ax.is_waterfall() if waterfall: x, y = ax.waterfall_x_offset, ax.waterfall_y_offset has_fill = ax.waterfall_has_fill() if has_fill: line_colour_fill = datafunctions.waterfall_fill_is_line_colour( ax) if line_colour_fill: fill_colour = None else: fill_colour = datafunctions.get_waterfall_fills( ax)[0].get_facecolor() ax.update_waterfall(0, 0) # The colorbar can get screwed up with ragged workspaces and log scales as they go # through the normalisation toggle. # Set it to Linear and change it back after if necessary, since there's no reason # to duplicate the handling. colorbar_log = False if ax.images: colorbar_log = isinstance(ax.images[-1].norm, LogNorm) if colorbar_log: self._change_colorbar_axes(Normalize) self._change_plot_normalization(ax) if ax.lines: # Relim causes issues with colour plots, which have no lines. ax.relim() if ax.images: # Colour bar limits are wrong if workspace is ragged. Set them manually. colorbar_min = np.nanmin(ax.images[-1].get_array()) colorbar_max = np.nanmax(ax.images[-1].get_array()) for image in ax.images: image.set_clim(colorbar_min, colorbar_max) # Update the colorbar label cb = image.colorbar if cb: datafunctions.add_colorbar_label( cb, ax.get_figure().axes) if colorbar_log: # If it had a log scaled colorbar before, put it back. self._change_colorbar_axes(LogNorm) ax.autoscale() datafunctions.set_initial_dimensions(ax) if waterfall: ax.update_waterfall(x, y) if has_fill: ax.set_waterfall_fill(True, fill_colour) self.canvas.draw() def _change_plot_normalization(self, ax): is_normalized = self._is_normalized(ax) for arg_set in ax.creation_args: if arg_set['function'] == 'contour': continue if arg_set['workspaces'] in ax.tracked_workspaces: workspace = ads.retrieve(arg_set['workspaces']) arg_set['distribution'] = is_normalized arg_set_copy = copy(arg_set) [ arg_set_copy.pop(key) for key in ['function', 'workspaces', 'autoscale_on_update', 'norm'] if key in arg_set_copy.keys() ] if 'specNum' not in arg_set: if 'wkspIndex' in arg_set: arg_set['specNum'] = workspace.getSpectrum( arg_set.pop('wkspIndex')).getSpectrumNo() else: raise RuntimeError( "No spectrum number associated with plot of " "workspace '{}'".format(workspace.name())) # 2D plots have no spec number so remove it if figure_type(self.canvas.figure) in [ FigureType.Image, FigureType.Contour ]: arg_set_copy.pop('specNum') for ws_artist in ax.tracked_workspaces[workspace.name()]: if ws_artist.spec_num == arg_set_copy.get('specNum'): ws_artist.is_normalized = not is_normalized # This check is to prevent the contour lines being re-plotted using the colorfill plot args. if isinstance(ws_artist._artists[0], QuadContourSet): contour_line_colour = ws_artist._artists[ 0].collections[0].get_color() ws_artist.replace_data(workspace, None) # Re-apply the contour line colour for col in ws_artist._artists[0].collections: col.set_color(contour_line_colour) else: ws_artist.replace_data(workspace, arg_set_copy) def _can_toggle_normalization(self, ax): """ Return True if no plotted workspaces are distributions, all curves on the figure are either distributions or non-distributions, and the data_replace_cb method was set when plotting . Return False otherwise. :param ax: A MantidAxes object :return: bool """ plotted_normalized = [] if not ax.creation_args: return False axis = ax.creation_args[0].get('axis', None) for workspace_name, artists in ax.tracked_workspaces.items(): if hasattr(ads.retrieve(workspace_name), "isDistribution"): is_dist = ads.retrieve(workspace_name).isDistribution() else: is_dist = True if axis != MantidAxType.BIN and not is_dist and ax.data_replaced: plotted_normalized += [a.is_normalized for a in artists] else: return False if all(plotted_normalized) or not any(plotted_normalized): return True return False def _quick_change_axes(self, scale_types, ax): """ Perform a change of axes on the figure to that given by the option :param scale_types: A 2-tuple of strings giving matplotlib axes scale types """ # Recompute the limits of the data. If the scale is set to log # on either axis, Fit enabled & then disabled, then the axes are # not rescaled properly because the vertical marker artists were # included in the last computation of the data limits and # set_xscale/set_yscale only autoscale the view xlim = copy(ax.get_xlim()) ylim = copy(ax.get_ylim()) ax.set_xscale(scale_types[0]) ax.set_yscale(scale_types[1]) ax.set_xlim(xlim) ax.set_ylim(ylim) self.canvas.draw_idle() def _change_colorbar_axes(self, scale_type): for ax in self.canvas.figure.get_axes(): images = ax.get_images() + [ col for col in ax.collections if isinstance(col, Collection) ] for image in images: if image.norm.vmin is not None and image.norm.vmax is not None: datafunctions.update_colorbar_scale( self.canvas.figure, image, scale_type, image.norm.vmin, image.norm.vmax) self.canvas.draw_idle()