def _overplot_waterfall(ax, no_of_lines):
"""
If overplotting onto a waterfall axes, convert lines to waterfall (add x and y offset) before overplotting.
:param ax: object of MantidAxes type to overplot onto.
:param no_of_lines: number of lines to overplot onto input axes.
"""
for i in range(no_of_lines):
errorbar_cap_lines = datafunctions.remove_and_return_errorbar_cap_lines(
ax)
datafunctions.convert_single_line_to_waterfall(
ax,
len(ax.get_lines()) - (i + 1))
if ax.waterfall_has_fill():
datafunctions.waterfall_update_fill(ax)
for cap in errorbar_cap_lines:
ax.add_line(cap)
def test_overplotting_onto_waterfall_plot_with_solid_colour_fills_adds_a_filled_area_with_the_same_colour(self):
fig, ax = plt.subplots(subplot_kw={'projection': 'mantid'})
ax.plot([0, 1], [0, 1])
ax.plot([0, 1], [0, 1])
# Make a waterfall plot.
ax.set_waterfall(True)
# Add filled areas.
ax.set_waterfall_fill(True)
# Set the fills to be the same colour.
ax.collections[0].set_facecolor([1, 0, 0, 1])
ax.collections[1].set_facecolor([1, 0, 0, 1])
# Plot another line and make it join the waterfall.
ax.plot([0, 1], [0, 1])
datafunctions.convert_single_line_to_waterfall(ax, 2)
datafunctions.waterfall_update_fill(ax)
# Check that there are now three filled areas and the new fill colour matches the others.
self.assertTrue((ax.collections[2].get_facecolor() == [1, 0, 0, 1]).all())
def test_overplotting_onto_waterfall_plot_with_line_colour_fills_adds_another_filled_area_with_new_line_colour(self):
fig, ax = plt.subplots(subplot_kw={'projection': 'mantid'})
ax.plot([0, 1], [0, 1], color="#ff9900")
ax.plot([0, 1], [0, 1], color="#00d1ff")
# Make a waterfall plot.
ax.set_waterfall(True)
# Add filled areas.
ax.set_waterfall_fill(True)
# Set the fills to be the same colour as their lines.
ax.collections[0].set_facecolor(ax.lines[0].get_color())
ax.collections[1].set_facecolor(ax.lines[0].get_color())
# Plot another line and make it join the waterfall.
ax.plot([0, 1], [0,1], color='#00fff0')
datafunctions.convert_single_line_to_waterfall(ax, 2)
datafunctions.waterfall_update_fill(ax)
# Check that there are now three filled areas and the new line colour matches the new fill colour.
self.assertEqual(convert_color_to_hex(ax.collections[2].get_facecolor()[0]), ax.lines[2].get_color())
def plot(workspaces,
spectrum_nums=None,
wksp_indices=None,
errors=False,
overplot=False,
fig=None,
plot_kwargs=None,
ax_properties=None,
window_title=None,
tiled=False,
waterfall=False,
log_name=None,
log_values=None):
"""
Create a figure with a single subplot and for each workspace/index add a
line plot to the new axes. show() is called before returning the figure instance. A legend
is added.
:param workspaces: A list of workspace handles or strings
:param spectrum_nums: A list of spectrum number identifiers (general start from 1)
:param wksp_indices: A list of workspace indexes (starts from 0)
:param errors: If true then error bars are added for each plot
:param overplot: If true then overplot over the current figure if one exists. If an axis object the overplotting
will be done on the axis passed in
:param fig: If not None then use this Figure object to plot
:param plot_kwargs: Arguments that will be passed onto the plot function
:param ax_properties: A dict of axes properties. E.g. {'yscale': 'log'}
:param window_title: A string denoting name of the GUI window which holds the graph
:param tiled: An optional flag controlling whether to do a tiled or overlayed plot
:param waterfall: An optional flag controlling whether or not to do a waterfall plot
:param log_name: The optional log being plotted against.
:param log_values: An optional list of log values to plot against.
:return: The figure containing the plots
"""
plot_font = ConfigService.getString('plots.font')
if plot_font:
if len(mpl.rcParams['font.family']) > 1:
mpl.rcParams['font.family'][0] = plot_font
else:
mpl.rcParams['font.family'].insert(0, plot_font)
if plot_kwargs is None:
plot_kwargs = {}
_validate_plot_inputs(workspaces, spectrum_nums, wksp_indices, tiled,
overplot)
workspaces = [ws for ws in workspaces if isinstance(ws, MatrixWorkspace)]
if spectrum_nums is not None:
kw, nums = 'specNum', spectrum_nums
else:
kw, nums = 'wkspIndex', wksp_indices
_add_default_plot_kwargs_from_settings(plot_kwargs, errors)
num_axes = len(workspaces) * len(nums) if tiled else 1
fig, axes = get_plot_fig(overplot, ax_properties, window_title, num_axes,
fig)
# Convert to a MantidAxes if it isn't already. Ignore legend since
# a new one will be drawn later
axes = [
MantidAxes.from_mpl_axes(ax, ignore_artists=[Legend])
if not isinstance(ax, MantidAxes) else ax for ax in axes
]
assert axes, "No axes are associated with this plot"
if tiled:
ws_index = [(ws, index) for ws in workspaces for index in nums]
for index, ax in enumerate(axes):
if index < len(ws_index):
_do_single_plot(ax, [ws_index[index][0]], errors, False,
[ws_index[index][1]], kw, plot_kwargs)
else:
ax.axis('off')
else:
show_title = ("on" == ConfigService.getString(
"plots.ShowTitle").lower()) and not overplot
ax = overplot if isinstance(overplot, MantidAxes) else axes[0]
ax.axis('on')
_do_single_plot(ax, workspaces, errors, show_title, nums, kw,
plot_kwargs, log_name, log_values)
# Can't have a waterfall plot with only one line.
if len(nums) * len(workspaces) == 1 and waterfall:
waterfall = False
# The plot's initial xlim and ylim are used to offset each curve in a waterfall plot.
# Need to do this whether the current curve is a waterfall plot or not because it may be converted later.
if not overplot:
datafunctions.set_initial_dimensions(ax)
if waterfall:
ax.set_waterfall(True)
if not overplot:
fig.canvas.set_window_title(figure_title(workspaces, fig.number))
else:
if ax.is_waterfall():
for i in range(len(nums) * len(workspaces)):
errorbar_cap_lines = datafunctions.remove_and_return_errorbar_cap_lines(
ax)
datafunctions.convert_single_line_to_waterfall(
ax,
len(ax.get_lines()) - (i + 1))
if ax.waterfall_has_fill():
datafunctions.waterfall_update_fill(ax)
ax.lines += errorbar_cap_lines
# update and show figure
return _update_show_figure(fig)
