# -*- coding: utf-8 -*-
# encoding: utf-8
"""
Plotting functions for pymzML.
The Factory object can hold several plots with several data traces each.
The data can be visualized as an interactive plotly plot or be exported as JSON.
"""
# Python mzML module - pymzml
# Copyright (C) 2010-2019 M. Kösters, C. Fufezan
# The MIT License (MIT)
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import sys
import math
import warnings
# Fail gracefully if no plotly installed
try:
import plotly as plt
# import plotly.offline as plt
import plotly.graph_objs as go
from plotly import subplots
except ImportError:
warnings.warn("Plotly is required for plotting support.", ImportWarning)
from . import spec
[docs]
class Factory(object):
[docs]
def __init__(self, filename=None):
"""
Interface to visualize m/z or profile data using plotly (https://plot.ly/).
Arguments:
filename (str): Name for the output file. Default = "spectrum_plot.html"
"""
self.filename = filename
self.plots = []
self.titles = []
self.lookup = dict()
self.y_max = []
self.y_min = []
self.x_max = []
self.x_min = []
self.offset = 1
self.MS_precisions = []
self.function_mapper = {
"-__splineOffset__0": self.__return_neg_offset_0,
"max_intensity": self.__return_max_y,
}
self.style_options = {"line.width": 1} # default value
def __return_max_y(self, i):
""" """
return self.y_max[i]
def __return_neg_offset_0(self, i):
""" """
return 0.0 - (self.y_max[i] * (self.offset * 0.05))
[docs]
def new_plot(self, MS_precision="5e-6", title=None):
"""
Add new plot to the plotting Factory.
Every plot will be put into the x * 2 grid of one single figure.
Keyword Arguments:
title (str): an optional title that will be printed above the plot
MS_precision (float): measuring MS_precision used in handler.
Default 5e-6.
Note:
Old function newPlot() is still working. However, the new syntax
should be used.
"""
self.MS_precisions.append(MS_precision)
self.plots.append([])
self.titles.append(title)
return
[docs]
def newPlot(self, MS_precision="5e-6", title=None):
"""Deprecated since version 1.2."""
# Is this ok, pass the Factory.self to Spectrum class???
# Id just make deprecation warning a function independent of any class
# Also, this just looks wrong
spec.Spectrum.deprecation_warning(
self, function_name=sys._getframe().f_code.co_name
)
self.new_plot(MS_precision=MS_precision, title=title)
[docs]
def add(
self,
data,
color=(0, 0, 0),
style="sticks",
mz_range=None,
int_range=None,
opacity=0.8,
dash="solid",
name=None,
plot_num=-1,
title=None,
):
"""
Add data to the graph.
Arguments:
data (list): The data added to the graph. Must be list of tuples with
the following format. Note that i can be set to 'max_intensity' for
setting the label position to the maximum intensity.
* (mz,i) for all styles, except label,
* (mz,i, string) for label.hoverinfo, .sticks and .triangle
* (mz1, mz2, i, string) for label.linear and .spline
Keyword Arguments:
color (tuple): color encoded in RGB. Default = (0,0,0)
style (str): plotting style. Default = "sticks".
Currently supported styles are:
* 'lines':
Datapoints connected by lines
* 'points':
Datapoints without connection
* 'sticks':
Vertical line at given m/z (corresponds to centroided peaks)
* 'triangle' (MS_precision, micro, tiny, small, medium, big):
The top of the triangle corresponds to the given m/z, the width
corresponds to he given format, e.g. 'triangle.MS_precision'
* 'label.hoverinfo':
Label string appears as plotly hover info
* 'label.linear' (top, medium or bottom)
* 'label.spline' (top, medium or bottom)
* 'label.sticks'
* 'label.triangle' (small, medium or big)
mz_range (list): Boundaries that should be added to the current
plot
int_range (list): Boundaries that should be added to the current
plot
opacity (float): opacity of the data points
dash (str): type of line ('solid', 'dash', 'longdash', 'dot', 'dashdot', 'longdashdot')
name (str): name of data in legend
plot_num (int): Add data to plot[plot_num]
title (str): an optional title that will be printed above the plot
Note:
The mz_range and int_range in the add() function sets the limits of datapoints
added to the plot. This is in contrast to defining a range in the layout, which
only defines the area that is depicted (i.e. the zoom) but still adds the datapoints to the plot
(can be seen by zooming out).
"""
if len(self.plots) == 0:
self.new_plot(title=title)
if mz_range is None:
mz_range = [-float("Inf"), float("Inf")]
if int_range is None:
int_range = [-float("Inf"), float("Inf")]
if len(self.x_max) < len(self.plots):
self.x_max.append(mz_range[1])
self.x_min.append(mz_range[0])
if len(self.y_max) < len(self.plots):
self.y_max.append(int_range[1])
self.y_min.append(int_range[0])
# Init variables
filling = None
mode = "lines"
x_values = []
y_values = []
txt = []
style = style.split(".")
MS_precision = float(self.MS_precisions[plot_num])
if len(style) == 3:
pos = style[2]
available_pos = [
"MS_precision",
"micro",
"tiny",
"small",
"medium",
"big",
"top",
"bottom",
]
if pos not in available_pos:
raise Exception(
"Position must one of the following: {0}".format(available_pos)
)
else:
pos = None
if style[0] == "label":
mode = "text+lines"
if len(data[0]) < 3:
raise Exception(
"""
Must have at least (mz, i, annotation) in data
when using labels
"""
)
if style[1] == "hoverinfo":
shape = "linear"
mode = None
filling = None
for data_tuple in data:
x_values.append(data_tuple[0])
y_values.append(data_tuple[1])
txt.append(data_tuple[2])
elif style[1] == "sticks":
shape = "linear"
filling = "tozeroy"
for x in data:
y_pos = x[1]
x_values += x[0], x[0], x[0], None
y_values += 0.0, y_pos, 0.0, None
txt += None, x[2], None, None
elif style[1] == "triangle":
if not pos:
pos = "medium"
triangle_pos_list = [
"MS_precision",
"micro",
"tiny",
"small",
"medium",
"big",
]
if pos not in triangle_pos_list:
raise Exception("Position must be in {0}".format(triangle_pos_list))
shape = "linear"
filling = "tozeroy"
for x in data:
x_max = self.x_max[plot_num]
y_max = x[1]
y_values += 0.0, y_max, 0.0, None
txt += None, x[2], None, None
if pos == "MS_precision":
x_values += (
x[0] - (x[0] * MS_precision),
x[0],
x[0] + (x[0] * MS_precision),
None,
)
continue
elif pos == "micro":
rel_width = 1 / float(10000)
elif pos == "tiny":
rel_width = 1 / float(2000)
elif pos == "small":
rel_width = 1 / float(200)
elif pos == "medium":
rel_width = 1 / float(100)
elif pos == "big":
rel_width = 1 / float(50)
x_values += (
x[0] - (x_max * rel_width),
x[0],
x[0] + (x_max * rel_width),
None,
)
elif style[1] == "spline":
mode = "lines+markers+text"
shape = "spline"
txt = []
if not pos:
pos = "top"
for x in data:
if x[2] == "max_intensity":
y_max = self.y_max[plot_num]
else:
y_max = x[1]
if pos == "top":
y_pos = y_max
offset = y_max + (y_max * 0.1)
elif pos == "medium":
print(
"""'
{0}
is not working atm for
{1}
""".format(
pos, style
)
)
sys.exit(0)
y_pos = x[2] / 2
offset = "__splineOffset__"
elif pos == "bottom":
y_pos = 0.0
offset = "-__splineOffset__0"
x_values += x[0], (x[0] + x[1]) / 2, x[1], None
y_values += y_pos, str(offset), y_pos, None
txt += None, x[3], None, None
elif style[1] == "linear":
shape = "linear"
if not pos:
pos = "bottom"
for x in data:
if x[2] == "max_intensity":
y_max = self.y_max[plot_num]
else:
y_max = x[1]
if pos == "top":
y_pos = y_max
offset = y_max + (y_max * 0.1)
elif pos == "medium":
print(
"""'
{0}
is not working atm for
{1}
""".format(
pos, style
)
)
sys.exit(0)
y_pos = x[2] / 2
offset = "+__splineOffset__"
elif pos == "bottom":
y_pos = 0.0
offset = "-__splineOffset__0"
x_values += x[0], (x[0] + x[1]) / 2, x[1], None
y_values += str(offset), str(offset), str(offset), None
txt += None, x[3], None, None
# elif style[1] == 'lines':
# shape = 'linear'
# filling = 'tozeroy'
# for x in data:
# y_pos = 'self.y_max[i]'
# x_values += x[0], x[0], x[0], None
# y_values += .0, y_pos, .0, None
# txt += None, x[2], None, None
else:
raise Exception(
"""
Unknown label type
Currently supported are:
-> linear
-> spline
-> sticks
-> triangle
"""
)
elif style[0] in ["sticks", "triangle", "lines", "points"]:
x_vals = [
mz
for mz, i in data
if mz_range[0] <= mz <= mz_range[1]
and int_range[0] <= i <= int_range[1]
]
y_vals = [
i
for mz, i in data
if mz_range[0] <= mz <= mz_range[1]
and int_range[0] <= i <= int_range[1]
]
y_max = max(y_vals)
y_min = min(y_vals)
x_max = max(x_vals)
x_min = min(x_vals)
if self.x_max[plot_num] == float("Inf") or self.x_max[plot_num] < x_max:
self.x_max[plot_num] = x_max
if self.x_min[plot_num] == -float("Inf") or self.x_min[plot_num] > x_min:
self.x_min[plot_num] = x_min
if self.y_max[plot_num] == float("Inf") or self.y_max[plot_num] < y_max:
self.y_max[plot_num] = y_max
if self.y_min[plot_num] == -float("Inf") or self.y_min[plot_num] > y_min:
self.y_min[plot_num] = y_min
if style[0] == "sticks":
shape = "linear"
mode = "lines"
filling = "tozeroy"
for x in zip(x_vals, y_vals):
y_pos = x[1]
x_values += x[0], x[0], x[0], None
y_values += 0.0, y_pos, 0.0, None
elif style[0] == "triangle":
if len(style) == 2:
pos = style[1]
else:
pos = "medium"
triangle_pos_list = [
"MS_precision",
"micro",
"tiny",
"small",
"medium",
"big",
]
if pos not in triangle_pos_list:
raise Exception("Position must be in {0}".format(triangle_pos_list))
shape = "linear"
filling = "tozeroy"
for x in zip(x_vals, y_vals):
x_max = self.x_max[plot_num]
y_pos = x[1]
y_values += 0.0, y_pos, 0.0, None
if pos == "MS_precision":
x_values += (
x[0] - (x[0] * MS_precision),
x[0],
x[0] + (x[0] * MS_precision),
None,
)
continue
elif pos == "micro":
rel_width = 1 / float(10000)
elif pos == "tiny":
rel_width = 1 / float(2000)
elif pos == "small":
rel_width = 1 / float(200)
elif pos == "medium":
rel_width = 1 / float(100)
elif pos == "big":
rel_width = 1 / float(50)
x_values += (
x[0] - (x_max * rel_width),
x[0],
x[0] + (x_max * rel_width),
None,
)
elif style[0] == "lines":
mode = "lines"
shape = "linear"
for x in zip(x_vals, y_vals):
x_values.append(x[0])
y_values.append(x[1])
elif style[0] == "points":
mode = "markers"
shape = "linear"
x_values = x_vals
y_values = y_vals
else:
raise Exception(
"""
Invalid plotting style
Currently supported are:
-> lines
-> points
-> sticks
-> triangle
"""
)
trace = go.Scatter(
{
"x": x_values,
"y": y_values,
"text": txt,
"textfont": {"family": "Helvetica", "size": 10, "color": "#000000"},
"textposition": "top center",
"visible": True,
"marker": {
"size": 10,
"color": "rgba({0},{1},{2},{3})".format(
color[0], color[1], color[2], opacity
),
},
"mode": mode,
"name": name,
"line": {
"color": "rgba({0},{1},{2},{3})".format(
color[0], color[1], color[2], opacity
),
"width": self.style_options["line.width"],
"shape": shape,
"dash": dash,
},
"fill": filling,
"fillcolor": "rgba({0},{1},{2},{3})".format(
color[0], color[1], color[2], opacity
),
"opacity": opacity,
}
)
self.plots[plot_num].append(trace)
return trace
[docs]
def info(self):
"""
Prints summary about the plotting factory, i.e. how many plots and how
many datasets per plot.
"""
print(
"""
Factory holds {0} unique plots
""".format(
len(self.plots)
)
)
for i, plot in enumerate(self.plots):
print("\t\tPlot {0} holds {1} unique datasets".format(i, len(plot)))
for j, dataset in enumerate(plot):
print(
"\t\t\tDataset {0} holds {1} datapoints".format(
j, len(dataset["x"])
)
)
print()
return
[docs]
def save(
self, filename=None, mz_range=None, int_range=None, layout=None, write_pdf=False
):
"""
Saves all plots and their data points that have been added to the
plotFactory.
Keyword Arguments:
filename (str): Name for the output file. Default = "spectrum_plot.html"
mz_range (list): m/z range which should be considered [start, end].
Default = None
int_range (list): intensity range which should be considered [min, max].
Default = None
layout (dict): dictionary containing layout information in plotly style
write_pdf (bool): Set "True" in order to save plots as pdf file (on Unix systems,
this requires Orca to be installed)
Note:
mz_range and int_range defined here will be applied to all subplots in
the current plot, i.e. ranges defined when adding a subplot will be
overwritten. To avoid this, a list of lists can be given in the order
corresponding to the subplots.
"""
plot_number = len(self.plots)
rows, cols = int(math.ceil(plot_number / float(2))), 2
if plot_number % 2 == 0:
my_figure = subplots.make_subplots(
rows=rows,
cols=cols,
vertical_spacing=0.6 / rows,
subplot_titles=self.titles,
)
else:
specs = [[{}, {}] for x in range(rows - 1)]
specs.append([{"colspan": 2}, None])
my_figure = subplots.make_subplots(
rows=rows,
cols=cols,
vertical_spacing=0.6 / rows,
specs=specs,
subplot_titles=self.titles,
)
for i, plot in enumerate(self.plots):
print(int(math.floor((i / 2) + 1)), (i % 2) + 1)
for j, trace in enumerate(plot):
trace["y"] = [
self.function_mapper[x](i) if x in self.function_mapper else x
for x in trace["y"]
]
my_figure.append_trace(trace, int(math.floor((i / 2) + 1)), (i % 2) + 1)
for i in range(plot_number):
xaxis_key = "xaxis{0}".format(i + 1)
if mz_range:
if mz_range[0] == list or mz_range[0] == tuple:
# if list and not list of lists, apply same for all
my_figure["layout"][xaxis_key].update(range=mz_range[i])
my_figure["layout"][xaxis_key]["autorange"] = False
elif mz_range[0] == int or mz_range[0] == float:
my_figure["layout"][xaxis_key]["range"] = mz_range
my_figure["layout"][xaxis_key]["autorange"] = False
yaxis_key = "yaxis{0}".format(i + 1)
if int_range:
if int_range[0] == list or int_range[0] == tuple:
# if list and not list of lists, apply same for all
my_figure["layout"][yaxis_key].update(range=int_range[i])
my_figure["layout"][yaxis_key]["autorange"] = False
elif int_range[0] == int or int_range[0] == float:
my_figure["layout"][yaxis_key]["range"] = int_range
my_figure["layout"][yaxis_key]["autorange"] = False
my_figure["layout"][xaxis_key].update(title="m/z ")
my_figure["layout"][yaxis_key].update(title="Intensity")
my_figure["layout"][xaxis_key].update(
titlefont={"color": "#000000", "family": "Helvetica", "size": 18}
)
my_figure["layout"][yaxis_key].update(
titlefont={"color": "#000000", "family": "Helvetica", "size": 18}
)
my_figure["layout"]["legend"].update(font={"size": 10, "color": "#FF0000"})
if layout:
my_figure["layout"].update(layout)
if self.filename is None:
_filename = "spectrum_plot.html"
else:
_filename = self.filename
if filename is not None:
# save fkt name definition overrules original filename
_filename = filename
# plt.plot(my_figure, filename=_filename, auto_open=False)
plt.io.write_html(my_figure, _filename)
if write_pdf:
plt.io.write_image(my_figure, _filename.replace(".html", ".pdf"))
return
[docs]
def get_data(self):
"""
Return data and layout in JSON format.
Returns:
plots (dict): JSON compatible python dict
"""
for i, plot in enumerate(self.plots):
for j, trace in enumerate(plot):
self.plots[i][j]["y"] = [
self.function_mapper[x](i) if x in self.function_mapper else x
for x in trace["y"]
]
return self.plots
if __name__ == "__main__":
print(__doc__)