def text3d(ax, xyz, s, zdir="z", size=None, angle=0, usetex=False, **kwargs):
x, y, z = xyz
if zdir == "y":
xy1, z1 = (x, z), y
elif zdir == "y":
xy1, z1 = (y, z), x
else:
xy1, z1 = (x, y), z
text_path = TextPath((0, 0), s, size=size, usetex=usetex)
trans = Affine2D().rotate(angle).translate(xy1[0], xy1[1])
p1 = PathPatch(trans.transform_path(text_path), **kwargs)
ax.add_patch(p1)
art3d.pathpatch_2d_to_3d(p1, z=z1, zdir=zdir)
def letterAt(letter, x, y, yscale=1, ax=None, color=None, alpha=1.0):
#fp = FontProperties(family="Arial", weight="bold")
fp = FontProperties(family="Ubuntu", weight="bold")
globscale = 1.35
LETTERS = {
"T": TextPath((-0.305, 0), "T", size=1, prop=fp),
"G": TextPath((-0.384, 0), "G", size=1, prop=fp),
"A": TextPath((-0.35, 0), "A", size=1, prop=fp),
"C": TextPath((-0.366, 0), "C", size=1, prop=fp),
"UP": TextPath((-0.488, 0), '$\\Uparrow$', size=1, prop=fp),
"DN": TextPath((-0.488, 0), '$\\Downarrow$', size=1, prop=fp),
"(": TextPath((-0.25, 0), "(", size=1, prop=fp),
".": TextPath((-0.125, 0), "-", size=1, prop=fp),
")": TextPath((-0.1, 0), ")", size=1, prop=fp)
}
COLOR_SCHEME = {
'G': 'orange',
'A': 'red',
'C': 'blue',
'T': 'darkgreen',
'UP': 'green',
'DN': 'red',
'(': 'black',
'.': 'black',
')': 'black'
}
text = LETTERS[letter]
chosen_color = COLOR_SCHEME[letter]
if color is not None:
chosen_color = color
t = mpl.transforms.Affine2D().scale(1*globscale, yscale*globscale) + \
mpl.transforms.Affine2D().translate(x,y) + ax.transData
p = PathPatch(text, lw=0, fc=chosen_color, alpha=alpha, transform=t)
if ax != None:
ax.add_artist(p)
return p
def display_points(self, image_idx, image):
visible_points_coords = self.database.get_visible_points_coords(image)
self.clear_images(image_idx)
for point_id, coords in visible_points_coords.items():
color = distinct_colors[divmod(hash(point_id), 19)[1]]
text_path = TextPath((0, 0), point_id, size=10)
p1 = PathPatch(text_path, transform=IdentityTransform(), alpha=1, color=color)
offsetbox2 = AuxTransformBox(IdentityTransform())
offsetbox2.add_artist(p1)
ab = AnnotationBbox(offsetbox2, ((coords[0] + 30), (coords[1] + 30)), bboxprops=dict(alpha=0.05))
circle = mpatches.Circle((coords[0], coords[1]), 20, color=color, fill=False)
self.plt_artists[image_idx].append(ab)
self.plt_artists[image_idx].append(circle)
self.subplots[image_idx].add_artist(ab)
self.subplots[image_idx].add_artist(circle)
self.figures[image_idx].canvas.draw_idle()
def text3d(ax,
xyz,
s,
zdir="z",
size=0.1,
angle=0,
font='Arial',
weight='normal',
ha='left',
va='center',
**kwargs):
x, y, z = xyz
xlim, ylim, zlim = ax.get_xlim(), ax.get_ylim(), ax.get_zlim()
xmin, xmax, ymin, ymax, zmin, zmax = xlim[0], xlim[1], ylim[0], ylim[
1], zlim[0], zlim[1]
xlen, ylen, zlen = xmax - xmin, ymax - ymin, zmax - zmin
minLen_axis = np.min([xlen, ylen, zlen])
aspect = ax.get_box_aspect()
fontscale = 1
if zdir == "y":
xy, z, fontscale = (x, z), y, (xlen / zlen) / (aspect[0] / aspect[2])
elif zdir == "x":
xy, z, fontscale = (y, z), x, (ylen / zlen) / (aspect[1] / aspect[2])
else:
xy, z, fontscale = (x, y), z, (xlen / ylen) / (aspect[0] / aspect[1])
path = TextPath((0, 0),
s,
size=size,
prop=FontProperties(family=font, weight=weight))
V = path.vertices
if (ha == 'center'):
V[:, 0] -= (V[:, 0].max() - V[:, 0].min()) / 2 # 居中
elif (ha == 'right'):
V[:, 0] -= V[:, 0].max()
if (va == 'center'):
V[:, 1] -= (V[:, 1].max() - V[:, 1].min()) / 2 # 居中
elif (va == 'top'):
V[:, 1] -= V[:, 1].max()
trans = Affine2D().rotate(angle / 180 * np.pi).scale(
1, 1 / fontscale).translate(xy[0], xy[1])
path = PathPatch(trans.transform_path(path), clip_on=False, **kwargs)
ax.add_patch(path)
art3d.pathpatch_2d_to_3d(path, z=z, zdir=zdir)
def text3d(ax, xyz, s, zdir="z", size=None, angle=0, usetex=False, **kwargs):
'''
Plots the string 's' on the axes 'ax', with position 'xyz', size 'size',
and rotation angle 'angle'. 'zdir' gives the axis which is to be treated
as the third dimension. usetex is a boolean indicating whether the string
should be interpreted as latex or not. Any additional keyword arguments
are passed on to transform_path.
Note: zdir affects the interpretation of xyz.
'''
x, y, z = xyz
if zdir == "y":
xy1, z1 = (x, z), y
elif zdir == "y":
xy1, z1 = (y, z), x
else:
xy1, z1 = (x, y), z
text_path = TextPath((0, 0), s, size=size, usetex=usetex)
trans = Affine2D().rotate(angle).translate(xy1[0], xy1[1])
p1 = PathPatch(trans.transform_path(text_path), **kwargs)
ax.add_patch(p1)
art3d.pathpatch_2d_to_3d(p1, z=z1, zdir=zdir)
def text3d(ax, xyz, s, zdir="z", size=None, angle=0, usetex=False, **kwargs):
"""
Plots the string *s* on the axes *ax*, with position *xyz*, size *size*,
and rotation angle *angle*. *zdir* gives the axis which is to be treated as
the third dimension. *usetex* is a boolean indicating whether the string
should be run through a LaTeX subprocess or not. Any additional keyword
arguments are forwarded to `.transform_path`.
Note: zdir affects the interpretation of xyz.
"""
x, y, z = xyz
if zdir == "y":
xy1, z1 = (x, z), y
elif zdir == "x":
xy1, z1 = (y, z), x
else:
xy1, z1 = (x, y), z
text_path = TextPath((0, 0), s, size=size, usetex=usetex)
trans = Affine2D().rotate(angle).translate(xy1[0], xy1[1])
p1 = PathPatch(trans.transform_path(text_path), **kwargs)
ax.add_patch(p1)
art3d.pathpatch_2d_to_3d(p1, z=z1, zdir=zdir)
order_colors_pos = c_pos[np.argsort(matrix[site][c_pos])]
order_colors_neg = c_neg[np.argsort(-matrix[site][c_neg])]
for c in order_colors_pos:
liste.append( (list_aa[c],matrix[site,c],'+') )
for c in order_colors_neg:
liste.append( (list_aa[c],-matrix[site,c],'-') )
all_scores.append(liste)
maxi_size = np.abs(matrix).sum(-1).max()
return all_scores,maxi_size
fp = FontProperties(family="Arial", weight="bold")
globscale = 1.35
list_aa = ['A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W','Y','$\\boxminus$']
LETTERS = dict([ (letter, TextPath((-0.30, 0), letter, size=1, prop=fp) ) for letter in list_aa] )
COLOR_SCHEME = dict( [(letter,aa_color(letter)) for letter in list_aa] )
def Sequence_logo(matrix, ax = None,data_type=None,figsize=None,ylabel = None,title=None,epsilon=1e-4,show=True,
nrows=1,ticks_every=1,ticks_labels_size=14,title_size=20, x_start =0,x_stop=None):
if data_type is None:
if matrix.min()>=0:
data_type='mean'
else:
data_type = 'weights'
if ax is not None:
show = False
return_fig = False
else:
if figsize is None:
import matplotlib as mpl
from matplotlib.text import TextPath
from matplotlib.patches import PathPatch
from matplotlib.font_manager import FontProperties
fp = FontProperties(family="Arial", weight="bold")
globscale = 1.35
NUMBERS = {
"3": TextPath((-0.305, 0), "3", size=1, prop=fp),
"5": TextPath((-0.35, 0), "5", size=1, prop=fp),
"7": TextPath((-0.366, 0), "7", size=1, prop=fp),
"9": TextPath((-0.384, 0), "9", size=1, prop=fp),
"11": TextPath((-0.398, 0), "E", size=1, prop=fp)
}
ALPHABETS = {
"A": TextPath((-0.305, 0), "A", size=1, prop=fp),
"T": TextPath((-0.35, 0), "T", size=1, prop=fp),
"G": TextPath((-0.366, 0), "G", size=1, prop=fp),
"C": TextPath((-0.384, 0), "C", size=1, prop=fp)
}
COLOR_SCHEME = {
'3': 'orange',
'5': 'red',
'7': 'blue',
'9': 'navy',
'11': 'darkgreen'
}
COLOR_SCHEME_ALPHABET = {'A': 'orange', 'T': 'red', 'G': 'blue', 'C': 'navy'}
def __init__(self,
transform,
label_x,
label_y,
length=0.15,
fontsize=0.08,
loc=2,
angle=0,
aspect_ratio=1,
pad=0.4,
borderpad=0.4,
frameon=False,
color='w',
alpha=1,
sep_x=0.01,
sep_y=0,
fontproperties=None,
back_length=0.15,
head_width=10,
head_length=15,
tail_width=2,
text_props=None,
arrow_props=None,
**kwargs):
"""
Draw two perpendicular arrows to indicate directions.
Parameters
----------
transform : `matplotlib.transforms.Transform`
The transformation object for the coordinate system in use, i.e.,
:attr:`matplotlib.axes.Axes.transAxes`.
label_x, label_y : str
Label text for the x and y arrows
length : float, optional, default: 0.15
Length of the arrow, given in coordinates of *transform*.
fontsize : float, optional, default: 0.08
Size of label strings, given in coordinates of *transform*.
loc : int, optional, default: 2
Location of the direction arrows. Valid location codes are::
'upper right' : 1,
'upper left' : 2,
'lower left' : 3,
'lower right' : 4,
'right' : 5,
'center left' : 6,
'center right' : 7,
'lower center' : 8,
'upper center' : 9,
'center' : 10
angle : float, optional, default: 0
The angle of the arrows in degrees.
aspect_ratio : float, optional, default: 1
The ratio of the length of arrow_x and arrow_y.
Negative numbers can be used to change the direction.
pad : float, optional, default: 0.4
Padding around the labels and arrows, in fraction of the font size.
borderpad : float, optional, default: 0.4
Border padding, in fraction of the font size.
frameon : bool, optional, default: False
If True, draw a box around the arrows and labels.
color : str, optional, default: 'white'
Color for the arrows and labels.
alpha : float, optional, default: 1
Alpha values of the arrows and labels
sep_x, sep_y : float, optional, default: 0.01 and 0 respectively
Separation between the arrows and labels in coordinates of
*transform*.
fontproperties : `matplotlib.font_manager.FontProperties`, optional
Font properties for the label text.
back_length : float, optional, default: 0.15
Fraction of the arrow behind the arrow crossing.
head_width : float, optional, default: 10
Width of arrow head, sent to ArrowStyle.
head_length : float, optional, default: 15
Length of arrow head, sent to ArrowStyle.
tail_width : float, optional, default: 2
Width of arrow tail, sent to ArrowStyle.
text_props, arrow_props : dict
Properties of the text and arrows, passed to
`.textpath.TextPath` and `.patches.FancyArrowPatch`.
**kwargs
Keyworded arguments to pass to
:class:`matplotlib.offsetbox.AnchoredOffsetbox`.
Attributes
----------
arrow_x, arrow_y : `matplotlib.patches.FancyArrowPatch`
Arrow x and y
text_path_x, text_path_y : `matplotlib.textpath.TextPath`
Path for arrow labels
p_x, p_y : `matplotlib.patches.PathPatch`
Patch for arrow labels
box : `matplotlib.offsetbox.AuxTransformBox`
Container for the arrows and labels.
Notes
-----
If *prop* is passed as a keyword argument, but *fontproperties* is
not, then *prop* is be assumed to be the intended *fontproperties*.
Using both *prop* and *fontproperties* is not supported.
Examples
--------
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> from mpl_toolkits.axes_grid1.anchored_artists import (
... AnchoredDirectionArrows)
>>> fig, ax = plt.subplots()
>>> ax.imshow(np.random.random((10, 10)))
>>> arrows = AnchoredDirectionArrows(ax.transAxes, '111', '110')
>>> ax.add_artist(arrows)
>>> fig.show()
Using several of the optional parameters, creating downward pointing
arrow and high contrast text labels.
>>> import matplotlib.font_manager as fm
>>> fontprops = fm.FontProperties(family='monospace')
>>> arrows = AnchoredDirectionArrows(ax.transAxes, 'East', 'South',
... loc='lower left', color='k',
... aspect_ratio=-1, sep_x=0.02,
... sep_y=-0.01,
... text_props={'ec':'w', 'fc':'k'},
... fontproperties=fontprops)
"""
if arrow_props is None:
arrow_props = {}
if text_props is None:
text_props = {}
arrowstyle = ArrowStyle("Simple",
head_width=head_width,
head_length=head_length,
tail_width=tail_width)
if fontproperties is None and 'prop' in kwargs:
fontproperties = kwargs.pop('prop')
if 'color' not in arrow_props:
arrow_props['color'] = color
if 'alpha' not in arrow_props:
arrow_props['alpha'] = alpha
if 'color' not in text_props:
text_props['color'] = color
if 'alpha' not in text_props:
text_props['alpha'] = alpha
t_start = transform
t_end = t_start + transforms.Affine2D().rotate_deg(angle)
self.box = AuxTransformBox(t_end)
length_x = length
length_y = length * aspect_ratio
self.arrow_x = FancyArrowPatch((0, back_length * length_y),
(length_x, back_length * length_y),
arrowstyle=arrowstyle,
shrinkA=0.0,
shrinkB=0.0,
**arrow_props)
self.arrow_y = FancyArrowPatch((back_length * length_x, 0),
(back_length * length_x, length_y),
arrowstyle=arrowstyle,
shrinkA=0.0,
shrinkB=0.0,
**arrow_props)
self.box.add_artist(self.arrow_x)
self.box.add_artist(self.arrow_y)
text_path_x = TextPath(
(length_x + sep_x, back_length * length_y + sep_y),
label_x,
size=fontsize,
prop=fontproperties)
self.p_x = PathPatch(text_path_x, transform=t_start, **text_props)
self.box.add_artist(self.p_x)
text_path_y = TextPath((length_x * back_length + sep_x, length_y *
(1 - back_length) + sep_y),
label_y,
size=fontsize,
prop=fontproperties)
self.p_y = PathPatch(text_path_y, **text_props)
self.box.add_artist(self.p_y)
AnchoredOffsetbox.__init__(self,
loc,
pad=pad,
borderpad=borderpad,
child=self.box,
frameon=frameon,
**kwargs)
'M':(-0.301,0),
'N':(-0.301,0),
'P':(-0.301,0),
'Q':(-0.301,0),
'R':(-0.301,0),
'S':(-0.301,0),
'T':(-0.301,0),
'V':(-0.301,0),
'W':(-0.301,0),
'Y':(-0.301,0),
'X':(-0.301,0)
}
fp = FontProperties(family="Ubuntu", weight="bold")
LETTERS = {i: TextPath((aa_textpaths[i]), i, size=1, prop=fp) for i in aa_letters}
globscale = 1.35
# define color schemes
aa_1 = {i:'blue' for i in ['R','H','K']}
aa_2 = {i:'red' for i in ['D','E']}
aa_3 = {i:'cyan' for i in ['S','T','N','Q']}
aa_4 = {i:'green' for i in ['A','I','L','M','F','W','Y','V']}
aa_5 = {i:'yellow' for i in ['C','G','P']}
COLOR_SCHEME = {**aa_1,**aa_2,**aa_3,**aa_4,**aa_5}
def letterAt(letter, x, y, yscale=1, ax=None):
text = LETTERS[letter]
# visualize the data
x = data.food
y = data.sleep
groups = data.groupby('label')
colors = ['crimson', 'mediumblue']
#plot
#src https://stackoverflow.com/questions/21654635/scatter-plots-in-pandas-pyplot-how-to-plot-by-category
#plt.figure(figsize=[8,8])
i = 0
fig, ax = plt.subplots()
for name, group in groups:
letter = group.isCat.unique()
letter = letter[0]
ax.scatter(group.food, group.sleep, c=colors[i], marker=TextPath((0, 0), letter), s = 400, alpha =.8, label = name)
i+=1
##ax.legend()
plt.title("Cat?")
plt.xlabel("Food (in grams)")
plt.ylabel("Sleep (in hours)")
plt.show()
### Step 2. Train
X = data[['food','sleep']]
y = data['label']
#x_train, Y_train =
sample = [[600,22.0]]
# 2a. SVM Model
(args.predictionfolder, args.pdbid))
]
#AvailableGridPrediction = [i for i in glob.glob("%s/*_result_reformat.pickle" %(args.predictionfolder))]
# ============================
# Configure Matplotlib
# ============================
import matplotlib as mpl
from matplotlib.text import TextPath
from matplotlib.patches import PathPatch
from matplotlib.font_manager import FontProperties
fp = FontProperties(family="sans-serif", weight="bold")
globscale = 1.35
LETTERS = {
"U": TextPath((-0.365, 0), "U", size=1, prop=fp),
"G": TextPath((-0.384, 0), "G", size=1, prop=fp),
"A": TextPath((-0.35, 0), "A", size=1, prop=fp),
"C": TextPath((-0.325, 0), "C", size=1, prop=fp)
}
# RNAC color scheme
COLOR_SCHEME = {'G': '#FFAF00', 'A': '#06C806', 'C': '#0003C6', 'U': '#C90101'}
# Our NucleicNet Color scheme
#COLOR_SCHEME = {'G': '#AEF3EB',
# 'A': '#5B9AE8',
# 'C': '#E30F38',
# 'U': '#F1BBC1'}
def letterAt(letter, x, y, yscale=1, ax=None):
def logo_plot_in_axis(df,
seqID,
ax,
refseq=True,
key_residues=None,
refplot=False,
colors="WEBLOGO",
**kwargs):
"""Generates classic **LOGO** plot in a given axis.
:param df: Data container.
:type df: Union[:class:`.DesignFrame`, :class:`.SequenceFrame`]
:param str seqID: |seqID_param|.
:param bool refseq: if :data:`True` (default), mark the original residues according to
the reference sequence.
:param key_residues: |keyres_param|.
:type key_residues: |keyres_param|
:param bool refplot: When :data:`True`, it will reorder the residues in each position
so that the reference residue will be on the bottom and setting a two-color scheme
(provide a single color name in ``colors``) that allows to quickly identify the reference
type in each position.
:param colors: Colors to assign; it can be the name of a available color set or
a dictionary with a color for each type. Available color schemes are: Weblogo
(default), Hydrophobicity, Chemistry, and Charge.
:type colors: Union[:class:`str`, :class:`dict`]
:return: :class:`~matplotlib.axes.Axes` - secondary axis
.. seealso::
:func:`.logo_plot`
"""
order = [
"A", "V", "I", "L", "M", "F", "Y", "W", "S", "T", "N", "Q", "R", "H",
"K", "D", "E", "C", "G", "P"
]
data = copy.deepcopy(df)
if data.empty:
raise ValueError("Provided data container is empty. Nothing to plot.")
mpl.rcParams['svg.fonttype'] = 'none'
# Graphical Properties of resizable letters
path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'../components/square.ttf')
fp = FontProperties(fname=path, weight="bold")
globscale = 1.22
letters_shift = -0.5
LETTERS = {}
if isinstance(colors, dict):
for aa in colors:
LETTERS[aa] = TextPath((letters_shift, 0), aa, size=1, prop=fp)
elif isinstance(colors, str):
for aa in color_scheme(colors):
LETTERS[aa] = TextPath((letters_shift, 0), aa, size=1, prop=fp)
else:
raise ValueError(
"Colors need to either be a string representing the name of a available "
"color set or a dictionary with a color for each type.")
# Data type management.
if not isinstance(data, pd.DataFrame):
raise ValueError(
"Input data must be in a DataFrame, DesignFrame or SequenceFrame")
else:
if not isinstance(data, (DesignFrame, SequenceFrame)):
if len(set(data.columns.values).intersection(
set(order))) == len(order):
data = SequenceFrame(data)
else:
data = DesignFrame(data)
if isinstance(data, DesignFrame):
data = data.sequence_frequencies(seqID)
# Refseq and key_residues management.
ref_seq = data.get_reference_sequence(seqID,
key_residues) if refseq else ""
# data and key_residues management.
_data = data.get_key_residues(key_residues)
maxv = int(math.ceil(data.max_hight()))
ticks = len(_data)
# This is applied if it comes from the logo_plot function
if 'line_break' in kwargs and kwargs['line_break'] is not None:
if ticks < kwargs['line_break']:
ticks = kwargs['line_break']
ax.set_xticks(np.arange(0.5, ticks + 1))
ax.set_yticks(range(0, maxv + 1))
ax.set_xticklabels(_data.index.values)
ax.set_yticklabels(np.arange(0, maxv + 1, 1))
ax.set_xlim(-0.1, ticks + 0.1)
ax2 = None
if ref_seq is not None:
ax2 = ax.twiny()
ax2.set_xticks(ax.get_xticks())
ax2.set_xticklabels(list(ref_seq))
ax2.set_xlim(-0.1, ticks + 0.1)
sns.despine(ax=ax, trim=True)
ax.grid(False)
if ref_seq is not None:
sns.despine(ax=ax2, top=False, right=True, left=True, trim=True)
ax2.grid(False)
ax.lines = []
wdata = _dataframe2logo(_data)
x = 0.5
maxi = 0
for scores in wdata:
y = 0
for base, score in scores:
if isinstance(colors, dict):
_letterAt(base, x, y, score, ax, globscale, LETTERS, colors)
else:
_letterAt(base, x, y, score, ax, globscale, LETTERS,
color_scheme(colors))
y += score
x += 1
maxi = max(maxi, y)
return ax2
def plotDataV2(df, i):
xrange = np.arange(60 * 24)
plotdf = pd.DataFrame()
for group in df.groupby([df.device_id]):
groupdf = pd.DataFrame()
groupdf[group[0]] = group[1]['mean']
# FIXME remove the follwing three lines - no longer needed, the missing values are filled on compute_amvd.py now
# groupdf[group[0]+'-minute'] = group[1]['minute']
# groupdf[group[0]+'-minute'] = group[1]['timestamp']*60 + group[1]['timestamp.1']
# groupdf = groupdf.set_index(group[0]+'-minute').reindex(xrange).fillna(0).reset_index()
plotdf[group[0]] = groupdf[group[0]].values
plotdf[group[0] + '-delta'] = group[1]['delta'].values
plotdf[group[0] + '-activity'] = group[1]['activity_name'].values
fig, ax = plt.subplots()
#fig.canvas.set_window_title('Day '+str(i))
ax.set_title('Click on legend line to toggle line on/off')
lines = []
for column in plotdf.columns:
if 'delta' in column or 'activity' in column:
continue
line, = ax.plot(xrange,
plotdf[column],
lw=1.5,
label=column,
linestyle='-',
marker=',',
markersize=5)
# new
activity_groups = plotdf[column + '-activity'].groupby(
plotdf[column + '-activity'])
activity_labels_arr = []
for name, group in activity_groups:
if name == '0':
continue
print column, group.index
yvals = plotdf.iloc[group.index]
activity_labels, = ax.plot(group.index,
yvals[column],
marker=TextPath((0, 0),
name[0],
size=10000),
color='black',
linestyle='',
ms=10,
label='_nolegend_')
activity_labels_arr.append(activity_labels)
# new end
# poly = ax.fill_between(xrange, plotdf[column], where=plotdf[column]>10.05, facecolor=line.get_color(), alpha=0.5)
poly = ax.fill_between(
xrange,
plotdf[column],
where=(plotdf[column] > config['magnitude_threshold']).values &
(plotdf[column + '-delta'].abs() >
config['delta_threshold']).values,
facecolor=line.get_color(),
alpha=0.5)
lines.append(
(line, poly,
activity_labels_arr)) # 0 is the line, 1 is the filled polygon
# set x axis to display time
def timeformatter(x, pos):
'The two args are the value and tick position'
return "{:02d}:{:02d}".format(int(x) / 60, int(x) % 60)
formatter = plt.FuncFormatter(timeformatter)
ax.xaxis.set_major_formatter(formatter)
# set axis names
plt.xlabel('Time')
plt.ylabel('Acceleration(magnitude)')
leg = ax.legend(loc='upper left', fancybox=True, shadow=True)
leg.get_frame().set_alpha(0.4)
lined = dict()
for legline, origline in zip(leg.get_lines(), lines):
legline.set_picker(5) # 5 pts tolerance
lined[legline] = origline
def onpick(event):
# on the pick event, find the orig line corresponding to the
# legend proxy line, and toggle the visibility
legline = event.artist
origline = lined[legline][0] # 0 is the line, 1 is the filled polygon
poly = lined[legline][1]
vis = not origline.get_visible()
origline.set_visible(vis)
poly.set_visible(vis)
# new
activity_labels_arr = lined[legline][2]
for activity_labels in activity_labels_arr:
activity_labels.set_visible(vis)
# new end
# Change the alpha on the line in the legend so we can see what lines
# have been toggled
if vis:
legline.set_alpha(1.0)
else:
legline.set_alpha(0.2)
fig.canvas.draw()
fig.canvas.mpl_connect('pick_event', onpick)
def plot_own_sequence_logo(ALL_SCORES):
# ALL_SCORES = [[('A', 0),
# ('C', 1),
# ('G', 1),
# ('T', 0.0)],
# [('C', 1),
# ('G', 1),
# ('A', 0),
# ('T', 0)]]
# NOTE: order MATTERS within each row - smallest probability should appear first
fp = FontProperties(family="Arial", weight="bold")
globscale = 1.35
LETTERS = {
"T": TextPath((-0.305, 0), "T", size=1, prop=fp),
"G": TextPath((-0.384, 0), "G", size=1, prop=fp),
"A": TextPath((-0.35, 0), "A", size=1, prop=fp),
"C": TextPath((-0.366, 0), "C", size=1, prop=fp)
}
COLOR_SCHEME = {'G': 'orange', 'A': 'green', 'C': 'blue', 'T': 'red'}
def letterAt(letter, x, y, yscale=1, ax=None):
text = LETTERS[letter]
t = mpl.transforms.Affine2D().scale(1 * globscale, yscale * globscale) + \
mpl.transforms.Affine2D().translate(x, y) + ax.transData
p = PathPatch(text, lw=0, fc=COLOR_SCHEME[letter], transform=t)
if ax != None:
ax.add_artist(p)
return p
import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(10, 3))
all_scores = ALL_SCORES
x = 1
maxi = 0
for scores in all_scores:
y = 0
for base, score in scores:
letterAt(base, x, y, score, ax)
y += score
x += 1
maxi = max(maxi, y)
# plt.rcParams['axes.labelweight'] = 'bold'
plt.rcParams['axes.linewidth'] = 1.2
plt.ylabel("bits", weight='bold')
plt.xticks(range(1, x), weight='bold')
plt.yticks([0, 1, 2], weight='bold')
plt.xlim((0.5, x - 0.5))
plt.ylim((0, 2)) #maxi
ax.tick_params(length=0.0)
# rc('axes', linewidth=2)
# rc('font', weight='bold')
# ax.spines['bottom'].set_visible(False)
# Hide the right and top spines
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
# Only show ticks on the left and bottom spines
ax.yaxis.set_ticks_position('left')
ax.xaxis.set_ticks_position('bottom')
plt.tight_layout()
plt.show()
def sequence_logo(score_matrix,
order="value",
width=1.0,
ax=None,
sequence_type=Genome,
font_properties=None,
color_scheme=None,
**kwargs):
"""Plots a sequence logo for visualizing motifs.
Parameters
----------
score_matrix : np.ndarray
An :math:`L \\times N` array (where :math:`L` is the length of
the sequence, and :math:`N` is the size of the alphabet)
containing the scores for each base occuring at each position.
order : {'alpha', 'value'}
The manner by which to sort the bases stacked at each position
in the sequence logo plot.
* 'alpha' - Bases go in the order they are found in the\
sequence alphabet.
* 'value' - Bases go in the order of their value, with the\
largest at the bottom.
width : float, optional
Default is 1. The width of each character in the plotted logo.
A value of 1 will mean that there is no gap between each the
characters at each position. A value of 0 will not draw any
characters.
ax : matplotlib.pyplot.Axes or None, optional
Default is `None`. The axes to plot on. If left as `None`, a new
axis will be created.
sequence_type : class, optional
Default is `selene_sdk.sequences.Genome`. The type of sequence that
the *in silico* mutagenesis results are associated with. This
should generally be a subclass of `selene_sdk.sequences.Sequence`.
font_properties : matplotlib.font_manager.FontProperties or None, optional
Default is `None`. A `matplotlib.font_manager.FontProperties`
object that specifies the properties of the font to use for
plotting the motif. If `None`, no font will be used, and the
text will be rendered by a path. This method of rendering paths
is preferred, as it ensures all character heights correspond to
the actual values, and that there are no extra gaps between
the tops and bottoms of characters at each position in the
sequence logo. If the user opts to use a value other
than `None`, then no such guarantee can be made.
color_scheme : list(str) or None, optional
Default is `None`. A list containing the hex codes or names of
colors to use, appearing in the order of the bases of the
sequence type. If left as `None`, a default palette will be made
with `seaborn.color_palette`, and will have as many
colors as there are characters in the input sequence alphabet.
Returns
-------
matplotlib.pyplot.Axes
The axes containing the sequence logo plot.
Raises
------
ValueError
If the number of columns in `score_matrix` does not match the
number of characters in the alphabet of `sequence_type`.
ValueError
If the number of colors in `color_palette` does not match the
number of characters in the alphabet of `sequence_type`.
Examples
--------
We have included an example of the output from a`sequence_logo`
plot below:
.. image:: ../../docs/source/_static/img/sequence_logo_example.png
"""
# Note that everything will break if we do not deepcopy.
score_matrix = deepcopy(score_matrix)
score_matrix = score_matrix.transpose()
if font_properties is not None:
warnings.warn(
"Specifying a value for `font_properties` (other than `None`) "
"will use the `matplotlib`-based character paths, and causes "
"distortions in the plotted motif. We recommend leaving "
"`font_properties=None`. See the documentation for details.",
UserWarning)
if color_scheme is None:
color_scheme = sns.color_palette("Set1",
n_colors=len(sequence_type.BASES_ARR))
color_scheme = color_scheme.as_hex()
if len(color_scheme) < len(sequence_type.BASES_ARR):
raise ValueError(
"Color scheme is shorter than number of bases in sequence.")
if score_matrix.shape[0] != len(sequence_type.BASES_ARR):
raise ValueError(
"Got score with {0} bases for sequence with {1} bases.".format(
score_matrix.shape[0], len(sequence_type.BASES_ARR)))
if ax is None:
_, ax = plt.subplots(figsize=score_matrix.shape)
# Determine offsets depending on sort order.
positive_offsets = np.zeros_like(score_matrix)
negative_offsets = np.zeros_like(score_matrix)
bases = np.empty(score_matrix.shape, dtype=object)
bases[:, :] = "?" # This ensures blanks are visually obvious.
# Change ordering of things based on input arguments.
if order == "alpha":
for i in range(score_matrix.shape[0]):
bases[i, :] = sequence_type.BASES_ARR[i]
elif order == "value":
if np.sum(score_matrix < 0) != 0:
sorted_scores = np.zeros_like(score_matrix)
for j in range(score_matrix.shape[1]):
# Sort the negative values and put them at bottom.
div = np.sum(score_matrix[:, j] < 0.)
negative_idx = np.argwhere(score_matrix[:, j] < 0.).flatten()
negative_sort_idx = np.argsort(score_matrix[negative_idx, j],
axis=None)
sorted_scores[:div, j] = score_matrix[
negative_idx[negative_sort_idx], j]
bases[:div, j] = sequence_type.BASES_ARR[
negative_idx[negative_sort_idx]].flatten()
# Sort the positive values and stack atop the negatives.
positive_idx = np.argwhere(score_matrix[:, j] >= 0.).flatten()
positive_sort_idx = np.argsort(score_matrix[positive_idx, j],
axis=None)
sorted_scores[div:, j] = score_matrix[
positive_idx[positive_sort_idx], j]
bases[div:, j] = sequence_type.BASES_ARR[
positive_idx[positive_sort_idx]].flatten()
score_matrix = sorted_scores
else:
for j in range(score_matrix.shape[1]):
sort_idx = np.argsort(score_matrix[:, j], axis=None)[::-1]
bases[:, j] = sequence_type.BASES_ARR[sort_idx]
score_matrix[:, j] = score_matrix[sort_idx, j]
# Create offsets for each bar.
for i in range(score_matrix.shape[0] - 1):
y_coords = score_matrix[i, :]
if i > 0:
negative_offsets[i + 1, :] = negative_offsets[i, :]
positive_offsets[i + 1, :] = positive_offsets[i, :]
neg_idx = np.argwhere(y_coords < 0.)
pos_idx = np.argwhere(y_coords >= 0.)
negative_offsets[i + 1, neg_idx] += y_coords[neg_idx]
positive_offsets[i + 1, pos_idx] += y_coords[pos_idx]
for i in range(score_matrix.shape[0]):
x_coords = np.arange(score_matrix.shape[1]) + 0.5
y_coords = score_matrix[i, :]
# Manage negatives and positives separately.
offsets = np.zeros(score_matrix.shape[1])
negative_idx = np.argwhere(y_coords < 0.)
positive_idx = np.argwhere(y_coords >= 0.)
offsets[negative_idx] = negative_offsets[i, negative_idx]
offsets[positive_idx] = positive_offsets[i, positive_idx]
bars = ax.bar(x_coords,
y_coords,
color="black",
width=width,
bottom=offsets)
for j, bar in enumerate(bars):
base = bases[i, j]
bar.set_color(color_scheme[sequence_type.BASE_TO_INDEX[base]])
bar.set_edgecolor(None)
# Iterate over the barplot's bars and turn them into letters.
new_patches = []
for i, bar in enumerate(ax.patches):
base_idx = i // score_matrix.shape[1]
seq_idx = i % score_matrix.shape[1]
base = bases[base_idx, seq_idx]
# We construct a text path that tracks the bars in the barplot.
# Thus, the barplot takes care of scaling and translation,
# and we just copy it.
if font_properties is None:
text = Path(_SVG_PATHS[base][0], _SVG_PATHS[base][1])
else:
text = TextPath((0., 0.), base, fontproperties=font_properties)
b_x, b_y, b_w, b_h = bar.get_extents().bounds
t_x, t_y, t_w, t_h = text.get_extents().bounds
scale = (b_w / t_w, b_h / t_h)
translation = (b_x - t_x, b_y - t_y)
text = PathPatch(text, facecolor=bar.get_facecolor(), lw=0.)
bar.set_facecolor("none")
text.set_path_effects([_TextPathRenderingEffect(bar)])
transform = transforms.Affine2D().translate(*translation).scale(*scale)
text.set_transform(transform)
new_patches.append(text)
for patch in new_patches:
ax.add_patch(patch)
ax.set_xlim(0, score_matrix.shape[1])
ax.set_xticks(np.arange(score_matrix.shape[1]) + 0.5)
ax.set_xticklabels(np.arange(score_matrix.shape[1]))
return ax
import mpl_toolkits.mplot3d.art3d as art3d
from matplotlib.text import TextPath
from matplotlib.transforms import Affine2D
def text3d(ax, (x, y, z), s, zdir="z", size=None, angle=0, usetex=False,
**kwargs):
if zdir == "y":
xy1, z1 = (x, z), y
elif zdir == "y":
xy1, z1 = (y, z), x
else:
xy1, z1 = (x, y), z
text_path = TextPath((0, 0), s, size=size, usetex=usetex)
trans = Affine2D().rotate(angle).translate(xy1[0], xy1[1])
p1 = PathPatch(trans.transform_path(text_path), **kwargs)
ax.add_patch(p1)
art3d.pathpatch_2d_to_3d(p1, z=z1, zdir=zdir)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
p = Circle((5, 5), 3)
ax.add_patch(p)
art3d.pathpatch_2d_to_3d(p, z=0, zdir="x")
import matplotlib.patches as patches
from matplotlib.text import TextPath
from matplotlib.patches import PathPatch
from matplotlib.font_manager import FontProperties
import numpy as np
from scipy import stats
import pyproteome as pyp
from . import motif, plogo
BASES = list('ACDEFGHIKLMNPQRSTVWY')
GLOBSCALE = 1.4
LETTERS = {
base: TextPath(
(-0.303, 0),
base,
size=1,
prop=FontProperties(family='monospace', weight='bold'),
)
for base in BASES
}
LETTERS['Q'] = TextPath(
(-0.303, .11),
'Q',
size=1,
prop=FontProperties(family='monospace', weight='bold'),
)
LETTERS['G'] = TextPath(
(-0.303, .01),
'G',
size=1,
prop=FontProperties(family='monospace', weight='bold'),
def logo_plot(df,
seqID,
refseq=True,
key_residues=None,
line_break=None,
font_size=35,
colors="WEBLOGO"):
"""Generates classic **LOGO** plots.
:param df: Data container.
:type df: Union[:class:`.DesignFrame`, :class:`.SequenceFrame`]
:param str seqID: |seqID_param|.
:param bool refseq: if :data:`True` (default), mark the original residues according to
the reference sequence.
:param key_residues: |keyres_param|.
:type key_residue: |keyres_param|
:param int line_break: Force a line-change in the plot after n residues are plotted.
:param float font_size: Expected size of the axis font.
:param colors: Colors to assign; it can be the name of a available color set or
a dictionary with a color for each type.
:type colors: Union[:class:`str`, :class:`dict`]
:return: :class:`~matplotlib.figure.Figure` and
:func:`list` of :class:`~matplotlib.axes.Axes`
.. rubric:: Example
.. ipython::
In [1]: from rstoolbox.io import parse_rosetta_file
...: from rstoolbox.plot import logo_plot
...: import matplotlib.pyplot as plt
...: df = parse_rosetta_file("../rstoolbox/tests/data/input_2seq.minisilent.gz",
...: {"sequence": "B"})
...: df.add_reference_sequence("B", df.get_sequence("B")[0])
...: fig, axes = logo_plot(df, "B", refseq=True, line_break=50)
...: plt.tight_layout()
@savefig sequence_logo_plot_docs.png width=5in
In [2]: plt.show()
"""
def _letterAt(letter,
x,
y,
yscale=1,
ax=None,
globscale=1.35,
LETTERS=None,
COLOR_SCHEME=None):
text = LETTERS[letter]
t = mpl.transforms.Affine2D().scale(1 * globscale, yscale * globscale) + \
mpl.transforms.Affine2D().translate(x, y) + ax.transData
p = PathPatch(text, lw=0, fc=COLOR_SCHEME[letter], transform=t)
if ax is not None:
ax.add_artist(p)
return p
def _dataframe2logo(data):
aa = list(data)
odata = []
for _, pos in data.iterrows():
pdata = []
for k in aa:
if pos[k] > 0.0000000:
pdata.append((k, float(pos[k])))
odata.append(sorted(pdata, key=operator.itemgetter(1, 0)))
return odata
def _chunks(l, n):
for i in range(0, len(l), n):
yield l[i:i + n]
order = [
"A", "V", "I", "L", "M", "F", "Y", "W", "S", "T", "N", "Q", "R", "H",
"K", "D", "E", "C", "G", "P"
]
data = copy.deepcopy(df)
mpl.rcParams['svg.fonttype'] = 'none'
# Graphical Properties of resizable letters
path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'../components/square.ttf')
fp = FontProperties(fname=path, weight="bold")
globscale = 1.22
letters_shift = -0.5
LETTERS = {}
for aa in color_scheme(colors):
LETTERS[aa] = TextPath((letters_shift, 0), aa, size=1, prop=fp)
# Data type management.
if not isinstance(data, pd.DataFrame):
raise ValueError(
"Input data must be in a DataFrame, DesignFrame or SequenceFrame")
else:
if not isinstance(data, (DesignFrame, SequenceFrame)):
if len(set(data.columns.values).intersection(
set(order))) == len(order):
data = SequenceFrame(data)
else:
data = DesignFrame(data)
if isinstance(data, DesignFrame):
data = data.sequence_frequencies(seqID)
# key_residues management.
length = len(data.get_reference_sequence(seqID)) if refseq else None
key_residues = get_selection(key_residues, seqID, list(data.index.values),
length)
# Plot
if line_break is None:
figsize = (len(data) * 2, 2.3 * 2)
grid = (1, 1)
fig = plt.figure(figsize=figsize)
axs = [
plt.subplot2grid(grid, (0, 0)),
]
krs = [
key_residues,
]
else:
rows = int(math.ceil(float(len(data)) / line_break))
figsize = (float(len(data) * 2) / rows, 2.3 * 2 * rows)
grid = (rows, 1)
fig = plt.figure(figsize=figsize)
axs = [plt.subplot2grid(grid, (_, 0)) for _ in range(rows)]
krs = list(_chunks(key_residues, line_break))
font = FontProperties()
font.set_size(font_size)
font.set_weight('bold')
for _, ax in enumerate(axs):
# Refseq and key_residues management.
ref_seq = data.get_reference_sequence(seqID, krs[_]) if refseq else ""
# data and key_residues management.
_data = data.get_key_residues(krs[_])
maxv = int(math.ceil(data.max_hight()))
ticks = len(_data)
if line_break is not None and len(_data) < line_break:
ticks = line_break
ax.set_xticks(np.arange(0.5, ticks + 1))
ax.set_yticks(range(0, maxv + 1))
ax.set_xticklabels(_data.index.values)
ax.set_yticklabels(np.arange(0, maxv + 1, 1))
if ref_seq is not None:
ax2 = ax.twiny()
ax2.set_xticks(ax.get_xticks())
ax2.set_xticklabels(list(ref_seq))
sns.despine(ax=ax, trim=True)
ax.grid(False)
if ref_seq is not None:
sns.despine(ax=ax2, top=False, right=True, left=True, trim=True)
ax2.grid(False)
ax.lines = []
wdata = _dataframe2logo(_data)
x = 0.5
maxi = 0
for scores in wdata:
y = 0
for base, score in scores:
_letterAt(base, x, y, score, ax, globscale, LETTERS,
color_scheme(colors))
y += score
x += 1
maxi = max(maxi, y)
for label in (ax.get_xticklabels() + ax.get_yticklabels()):
label.set_fontproperties(font)
if ref_seq is not None:
for label in (ax2.get_xticklabels() + ax2.get_yticklabels()):
label.set_fontproperties(font)
return fig, axs
def dna_logo(self, save=False, show=False, count=True, ax=None):
freq = np.array(self._freq(count))
en = 2.88539008 / max(sum(self.count), 1.5)
info = (np.log(5) / np.log(2) - en - self.entropy(count=count))
if np.min(info) < 0:
info -= np.min(info)
height = (freq.T * info).T
order = ['A', 'G', 'C', 'T', '-']
height = [
sorted(list(zip(order, i)), key=lambda x: x[1]) for i in height
]
fp = FontProperties(family="monospace", weight="bold")
LETTERS = {
"T": TextPath((-0.395, 0), "T", size=1.35, prop=fp),
"G": TextPath((-0.395, 0), "G", size=1.35, prop=fp),
"A": TextPath((-0.395, 0), "A", size=1.35, prop=fp),
"C": TextPath((-0.395, 0), "C", size=1.35, prop=fp),
"-": TextPath((-0.395, 0), "I", size=1.35, prop=fp)
}
COLOR_SCHEME = {
'G': 'orange',
'A': 'red',
'C': 'blue',
'T': 'darkgreen',
'-': 'black'
}
if ax:
ax = ax
drawx = False
fig = None
else:
fig = Figure(figsize=(7, 2))
ax = fig.subplots()
drawx = True
for x, scores in enumerate(height):
y = 0
for letter, score in scores:
text = LETTERS[letter]
t = mpl.transforms.Affine2D().scale(1.2, score) + \
mpl.transforms.Affine2D().translate(x+1, y) + ax.transData
p = PathPatch(text, lw=0, fc=COLOR_SCHEME[letter], transform=t)
ax.add_artist(p)
y += score
x_tick_label = ([
str(k + 1) + '\n' + i[-1][0] for k, i in enumerate(height)
] if drawx else [str(k + 1) for k, i in enumerate(height)])
ax.set_title('{} Total count: {}'.format(str(self.name),
sum(self.count)),
fontsize=6)
ax.set_xticks(range(1, len(height) + 1), )
ax.set_xticklabels(x_tick_label)
ax.set_xlim((0, len(height) + 1))
ax.set_ylim((0, 2.33))
ax.tick_params(axis='both', which='both', labelsize=6)
if save:
fig.set_tight_layout(True)
save = save if isinstance(save,
str) else str(self.name) + '_logo.svg'
fig.savefig(save, format='svg')
if show:
plt.tight_layout()
plt.show()
return fig
import matplotlib.pyplot as plt
import numpy as np
import matplotlib
import matplotlib.patheffects
from matplotlib import transforms
from matplotlib.text import TextPath
from matplotlib.patches import PathPatch
from matplotlib.font_manager import FontProperties
"""
Global variables for plotting logos
"""
fp = FontProperties(family="Arial", weight="bold")
GLOBSCALE = 1.35
LETTERS = { "T" : TextPath((-0.305, 0), "T", size=1, prop=fp),
"G" : TextPath((-0.384, 0), "G", size=1, prop=fp),
"A" : TextPath((-0.35, 0), "A", size=1, prop=fp),
"C" : TextPath((-0.366, 0), "C", size=1, prop=fp) }
COLOR_SCHEME = {'G': 'orange',
'A': 'red',
'C': 'blue',
'T': 'darkgreen'}
class Scale(matplotlib.patheffects.RendererBase):
def __init__(self, sx, sy=None):
self._sx = sx
self._sy = sy
def draw_path(self, renderer, gc, tpath, affine, rgbFace):
affine = affine.identity().scale(self._sx, self._sy)+affine
def get_letter_to_glyph(self):
# preferably Arial, but that requires separate installation
fp = FontProperties(family="sans", weight="bold")
letters = dict(A=TextPath((-0.35, 0), "A", size=1, prop=fp),
C=TextPath((-0.35, 0), "C", size=1, prop=fp),
D=TextPath((-0.36, 0), "D", size=1, prop=fp),
E=TextPath((-0.34, 0), "E", size=1, prop=fp),
F=TextPath((-0.32, 0), "F", size=1, prop=fp),
G=TextPath((-0.378, 0), "G", size=1, prop=fp),
H=TextPath((-0.36, 0), "H", size=1, prop=fp),
I=TextPath((-0.14, 0), "I", size=1, prop=fp),
K=TextPath((-0.39, 0), "K", size=1, prop=fp),
L=TextPath((-0.33, 0), "L", size=1, prop=fp),
M=TextPath((-0.41, 0), "M", size=1, prop=fp),
N=TextPath((-0.36, 0), "N", size=1, prop=fp),
P=TextPath((-0.345, 0), "P", size=1, prop=fp),
Q=TextPath((-0.392, 0), "Q", size=1, prop=fp),
R=TextPath((-0.385, 0), "R", size=1, prop=fp),
S=TextPath((-0.32, 0), "S", size=1, prop=fp),
T=TextPath((-0.31, 0), "T", size=1, prop=fp),
V=TextPath((-0.33, 0), "V", size=1, prop=fp),
W=TextPath((-0.47, 0), "W", size=1, prop=fp),
Y=TextPath((-0.33, 0), "Y", size=1, prop=fp))
return letters
def _protein_letter_at(letter, x, y, yscale=1, ax=None, color='black', alpha=1.0):
#fp = FontProperties(family="Arial", weight="bold")
#fp = FontProperties(family="Ubuntu", weight="bold")
fp = FontProperties(family="DejaVu Sans", weight="bold")
globscale = 1.35
LETTERS = {"T" : TextPath((-0.305, 0), "T", size=1, prop=fp),
"G" : TextPath((-0.384, 0), "G", size=1, prop=fp),
"A" : TextPath((-0.35, 0), "A", size=1, prop=fp),
"C" : TextPath((-0.366, 0), "C", size=1, prop=fp),
"L" : TextPath((-0.35, 0), "L", size=1, prop=fp),
"M" : TextPath((-0.35, 0), "M", size=1, prop=fp),
"F" : TextPath((-0.35, 0), "F", size=1, prop=fp),
"W" : TextPath((-0.35, 0), "W", size=1, prop=fp),
"K" : TextPath((-0.35, 0), "K", size=1, prop=fp),
"Q" : TextPath((-0.35, 0), "Q", size=1, prop=fp),
"E" : TextPath((-0.35, 0), "E", size=1, prop=fp),
"S" : TextPath((-0.35, 0), "S", size=1, prop=fp),
"P" : TextPath((-0.35, 0), "P", size=1, prop=fp),
"V" : TextPath((-0.35, 0), "V", size=1, prop=fp),
"I" : TextPath((-0.35, 0), "I", size=1, prop=fp),
"Y" : TextPath((-0.35, 0), "Y", size=1, prop=fp),
"H" : TextPath((-0.35, 0), "H", size=1, prop=fp),
"R" : TextPath((-0.35, 0), "R", size=1, prop=fp),
"N" : TextPath((-0.35, 0), "N", size=1, prop=fp),
"D" : TextPath((-0.35, 0), "D", size=1, prop=fp),
"U" : TextPath((-0.35, 0), "U", size=1, prop=fp),
"!" : TextPath((-0.35, 0), "!", size=1, prop=fp),
"UP" : TextPath((-0.488, 0), '$\\Uparrow$', size=1, prop=fp),
"DN" : TextPath((-0.488, 0), '$\\Downarrow$', size=1, prop=fp),
"(" : TextPath((-0.25, 0), "(", size=1, prop=fp),
"." : TextPath((-0.125, 0), "-", size=1, prop=fp),
")" : TextPath((-0.1, 0), ")", size=1, prop=fp)}
if letter in LETTERS :
text = LETTERS[letter]
else :
text = TextPath((-0.35, 0), letter, size=1, prop=fp)
chosen_color = color
if chosen_color is None :
chosen_color = 'black'
if letter in ['A', 'I', 'L', 'M', 'F', 'W', 'V'] : #Hydrophobic
chosen_color = 'blue'
elif letter in ['K' ,'R'] : #Positive charge
chosen_color = 'red'
elif letter in ['E', 'D'] : #Negative charge
chosen_color = 'magenta'
elif letter in ['N', 'Q', 'S', 'T'] : #Polar
chosen_color = 'green'
elif letter in ['C'] : #Cysteines
chosen_color = 'pink'
elif letter in ['G'] : #Glycines
chosen_color = 'orange'
elif letter in ['P'] : #Prolines
chosen_color = 'yellow'
elif letter in ['H', 'Y'] : #Aromatic
chosen_color = 'cyan'
t = mpl.transforms.Affine2D().scale(1*globscale, yscale*globscale) + \
mpl.transforms.Affine2D().translate(x,y) + ax.transData
p = PathPatch(text, lw=0, fc=chosen_color, alpha=alpha, transform=t)
if ax != None:
ax.add_artist(p)
return p
def text_path(name):
return TextPath((0, 0), get_id(name))
(0.6, 0.8, 0.8), (1.0, 1.0, 1.0))}
# color map: field lines (red | blue)
redbl = {'red': ((0., 1., 1.), (0.5, 1., 0.), (1., 0., 0.)),
'blue': ((0., 0., 0.), (0.5, 0., 1.), (1., 1., 1.)),
'green': ((0., 0., 0.), (1., 0., 0.)),
'alpha': ((0., 0.4, 0.4), (1., 0.4, 0.4))}
mne_field_grad_cols = LinearSegmentedColormap('mne_grad', yrtbc)
mne_field_line_cols = LinearSegmentedColormap('mne_line', redbl)
# plot gradient and contour lines
im = plt.imshow(Z, cmap=mne_field_grad_cols, aspect='equal')
cs = plt.contour(Z, 9, cmap=mne_field_line_cols, linewidths=1)
plot_dims = np.r_[np.diff(ax.get_xbound()), np.diff(ax.get_ybound())]
# create MNE clipping mask
mne_path = TextPath((0, 0), 'MNE')
dims = mne_path.vertices.max(0) - mne_path.vertices.min(0)
vert = mne_path.vertices - dims / 2.
mult = (plot_dims / dims).min()
mult = [mult, -mult] # y axis is inverted (origin at top left)
offset = plot_dims / 2. - center_fudge
mne_clip = Path(offset + vert * mult, mne_path.codes)
# apply clipping mask to field gradient and lines
im.set_clip_path(mne_clip, transform=im.get_transform())
for coll in cs.collections:
coll.set_clip_path(mne_clip, transform=im.get_transform())
# get final position of clipping mask
mne_corners = mne_clip.get_extents().corners()
# add tagline
rcParams.update({'font.sans-serif': ['Cooper Hewitt'], 'font.weight': 'light'})
import matplotlib as mpl
from matplotlib.text import TextPath
from matplotlib.patches import PathPatch
from matplotlib.font_manager import FontProperties
fp = FontProperties(family="Arial", weight="bold")
globscale = 1.35
NUMBERS = { "1" : TextPath((-0.30, 0), "1", size=1, prop=fp),
"3" : TextPath((-0.305, 0), "3", size=1, prop=fp),
"5" : TextPath((-0.35, 0), "5", size=1, prop=fp),
"7" : TextPath((-0.366, 0), "7", size=1, prop=fp),
"9" : TextPath((-0.384, 0), "9", size=1, prop=fp),
"11" : TextPath((-0.398, 0), "E", size=1, prop=fp) }
ALPHABETS = { "A" : TextPath((-0.305, 0), "A", size=1, prop=fp),
"T" : TextPath((-0.35, 0), "T", size=1, prop=fp),
"G" : TextPath((-0.366, 0), "G", size=1, prop=fp),
"C" : TextPath((-0.384, 0), "C", size=1, prop=fp) }
COLOR_SCHEME = {'1': 'yellow',
'3': 'orange',
'5': 'red',
'7': 'blue',
'9': 'navy',
'11': 'darkgreen'}
COLOR_SCHEME_ALPHABET = {'A': 'darkgreen',
'T': 'red',
'G': 'orange',
'C': 'navy'}
ax1.axis('off')
except:
print('image missing')
# Scatter plot
ax2 = fig.add_subplot(1, 2, 2)
ax2.plot(df_red['x'], df_red['y'], ".", label='Red', color='r')
ax2.plot(df_green['x'], df_green['y'], ".", label='Green', color='g')
ax2.plot(df_blue['x'], df_blue['y'], ".", label='Blue', color='b')
ax2.plot(df_yellow['x'], df_yellow['y'], ".", label='Yellow', color='y')
#Candidates
for c in candidates:
ax2.plot(c[1],
c[2],
marker=TextPath((0, 0), c[0]),
markersize=20,
color='k')
ax2.set_xlim(-10, 10)
ax2.set_ylim(-10, 10)
ax2.set_title('Political Compass')
ax2.set_xlabel('Planned Economy <-- Economics --> Free Market')
ax2.set_ylabel('Liberal <-- Government --> Authoritarian')
lgd2 = ax2.legend(loc=1)
fig.savefig("Simulated_Spectrum", dpi=300)
if centerists:
mean_center = [0, 0]
cov_center = [[5, 0], [0, 5]] # diagonal covariance
pos_center = np.random.multivariate_normal(mean_center, cov_center, 3500)
E_data_extra = E_data_extra.sort_index()
E_data_extra2 = E_data_extra2.sort_index()
E_data_extra2.to_excel(writer, "E_PV_PC")
fig = plt.figure(num=None, figsize=(8, 6), facecolor='w', edgecolor='k')
fig.subplots_adjust(hspace=0.3, wspace=0.3)
i=0
for ttype, v1 in E_data.items():
i += 1
ax = fig.add_subplot(2, math.ceil(len(E_data)/2), i)
for product, v2 in v1.items():
search = re.search(r"^(\w)Z(\d+)$", product, re.IGNORECASE).groups()
char = search[0]
label= iden_label(int(search[1]))
label = TextPath((0,0), str(char+label), linewidth=3)
linestyle = iden_company(char)
ax.plot(v2["x"], v2["y"], label=product, linestyle=linestyle, marker=label, markersize=20)
ax.set_title(ttype)
plt.xlim([x_lower,x_upper])
ax.set_xlabel('Period')
ax.set_ylabel(v2["unit"])
handles, labels = ax.get_legend_handles_labels()
labels, handles = zip(*sorted(zip(labels, handles), key=lambda t: t[0]))
fig.legend(handles, labels, loc='lower right')
fig.suptitle('E. Product Sales', fontsize=20)
fig.savefig(rpt_out+'/E.png')
# Deal with F for competitive
F_data = collections.defaultdict(lambda: collections.defaultdict(lambda: collections.defaultdict(dict)))
F_data2 = collections.defaultdict(lambda: collections.defaultdict(lambda: collections.defaultdict(dict)))
if 1:
usetex = plt.rcParams["text.usetex"]
fig = plt.figure(1)
# EXAMPLE 1
ax = plt.subplot(211)
from matplotlib._png import read_png
fn = get_sample_data("grace_hopper.png", asfileobj=False)
arr = read_png(fn)
text_path = TextPath((0, 0), "!?", size=150)
p = PathClippedImagePatch(text_path,
arr,
ec="k",
transform=IdentityTransform())
#p.set_clip_on(False)
# make offset box
offsetbox = AuxTransformBox(IdentityTransform())
offsetbox.add_artist(p)
# make anchored offset box
ao = AnchoredOffsetbox(loc=2, child=offsetbox, frameon=True, borderpad=0.2)
ax.add_artist(ao)
list.sort(key=sortSecond)
PPM.append(list)
PPM
# draw the floating letters graph
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
#...
fig, ax = plt.subplots(figsize=(20,10))
for b in baseline:
path = TextPath((0,0), b[0])
plt.plot(b[1],b[2],marker=path, alpha=1, markersize=50, color=b[3])
for i in line_0:
path = TextPath((0,0), i[0])
plt.plot(i[1],i[2],marker=path, alpha=1, markersize=50, color=i[3])
for k in line_1:
path = TextPath((0,0), k[0])
plt.plot(k[1],k[2],marker=path, alpha=1, markersize=50, color=k[3])
for t in line_2:
path = TextPath((0,0), t[0])
plt.plot(t[1],t[2],marker=path, alpha=1, markersize=50, color=t[3])
plt.xlim([-11,11])
