def tight_layout(self, figure, renderer=None,
pad=1.08, h_pad=None, w_pad=None, rect=None):
"""
Adjust subplot parameters to give specified padding.
Parameters
----------
pad : float
Padding between the figure edge and the edges of subplots, as a
fraction of the font-size.
h_pad, w_pad : float, optional
Padding (height/width) between edges of adjacent subplots.
Defaults to ``pad_inches``.
rect : tuple of 4 floats, optional
(left, bottom, right, top) rectangle in normalized figure
coordinates that the whole subplots area (including labels) will
fit into. Default is (0, 0, 1, 1).
"""
subplotspec_list = tight_layout.get_subplotspec_list(
figure.axes, grid_spec=self)
if None in subplotspec_list:
warnings.warn("This figure includes Axes that are not compatible "
"with tight_layout, so results might be incorrect.")
if renderer is None:
renderer = tight_layout.get_renderer(figure)
kwargs = tight_layout.get_tight_layout_figure(
figure, figure.axes, subplotspec_list, renderer,
pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect)
self.update(**kwargs)
def tight_layout(self, figure, renderer=None,
pad=1.08, h_pad=None, w_pad=None, rect=None):
"""
Adjust subplot parameters to give specified padding.
Parameters
----------
pad : float
Padding between the figure edge and the edges of subplots, as a
fraction of the font-size.
h_pad, w_pad : float, optional
Padding (height/width) between edges of adjacent subplots.
Defaults to ``pad_inches``.
rect : tuple of 4 floats, optional
(left, bottom, right, top) rectangle in normalized figure
coordinates that the whole subplots area (including labels) will
fit into. Default is (0, 0, 1, 1).
"""
subplotspec_list = tight_layout.get_subplotspec_list(
figure.axes, grid_spec=self)
if None in subplotspec_list:
warnings.warn("This figure includes Axes that are not compatible "
"with tight_layout, so results might be incorrect.")
if renderer is None:
renderer = tight_layout.get_renderer(figure)
kwargs = tight_layout.get_tight_layout_figure(
figure, figure.axes, subplotspec_list, renderer,
pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect)
self.update(**kwargs)
def do_tight_layout(fig, axes, suptitle, **kwargs):
# tight_layout
renderer = get_renderer(fig)
axeslist = list(axes.values())
subplots_list = list(get_subplotspec_list(axeslist))
kw = get_tight_layout_figure(
fig,
axeslist,
subplots_list,
renderer,
# pad=1.1,
h_pad=0,
w_pad=0,
rect=None,
)
left = kwargs.get("left", kw["left"])
bottom = kwargs.get("bottom", kw["bottom"])
right = kwargs.get("right", kw["right"])
top = kw["top"]
if suptitle:
top = top * 0.95
top = kwargs.get("top", top)
ws = kwargs.get("wspace", kw.get("wspace", 0) * 1.1)
hs = kwargs.get("hspace", kw.get("hspace", 0) * 1.1)
plt.subplots_adjust(
left=left, bottom=bottom, right=right, top=top, wspace=ws, hspace=hs
)
def build_tight_layout(self, artists):
rect = [0,0,1,1]
args = None
try:
# Some plot configurations are incompatible with tight_layout; this
# test is from matplotlib's tight_layout() in figure.py
from matplotlib.tight_layout import get_subplotspec_list
if not None in get_subplotspec_list(self.figure.axes):
self.figure.savefig(io.BytesIO())
renderer = self.figure._cachedRenderer
fig_bbox = self.figure.get_tightbbox(renderer)
if self.legends:
legend_width = max([l.get_window_extent().width for l in self.legends])/self.figure.dpi
rect[2] = max(0.5,1-legend_width/fig_bbox.width)
if self.annotation_obj:
annotation_height = self.annotation_obj.get_window_extent(renderer).height/self.figure.dpi
rect[1] = annotation_height/fig_bbox.height
if self.title_obj:
title_height = self.title_obj.get_window_extent(renderer).height/self.figure.dpi
rect[3] = 1-title_height/fig_bbox.height
self.figure.tight_layout(pad=0.5, rect=rect)
args = {}
except (AttributeError, ImportError):
pass
# Fall back to the regular bbox_extra_artists output feature
if args is None:
args = {'bbox_extra_artists': artists, 'bbox_inches': 'tight'}
return args
def build_tight_layout(self, artists):
rect = [0,0,1,1]
args = None
try:
# Some plot configurations are incompatible with tight_layout; this
# test is from matplotlib's tight_layout() in figure.py
from matplotlib.tight_layout import get_subplotspec_list
if not None in get_subplotspec_list(self.figure.axes):
self.figure.savefig(io.BytesIO())
renderer = self.figure._cachedRenderer
fig_bbox = self.figure.get_tightbbox(renderer)
if self.legends:
legend_width = max([l.get_window_extent().width for l in self.legends])/self.figure.dpi
rect[2] = max(0.5,1-legend_width/fig_bbox.width)
if self.annotation_obj:
annotation_height = self.annotation_obj.get_window_extent(renderer).height/self.figure.dpi
rect[1] = annotation_height/fig_bbox.height
if self.title_obj:
title_height = self.title_obj.get_window_extent(renderer).height/self.figure.dpi
rect[3] = 1-title_height/fig_bbox.height
self.figure.tight_layout(pad=0.5, rect=rect)
args = {}
except (AttributeError, ImportError):
pass
# Fall back to the regular bbox_extra_artists output feature
if args is None:
args = {'bbox_extra_artists': artists, 'bbox_inches': 'tight'}
return args
def do_tight_layout(fig, axes, suptitle, **kwargs):
# tight_layout
renderer = get_renderer(fig)
axeslist = list(axes.values())
subplots_list = list(get_subplotspec_list(axeslist))
kw = get_tight_layout_figure(fig,
axeslist,
subplots_list,
renderer,
pad=1.08,
h_pad=0,
w_pad=0,
rect=None)
left = kwargs.get('left', kw['left'])
bottom = kwargs.get('bottom', kw['bottom'])
right = kwargs.get('right', kw['right'])
top = kw['top']
if suptitle:
top = top * .95
top = kwargs.get('top', top)
ws = kwargs.get('wspace', kw.get('wspace', 0) * 1.1)
hs = kwargs.get('hspace', kw.get('hspace', 0) * 1.1)
plt.subplots_adjust(left=left,
bottom=bottom,
right=right,
top=top,
wspace=ws,
hspace=hs)
def horizontal_center(fig, pad=1.08):
"""Apply matplotlib's tight_layout to the left margin while keeping the plot
contents centered.
This is useful when setting the size of a figure to a document's full
column width then adjusting so that the plot appears centered rather than
the [y-axis label, tick labels, plot area] as a whole is centered.
Parameters
----------
fig : Figure
The matplotlib figure object, the content of which will be centered
pad : float
Padding between the edge of the figure and the axis labels, as a
multiple of font size
Returns
-------
i : int or None
The number of iterations to converge (the computed margins don't change
between iterations) or None if it does not converge.
Examples
--------
Plot some data and save it as a PNG. The center of the x axis will be
centered within the figure.
>>> import mplpub
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.plot([1, 2, 3], [1, 4, 9])
>>> plt.ylabel('y axis')
>>> fig.set_size_inches(4, 1)
>>> mplpub.horizontal_center(fig)
>>> fig.savefig('plot.png')
"""
for i in range(11):
adjust_kwargs = get_tight_layout_figure(fig, fig.axes,
get_subplotspec_list(fig.axes), get_renderer(fig), pad=pad)
min_kwarg = max(1-adjust_kwargs['right'], adjust_kwargs['left'])
if ((min_kwarg - fig.subplotpars.left)==0 and
(min_kwarg + fig.subplotpars.right)==1):
return i
fig.subplots_adjust(left=min_kwarg,
right=1-min_kwarg,
wspace=adjust_kwargs.get('wspace',None))
warnings.warn("horizontal_center did not converge")
def plotMatrix(hm,
outFileName,
colorMapDict={
'colorMap': ['binary'],
'missingDataColor': 'black',
'alpha': 1.0
},
plotTitle='',
xAxisLabel='',
yAxisLabel='',
regionsLabel='',
zMin=None,
zMax=None,
yMin=None,
yMax=None,
averageType='median',
reference_point_label='TSS',
startLabel='TSS',
endLabel="TES",
heatmapHeight=25,
heatmapWidth=7.5,
perGroup=False,
whatToShow='plot, heatmap and colorbar',
image_format=None,
legend_location='upper-left',
box_around_heatmaps=True,
label_rotation=0.0,
dpi=200,
interpolation_method='auto'):
hm.reference_point_label = reference_point_label
hm.startLabel = startLabel
hm.endLabel = endLabel
matrix_flatten = None
if zMin is None:
matrix_flatten = hm.matrix.flatten()
# try to avoid outliers by using np.percentile
zMin = np.percentile(matrix_flatten, 1.0)
if np.isnan(zMin):
zMin = [None]
else:
zMin = [zMin] # convert to list to support multiple entries
if zMax is None:
if matrix_flatten is None:
matrix_flatten = hm.matrix.flatten()
# try to avoid outliers by using np.percentile
zMax = np.percentile(matrix_flatten, 98.0)
if np.isnan(zMax) or zMax <= zMin[0]:
zMax = [None]
else:
zMax = [zMax]
if yMin is None:
yMin = [None]
if yMax is None:
yMax = [None]
if not isinstance(yMin, list):
yMin = [yMin]
if not isinstance(yMax, list):
yMax = [yMax]
plt.rcParams['font.size'] = 8.0
fontP = FontProperties()
showSummaryPlot = False
showColorbar = False
if whatToShow == 'plot and heatmap':
showSummaryPlot = True
elif whatToShow == 'heatmap and colorbar':
showColorbar = True
elif whatToShow == 'plot, heatmap and colorbar':
showSummaryPlot = True
showColorbar = True
# colormap for the heatmap
if colorMapDict['colorMap']:
cmap = []
for color_map in colorMapDict['colorMap']:
cmap.append(plt.get_cmap(color_map))
cmap[-1].set_bad(colorMapDict['missingDataColor']
) # nans are printed using this color
if colorMapDict['colorList'] and len(colorMapDict['colorList']) > 0:
# make a cmap for each color list given
cmap = []
for color_list in colorMapDict['colorList']:
cmap.append(
matplotlib.colors.LinearSegmentedColormap.from_list(
'my_cmap',
color_list.replace(' ', '').split(","),
N=colorMapDict['colorNumber']))
cmap[-1].set_bad(colorMapDict['missingDataColor']
) # nans are printed using this color
if len(cmap) > 1 or len(zMin) > 1 or len(zMax) > 1:
# position color bar below heatmap when more than one
# heatmap color is given
colorbar_position = 'below'
else:
colorbar_position = 'side'
grids = prepare_layout(hm.matrix, (heatmapWidth, heatmapHeight),
showSummaryPlot, showColorbar, perGroup,
colorbar_position)
# figsize: w,h tuple in inches
figwidth = heatmapWidth / 2.54
figheight = heatmapHeight / 2.54
if showSummaryPlot:
# the summary plot ocupies a height
# equal to the fig width
figheight += figwidth
numsamples = hm.matrix.get_num_samples()
if perGroup:
num_cols = hm.matrix.get_num_groups()
else:
num_cols = numsamples
total_figwidth = figwidth * num_cols
if showColorbar:
if colorbar_position == 'below':
figheight += 1 / 2.54
else:
total_figwidth += 1 / 2.54
fig = plt.figure(figsize=(total_figwidth, figheight))
fig.suptitle(plotTitle, y=1 - (0.06 / figheight))
# color map for the summary plot (profile) on top of the heatmap
cmap_plot = plt.get_cmap('jet')
numgroups = hm.matrix.get_num_groups()
if perGroup:
color_list = cmap_plot(
np.arange(hm.matrix.get_num_samples()) /
hm.matrix.get_num_samples())
else:
color_list = cmap_plot(np.arange(numgroups) / numgroups)
alpha = colorMapDict['alpha']
if image_format == 'plotly':
return plotlyMatrix(hm,
outFileName,
yMin=yMin,
yMax=yMax,
zMin=zMin,
zMax=zMax,
showSummaryPlot=showSummaryPlot,
showColorbar=showColorbar,
cmap=cmap,
colorList=color_list,
colorBarPosition=colorbar_position,
perGroup=perGroup,
averageType=averageType,
plotTitle=plotTitle,
xAxisLabel=xAxisLabel,
yAxisLabel=yAxisLabel,
label_rotation=label_rotation)
# check if matrix is reference-point based using the upstream >0 value
# and is sorted by region length. If this is
# the case, prepare the data to plot a border at the regions end
regions_length_in_bins = [None] * len(hm.parameters['upstream'])
if hm.matrix.sort_using == 'region_length' and hm.matrix.sort_method != 'no':
for idx in range(len(hm.parameters['upstream'])):
if hm.paramters['upstream'] > 0:
_regions = hm.matrix.get_regions()
foo = []
for _group in _regions:
_reg_len = []
for ind_reg in _group:
if isinstance(ind_reg, dict):
_len = ind_reg['end'] - ind_reg['start']
else:
_len = sum([x[1] - x[0] for x in ind_reg[1]])
_reg_len.append(
(hm.parameters['upstream'][idx] + _len) /
hm.parameters['bin size'][idx])
foo.append(_reg_len)
regions_length_in_bins[idx] = foo
# plot the profiles on top of the heatmaps
if showSummaryPlot:
if perGroup:
iterNum = numgroups
iterNum2 = hm.matrix.get_num_samples()
else:
iterNum = hm.matrix.get_num_samples()
iterNum2 = numgroups
ax_list = addProfilePlot(hm, plt, fig, grids, iterNum, iterNum2,
perGroup, averageType, yAxisLabel, color_list,
yMin, yMax, None, None, colorbar_position,
label_rotation)
if len(yMin) > 1 or len(yMax) > 1:
# replot with a tight layout
import matplotlib.tight_layout as tl
specList = tl.get_subplotspec_list(fig.axes, grid_spec=grids)
renderer = tl.get_renderer(fig)
kwargs = tl.get_tight_layout_figure(fig,
fig.axes,
specList,
renderer,
pad=1.08)
for ax in ax_list:
fig.delaxes(ax)
ax_list = addProfilePlot(hm, plt, fig, grids, iterNum, iterNum2,
perGroup, averageType, yAxisLabel,
color_list, yMin, yMax, kwargs['wspace'],
kwargs['hspace'], colorbar_position,
label_rotation)
if legend_location != 'none':
ax_list[-1].legend(loc=legend_location.replace('-', ' '),
ncol=1,
prop=fontP,
frameon=False,
markerscale=0.5)
first_group = 0 # helper variable to place the title per sample/group
for sample in range(hm.matrix.get_num_samples()):
sample_idx = sample
for group in range(numgroups):
group_idx = group
# add the respective profile to the
# summary plot
sub_matrix = hm.matrix.get_matrix(group, sample)
if showSummaryPlot:
if perGroup:
sample_idx = sample + 2 # plot + spacer
else:
group += 2 # plot + spacer
first_group = 1
if perGroup:
ax = fig.add_subplot(grids[sample_idx, group])
# the remainder (%) is used to iterate
# over the available color maps (cmap).
# if the user only provided, lets say two
# and there are 10 groups, colormaps they are reused every
# two groups.
cmap_idx = group_idx % len(cmap)
zmin_idx = group_idx % len(zMin)
zmax_idx = group_idx % len(zMax)
else:
ax = fig.add_subplot(grids[group, sample])
# see above for the use of '%'
cmap_idx = sample % len(cmap)
zmin_idx = sample % len(zMin)
zmax_idx = sample % len(zMax)
if group == first_group and not showSummaryPlot and not perGroup:
title = hm.matrix.sample_labels[sample]
ax.set_title(title)
if box_around_heatmaps is False:
# Turn off the boxes around the individual heatmaps
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
rows, cols = sub_matrix['matrix'].shape
# if the number of rows is too large, then the 'nearest' method simply
# drops rows. A better solution is to relate the threshold to the DPI of the image
if interpolation_method == 'auto':
if rows >= 1000:
interpolation_method = 'bilinear'
else:
interpolation_method = 'nearest'
# if np.clip is not used, then values of the matrix that exceed the zmax limit are
# highlighted. Usually, a significant amount of pixels are equal or above the zmax and
# the default behaviour produces images full of large highlighted dots.
# If interpolation='nearest' is used, this has no effect
sub_matrix['matrix'] = np.clip(sub_matrix['matrix'],
zMin[zmin_idx], zMax[zmax_idx])
img = ax.imshow(sub_matrix['matrix'],
aspect='auto',
interpolation=interpolation_method,
origin='upper',
vmin=zMin[zmin_idx],
vmax=zMax[zmax_idx],
cmap=cmap[cmap_idx],
alpha=alpha,
extent=[0, cols, rows, 0])
img.set_rasterized(True)
# plot border at the end of the regions
# if ordered by length
if regions_length_in_bins[sample] is not None:
x_lim = ax.get_xlim()
y_lim = ax.get_ylim()
ax.plot(regions_length_in_bins[sample][group_idx],
np.arange(
len(regions_length_in_bins[sample][group_idx])),
'--',
color='black',
linewidth=0.5,
dashes=(3, 2))
ax.set_xlim(x_lim)
ax.set_ylim(y_lim)
if perGroup:
ax.axes.set_xlabel(sub_matrix['group'])
if sample < hm.matrix.get_num_samples() - 1:
ax.axes.get_xaxis().set_visible(False)
else:
ax.axes.get_xaxis().set_visible(False)
ax.axes.set_xlabel(xAxisLabel)
ax.axes.set_yticks([])
if perGroup and group == 0:
ax.axes.set_ylabel(sub_matrix['sample'])
elif not perGroup and sample == 0:
ax.axes.set_ylabel(sub_matrix['group'])
# add labels to last block in a column
if (perGroup and sample == numsamples - 1) or \
(not perGroup and group_idx == numgroups - 1):
# add xticks to the bottom heatmap (last group)
ax.axes.get_xaxis().set_visible(True)
xticks_heat, xtickslabel_heat = hm.getTicks(sample)
if np.ceil(max(xticks_heat)) != float(
sub_matrix['matrix'].shape[1]):
tickscale = float(
sub_matrix['matrix'].shape[1]) / max(xticks_heat)
xticks_heat_use = [x * tickscale for x in xticks_heat]
ax.axes.set_xticks(xticks_heat_use)
else:
ax.axes.set_xticks(xticks_heat)
ax.axes.set_xticklabels(xtickslabel_heat, size=8)
# align the first and last label
# such that they don't fall off
# the heatmap sides
ticks = ax.xaxis.get_major_ticks()
ticks[0].label1.set_horizontalalignment('left')
ticks[-1].label1.set_horizontalalignment('right')
ax.get_xaxis().set_tick_params(which='both',
top='off',
direction='out')
if showColorbar and colorbar_position == 'below':
# draw a colormap per each heatmap below the last block
if perGroup:
col = group_idx
else:
col = sample
ax = fig.add_subplot(grids[-1, col])
tick_locator = ticker.MaxNLocator(nbins=3)
cbar = fig.colorbar(img,
cax=ax,
alpha=alpha,
orientation='horizontal',
ticks=tick_locator)
labels = cbar.ax.get_xticklabels()
ticks = cbar.ax.get_xticks()
if ticks[0] == 0:
# if the label is at the start of the colobar
# move it a bit inside to avoid overlapping
# with other labels
labels[0].set_horizontalalignment('left')
if ticks[-1] == 1:
# if the label is at the end of the colobar
# move it a bit inside to avoid overlapping
# with other labels
labels[-1].set_horizontalalignment('right')
# cbar.ax.set_xticklabels(labels, rotation=90)
if showColorbar and colorbar_position != 'below':
if showSummaryPlot:
# we don't want to colorbar to extend
# over the profiles and spacer top rows
grid_start = 2
else:
grid_start = 0
ax = fig.add_subplot(grids[grid_start:, -1])
fig.colorbar(img, cax=ax, alpha=alpha)
if box_around_heatmaps:
plt.subplots_adjust(wspace=0.10,
hspace=0.025,
top=0.85,
bottom=0,
left=0.04,
right=0.96)
else:
# When no box is plotted the space between heatmaps is reduced
plt.subplots_adjust(wspace=0.05,
hspace=0.01,
top=0.85,
bottom=0,
left=0.04,
right=0.96)
plt.savefig(outFileName,
bbox_inches='tight',
pdd_inches=0,
dpi=dpi,
format=image_format)
plt.close()
def plotMatrix(hm, outFileName,
colorMapDict={'colorMap': ['binary'], 'missingDataColor': 'black', 'alpha': 1.0},
plotTitle='',
xAxisLabel='', yAxisLabel='', regionsLabel='',
zMin=None, zMax=None,
yMin=None, yMax=None,
averageType='median',
reference_point_label='TSS',
startLabel='TSS', endLabel="TES",
heatmapHeight=25,
heatmapWidth=7.5,
perGroup=False, whatToShow='plot, heatmap and colorbar',
image_format=None,
legend_location='upper-left',
box_around_heatmaps=True,
dpi=200):
matrix_flatten = None
if zMin is None:
matrix_flatten = hm.matrix.flatten()
# try to avoid outliers by using np.percentile
zMin = np.percentile(matrix_flatten, 1.0)
if np.isnan(zMin):
zMin = [None]
else:
zMin = [zMin] # convert to list to support multiple entries
if zMax is None:
if matrix_flatten is None:
matrix_flatten = hm.matrix.flatten()
# try to avoid outliers by using np.percentile
zMax = np.percentile(matrix_flatten, 98.0)
if np.isnan(zMax) or zMax <= zMin[0]:
zMax = [None]
else:
zMax = [zMax]
if yMin is None:
yMin = [None]
if yMax is None:
yMax = [None]
if not isinstance(yMin, list):
yMin = [yMin]
if not isinstance(yMax, list):
yMax = [yMax]
plt.rcParams['font.size'] = 8.0
fontP = FontProperties()
showSummaryPlot = False
showColorbar = False
if whatToShow == 'plot and heatmap':
showSummaryPlot = True
elif whatToShow == 'heatmap and colorbar':
showColorbar = True
elif whatToShow == 'plot, heatmap and colorbar':
showSummaryPlot = True
showColorbar = True
# colormap for the heatmap
if colorMapDict['colorMap']:
cmap = []
for color_map in colorMapDict['colorMap']:
cmap.append(plt.get_cmap(color_map))
cmap[-1].set_bad(colorMapDict['missingDataColor']) # nans are printed using this color
if colorMapDict['colorList'] and len(colorMapDict['colorList']) > 0:
# make a cmap for each color list given
cmap = []
for color_list in colorMapDict['colorList']:
cmap.append(matplotlib.colors.LinearSegmentedColormap.from_list(
'my_cmap', color_list.replace(' ', '').split(","), N=colorMapDict['colorNumber']))
cmap[-1].set_bad(colorMapDict['missingDataColor']) # nans are printed using this color
if len(cmap) > 1 or len(zMin) > 1 or len(zMax) > 1:
# position color bar below heatmap when more than one
# heatmap color is given
colorbar_position = 'below'
else:
colorbar_position = 'side'
grids = prepare_layout(hm.matrix, (heatmapWidth, heatmapHeight),
showSummaryPlot, showColorbar, perGroup, colorbar_position)
# figsize: w,h tuple in inches
figwidth = heatmapWidth / 2.54
figheight = heatmapHeight / 2.54
if showSummaryPlot:
# the summary plot ocupies a height
# equal to the fig width
figheight += figwidth
numsamples = hm.matrix.get_num_samples()
if perGroup:
num_cols = hm.matrix.get_num_groups()
else:
num_cols = numsamples
total_figwidth = figwidth * num_cols
if showColorbar:
if colorbar_position == 'below':
figheight += 1 / 2.54
else:
total_figwidth += 1 / 2.54
fig = plt.figure(figsize=(total_figwidth, figheight))
xticks, xtickslabel = getProfileTicks(hm, reference_point_label, startLabel, endLabel)
xticks_heat, xtickslabel_heat = get_heatmap_ticks(hm, reference_point_label, startLabel, endLabel)
fig.suptitle(plotTitle, y=1 - (0.06 / figheight))
# color map for the summary plot (profile) on top of the heatmap
cmap_plot = plt.get_cmap('jet')
numgroups = hm.matrix.get_num_groups()
if perGroup:
color_list = cmap_plot(np.arange(hm.matrix.get_num_samples()) / hm.matrix.get_num_samples())
else:
color_list = cmap_plot(np.arange(numgroups) / numgroups)
alpha = colorMapDict['alpha']
# check if matrix is reference-point based using the upstream >0 value
# and is sorted by region length. If this is
# the case, prepare the data to plot a border at the regions end
if hm.parameters['upstream'] > 0 and \
hm.matrix.sort_using == 'region_length' and \
hm.matrix.sort_method != 'no':
_regions = hm.matrix.get_regions()
regions_length_in_bins = []
for _group in _regions:
_reg_len = []
for ind_reg in _group:
if isinstance(ind_reg, dict):
_len = ind_reg['end'] - ind_reg['start']
else:
_len = sum([x[1] - x[0] for x in ind_reg[1]])
_reg_len.append((hm.parameters['upstream'] + _len) / hm.parameters['bin size'])
regions_length_in_bins.append(_reg_len)
else:
regions_length_in_bins = None
# plot the profiles on top of the heatmaps
if showSummaryPlot:
if perGroup:
iterNum = numgroups
iterNum2 = hm.matrix.get_num_samples()
else:
iterNum = hm.matrix.get_num_samples()
iterNum2 = numgroups
ax_list = addProfilePlot(hm, plt, fig, grids, iterNum, iterNum2, perGroup, averageType, xticks, xtickslabel, yAxisLabel, color_list, yMin, yMax, None, None, colorbar_position)
if len(yMin) > 1 or len(yMax) > 1:
# replot with a tight layout
import matplotlib.tight_layout as tl
specList = tl.get_subplotspec_list(fig.axes, grid_spec=grids)
renderer = tl.get_renderer(fig)
kwargs = tl.get_tight_layout_figure(fig, fig.axes, specList, renderer, pad=1.08)
for ax in ax_list:
fig.delaxes(ax)
ax_list = addProfilePlot(hm, plt, fig, grids, iterNum, iterNum2, perGroup, averageType, xticks, xtickslabel, yAxisLabel, color_list, yMin, yMax, kwargs['wspace'], kwargs['hspace'], colorbar_position)
# reduce the number of yticks by half
num_ticks = len(ax_list[0].get_yticks())
yticks = [ax_list[0].get_yticks()[i] for i in range(1, num_ticks, 2)]
ax_list[0].set_yticks(yticks)
if legend_location != 'none':
ax_list[-1].legend(loc=legend_location.replace('-', ' '), ncol=1, prop=fontP,
frameon=False, markerscale=0.5)
first_group = 0 # helper variable to place the title per sample/group
for sample in range(hm.matrix.get_num_samples()):
sample_idx = sample
for group in range(numgroups):
group_idx = group
# add the respective profile to the
# summary plot
sub_matrix = hm.matrix.get_matrix(group, sample)
if showSummaryPlot:
if perGroup:
sample_idx = sample + 2 # plot + spacer
else:
group += 2 # plot + spacer
first_group = 1
if perGroup:
ax = fig.add_subplot(grids[sample_idx, group])
# the remainder (%) is used to iterate
# over the available color maps (cmap).
# if the user only provided, lets say two
# and there are 10 groups, colormaps they are reused every
# two groups.
cmap_idx = group_idx % len(cmap)
zmin_idx = group_idx % len(zMin)
zmax_idx = group_idx % len(zMax)
else:
ax = fig.add_subplot(grids[group, sample])
# see above for the use of '%'
cmap_idx = sample % len(cmap)
zmin_idx = sample % len(zMin)
zmax_idx = sample % len(zMax)
if group == first_group and not showSummaryPlot and not perGroup:
title = hm.matrix.sample_labels[sample]
ax.set_title(title)
if box_around_heatmaps is False:
# Turn off the boxes around the individual heatmaps
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
rows, cols = sub_matrix['matrix'].shape
interpolation_type = None if rows >= 1000 and cols >= 200 else 'nearest'
img = ax.imshow(sub_matrix['matrix'],
aspect='auto',
interpolation=interpolation_type,
origin='upper',
vmin=zMin[zmin_idx],
vmax=zMax[zmax_idx],
cmap=cmap[cmap_idx],
alpha=alpha,
extent=[0, cols, rows, 0])
img.set_rasterized(True)
# plot border at the end of the regions
# if ordered by length
if regions_length_in_bins is not None:
x_lim = ax.get_xlim()
y_lim = ax.get_ylim()
ax.plot(regions_length_in_bins[group_idx],
np.arange(len(regions_length_in_bins[group_idx])),
'--', color='black', linewidth=0.5, dashes=(3, 2))
ax.set_xlim(x_lim)
ax.set_ylim(y_lim)
if perGroup:
ax.axes.set_xlabel(sub_matrix['group'])
if sample < hm.matrix.get_num_samples() - 1:
ax.axes.get_xaxis().set_visible(False)
else:
ax.axes.get_xaxis().set_visible(False)
ax.axes.set_xlabel(xAxisLabel)
ax.axes.set_yticks([])
if perGroup and group == 0:
ax.axes.set_ylabel(sub_matrix['sample'])
elif not perGroup and sample == 0:
ax.axes.set_ylabel(sub_matrix['group'])
# add labels to last block in a column
if (perGroup and sample == numsamples - 1) or \
(not perGroup and group_idx == numgroups - 1):
# add xticks to the bottom heatmap (last group)
ax.axes.get_xaxis().set_visible(True)
if np.ceil(max(xticks_heat)) != float(sub_matrix['matrix'].shape[1]):
tickscale = float(sub_matrix['matrix'].shape[1]) / max(xticks_heat)
xticks_heat_use = [x * tickscale for x in xticks_heat]
ax.axes.set_xticks(xticks_heat_use)
else:
ax.axes.set_xticks(xticks_heat)
ax.axes.set_xticklabels(xtickslabel_heat, size=8)
# align the first and last label
# such that they don't fall off
# the heatmap sides
ticks = ax.xaxis.get_major_ticks()
ticks[0].label1.set_horizontalalignment('left')
ticks[-1].label1.set_horizontalalignment('right')
ax.get_xaxis().set_tick_params(
which='both',
top='off',
direction='out')
if showColorbar and colorbar_position == 'below':
# draw a colormap per each heatmap below the last block
if perGroup:
col = group_idx
else:
col = sample
ax = fig.add_subplot(grids[-1, col])
tick_locator = ticker.MaxNLocator(nbins=3)
cbar = fig.colorbar(img, cax=ax, alpha=alpha, orientation='horizontal', ticks=tick_locator)
labels = cbar.ax.get_xticklabels()
ticks = cbar.ax.get_xticks()
if ticks[0] == 0:
# if the label is at the start of the colobar
# move it a bit inside to avoid overlapping
# with other labels
labels[0].set_horizontalalignment('left')
if ticks[-1] == 1:
# if the label is at the end of the colobar
# move it a bit inside to avoid overlapping
# with other labels
labels[-1].set_horizontalalignment('right')
# cbar.ax.set_xticklabels(labels, rotation=90)
if showColorbar and colorbar_position != 'below':
if showSummaryPlot:
# we don't want to colorbar to extend
# over the profiles and spacer top rows
grid_start = 2
else:
grid_start = 0
ax = fig.add_subplot(grids[grid_start:, -1])
fig.colorbar(img, cax=ax, alpha=alpha)
if box_around_heatmaps:
plt.subplots_adjust(wspace=0.10, hspace=0.025, top=0.85, bottom=0, left=0.04, right=0.96)
else:
# When no box is plotted the space between heatmaps is reduced
plt.subplots_adjust(wspace=0.05, hspace=0.01, top=0.85, bottom=0, left=0.04, right=0.96)
plt.savefig(outFileName, bbox_inches='tight', pdd_inches=0, dpi=dpi, format=image_format)
plt.close()
def vertical_aspect(fig, aspect, ax_idx=0, pad=1.08,
nonoverlapping_extra_artists=[],
overlapping_extra_artists=[]):
"""Adjust figure height and vertical spacing so a sub-plot plotting area has
a specified aspect ratio and the overall figure has top/bottom margins from
tight_layout.
Parameters
----------
fig : Figure
The matplotlib figure object to be updated
aspect : float
The aspect ratio (W:H) desired for the subplot of ax_idx
ax_idx : int
The index (of fig.axes) for the axes to have the desired aspect ratio
pad : float
Padding between the edge of the figure and the axis labels, as a
multiple of font size
nonoverlapping_extra_artists : iterable of artists
Iterable of artists that should not overlap with the subplots but
should be accounted for in the layout; e.g., suptitle
overlapping_extra_artists : iterable of artists
Iterable of artists that may overlap with the subplots but should be
accounted for in the layout; e.g., legends
Returns
-------
i : int or float
The number of iterations to converge (be within one pixel by DPI) of the
desired aspect ratio or if it does not converge, the current aspect
ratio of the fig.axes[ax_idx]
Examples
--------
Plot some data and save it as a PNG. The height
>>> import mplpub
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.plot([1, 2, 3], [1, 4, 9])
>>> plt.ylabel('y axis')
>>> fig.set_size_inches(4, 1)
>>> mplpub.vertical_aspect(fig, mplpub.golden_ratio)
>>> fig.savefig('plot.png')
Plays well with subplots
>>> import mplpub
>>> import matplotlib.pyplot as plt
>>> plt.ion()
>>> fig = plt.figure()
>>> for spec in ((1,2,1), (2,2,2), (2,2,4)):
>>> plt.subplot(*spec)
>>> plt.plot([1, 2, 3], [1, 4, 9])
>>> plt.ylabel('y axis')
>>> fig.set_size_inches(8, 8)
>>> fig.suptitle("super title")
>>> print("center iter",mplpub.horizontal_center(fig))
The aspect ratio of any subplot can be set
>>> print("vert iter",mplpub.vertical_aspect(fig, 1, 1))
>>> print("vert iter",mplpub.vertical_aspect(fig, 0, 0.5))
"""
ax = fig.axes[ax_idx]
w, h = fig.get_size_inches()
nrows = get_subplotspec_list(fig.axes)[ax_idx].get_geometry()[0]
pad_inches = pad * FontProperties(
size=rcParams["font.size"]).get_size_in_points() / 144
non_overlapping_inches = {'top': 0, 'bottom': 0}
hspace = fig.subplotpars.hspace
for artist in nonoverlapping_extra_artists:
artist_bbox = TransformedBbox(
artist.get_window_extent(get_renderer(fig)),
fig.transFigure.inverted()
)
if artist_bbox.ymax < 0.5:
side = 'bottom'
else:
side = 'top'
non_overlapping_inches[side] += artist_bbox.height*h + pad_inches
for i in range(11):
overlapping_maxy = 0
overlapping_miny = 1
for artist in overlapping_extra_artists:
artist_bbox = TransformedBbox(
artist.get_window_extent(get_renderer(fig)),
fig.transFigure.inverted()
)
if artist_bbox.ymax > overlapping_maxy:
overlapping_maxy = artist_bbox.ymax
if artist_bbox.ymin < overlapping_miny:
overlapping_miny = artist_bbox.ymin
if overlapping_maxy > (1 - pad_inches/h):
overlapping_top_adjust_inches = overlapping_maxy*h - (h - pad_inches)
else:
overlapping_top_adjust_inches = 0
if overlapping_miny < pad_inches/h:
overlapping_bottom_adjust_inches = pad_inches - overlapping_miny*h
else:
overlapping_bottom_adjust_inches = 0
bbox = ax.get_position()
current_aspect = ((bbox.x1 - bbox.x0)*w)/((bbox.y1 - bbox.y0)*h)
aspect_diff = abs(current_aspect - aspect)*w * fig.get_dpi()
if ((aspect_diff*3.14159<1) and
(not overlapping_top_adjust_inches) and
(not overlapping_bottom_adjust_inches)):
return i
old_h = h
adjust_kwargs = get_tight_layout_figure(fig, fig.axes,
get_subplotspec_list(fig.axes), get_renderer(fig), pad=pad,
rect = (0,
(non_overlapping_inches['bottom']
+ overlapping_bottom_adjust_inches)/h,
1,
1 - (
non_overlapping_inches['top']
+ overlapping_top_adjust_inches
)/h)
)
tight_top_inches = (1-adjust_kwargs['top'])*old_h
tight_bottom_inches = adjust_kwargs['bottom']*old_h
hspace = adjust_kwargs.get('hspace',0)
h = ( bbox.width*w*(nrows + hspace*(nrows-1))/aspect +
(adjust_kwargs['bottom'] + 1 - adjust_kwargs['top'])*old_h +
overlapping_top_adjust_inches +
overlapping_bottom_adjust_inches +
non_overlapping_inches['top'] +
non_overlapping_inches['bottom'])
fig.set_size_inches((w, h))
fig.subplots_adjust(
top=1-(tight_top_inches)/h,
bottom=(tight_bottom_inches)/h,
hspace=adjust_kwargs.get('hspace',None)
)
warnings.warn("vertical_aspect did not converge")
return current_aspect