def test_hbox_divider():
arr1 = np.arange(20).reshape((4, 5))
arr2 = np.arange(20).reshape((5, 4))
fig, (ax1, ax2) = plt.subplots(1, 2)
ax1.imshow(arr1)
ax2.imshow(arr2)
pad = 0.5 # inches.
divider = HBoxDivider(
fig,
111, # Position of combined axes.
horizontal=[Size.AxesX(ax1),
Size.Fixed(pad),
Size.AxesX(ax2)],
vertical=[Size.AxesY(ax1),
Size.Scaled(1),
Size.AxesY(ax2)])
ax1.set_axes_locator(divider.new_locator(0))
ax2.set_axes_locator(divider.new_locator(2))
fig.canvas.draw()
p1 = ax1.get_position()
p2 = ax2.get_position()
assert p1.height == p2.height
assert p2.width / p1.width == pytest.approx((4 / 5)**2)
def make_heights_equal(fig, rect, ax1, ax2, pad):
# pad in inches
h1, v1 = Size.AxesX(ax1), Size.AxesY(ax1)
h2, v2 = Size.AxesX(ax2), Size.AxesY(ax2)
pad_v = Size.Scaled(1)
pad_h = Size.Fixed(pad)
def make_heights_equal(fig, rect, ax1, ax2, pad):
# pad in inches
divider = HBoxDivider(
fig,
rect,
horizontal=[Size.AxesX(ax1),
Size.Fixed(pad),
Size.AxesX(ax2)],
vertical=[Size.AxesY(ax1),
Size.Scaled(1),
Size.AxesY(ax2)])
ax1.set_axes_locator(divider.new_locator(0))
ax2.set_axes_locator(divider.new_locator(2))
def make_heights_equal(fig, rect, ax1, ax2, pad):
# pad in inches
h1, v1 = Size.AxesX(ax1), Size.AxesY(ax1)
h2, v2 = Size.AxesX(ax2), Size.AxesY(ax2)
pad_v = Size.Scaled(1)
pad_h = Size.Fixed(pad)
my_divider = HBoxDivider(fig, rect,
horizontal=[h1, pad_h, h2],
vertical=[v1, pad_v, v2])
ax1.set_axes_locator(my_divider.new_locator(0))
ax2.set_axes_locator(my_divider.new_locator(2))
def plot_anno_pred(anno_img, img, pred, save_path=None):
min_det_score = 0.5
boxes, scores = pred[:, :4].astype(np.int), pred[:, 4]
valid_idx = scores >= min_det_score
boxes = boxes[valid_idx]
scores = scores[valid_idx]
fig = plt.figure(figsize=(30, 15))
fig.add_subplot(121)
plt.imshow(anno_img[:, :, ::-1])
fig.add_subplot(122)
ax = plt.gca()
plt.imshow(img[:, :, ::-1])
# cmap=plt.cm.Wistia
cmap = plt.cm.spring
normal = plt.Normalize(0.5, max(scores))
colors = cmap(scores)
for box, c in zip(boxes, colors):
rect = patches.Rectangle(box[:2],
*box[2:],
linewidth=2,
edgecolor=c,
facecolor='none')
ax.add_patch(rect)
# cax, _ = cbar.make_axes(ax)
from mpl_toolkits.axes_grid1 import make_axes_locatable, axes_size
pad_fraction = 0.5
aspect = 20
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
cb2 = cbar.ColorbarBase(cax, cmap=cmap, norm=normal)
if save_path is not None:
fig.savefig(save_path, bbox_inches='tight', pad_inches=0, dpi=200)
def plot_weightmap(ax1,weightmap,name,title=False):
norm = np.size(weightmap)
cmap = mpl.cm.seismic
cmap.set_bad('k',1.)
im = np.log10(weightmap.T*norm)
pic = ax1.imshow(im,cmap=cmap, vmin=-2*np.nanmax(im),vmax=2*np.nanmax(im),
interpolation='nearest',origin='lower')
if title:
plt.title(r'TV-min Weightmap %s' % name)
# cbaraxes, kw = mpl.colorbar.make_axes(ax1,location='right',pad=0.01)
# plt.colorbar(pic,cax=cbaraxes)
# cbaraxes.yaxis.set_ticks_position('right')
aspect = 20
pad_fraction = 0.5
divider = make_axes_locatable(ax1)
width = axes_size.AxesY(ax1, aspect=1./aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
plt.colorbar(pic, cax=cax)
ax1.yaxis.set_ticks_position('left')
def _make_axes_grid(self):
self.axes = self._get_main_axes()
# Split up the current axes so there is space for start & stop buttons
self.divider = make_axes_locatable(self.axes)
pad = 0.01 # Padding between axes
pad_size = Size.Fraction(pad, Size.AxesX(self.axes))
large_pad_size = Size.Fraction(0.1, Size.AxesY(self.axes))
# Define size of useful axes cells, 50% each in x 20% for buttons in y.
small_x = Size.Fraction((1. - 2. * pad) / 10, Size.AxesX(self.axes))
ysize = Size.Fraction((1. - 2. * pad) / 15., Size.AxesY(self.axes))
button_grid = max((7, self.num_buttons))
# Set up grid, 3x3 with cells for padding.
if self.num_buttons > 0:
xsize = Size.Fraction((1. - 2. * pad) / button_grid,
Size.AxesX(self.axes))
horiz = [xsize] + [pad_size, xsize] * (button_grid - 1)
vert = [ysize, pad_size] * self.num_sliders + \
[large_pad_size, large_pad_size, Size.AxesY(self.axes)]
else:
vert = [ysize, large_pad_size] * self.num_sliders + \
[large_pad_size, Size.AxesY(self.axes)]
horiz = [Size.Fraction(0.1, Size.AxesX(self.axes))] + \
[Size.Fraction(0.05, Size.AxesX(self.axes))] + \
[Size.Fraction(0.65, Size.AxesX(self.axes))] + \
[Size.Fraction(0.1, Size.AxesX(self.axes))] + \
[Size.Fraction(0.1, Size.AxesX(self.axes))]
self.divider.set_horizontal(horiz)
self.divider.set_vertical(vert)
self.button_ny = len(vert) - 3
# If we are going to add a colorbar it'll need an axis next to the plot
if self.if_colorbar:
nx1 = -3
self.cax = self.fig.add_axes((0., 0., 0.141, 1.))
locator = self.divider.new_locator(nx=-2, ny=len(vert) - 1, nx1=-1)
self.cax.set_axes_locator(locator)
else:
# Main figure spans all horiz and is in the top (2) in vert.
nx1 = -1
self.axes.set_axes_locator(
self.divider.new_locator(nx=0, ny=len(vert) - 1, nx1=nx1))
def plot_correlations(ax1, ax2, fig, traces_cc, footprints_cc):
from mpl_toolkits.axes_grid1 import make_axes_locatable, axes_size
aspect = 20
pad_fraction = 0.5
# im1 = ax1.imshow(traces_cc, cmap='BuGn', clim=[0,1], interpolation = 'nearest')
# im1 = ax1.imshow(traces_cc, cmap='BuGn', interpolation = 'nearest')
im1 = ax1.imshow(traces_cc,
cmap='BrBG',
interpolation='nearest',
clim=[-1, 1])
divider = make_axes_locatable(ax1)
width = axes_size.AxesY(ax1, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax1 = divider.append_axes("right", size=width, pad=pad)
cbar = fig.colorbar(im1, ax=ax1, cax=cax1)
cbar.set_label('zero norm. cross-correlation')
ax1.set_xlabel('extracted traces')
ax1.set_ylabel('ground truth traces')
ax1.set_title('traces')
ax1.set_xticks([])
ax1.set_yticks([])
# im2 = ax2.imshow(footprints_cc, cmap='BuGn', clim=[0,1], interpolation = 'nearest')
im2 = ax2.imshow(footprints_cc,
cmap='BrBG',
interpolation='nearest',
clim=[-1, 1])
divider = make_axes_locatable(ax2)
width = axes_size.AxesY(ax2, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax2 = divider.append_axes("right", size=width, pad=pad)
cbar = fig.colorbar(im2, ax=ax2, cax=cax2)
cbar.set_label('zero norm. cross-correlation')
ax2.set_xlabel('extracted footprints')
ax2.set_ylabel('ground truth footprints')
ax2.set_title('footprints')
ax2.set_xticks([])
ax2.set_yticks([])
fig.tight_layout()
def plot_corrcoef(correlation_coefficient_matrix,
axes,
correlation_minimum=-1.,
correlation_maximum=1.,
colormap='bwr',
color_bar_aspect=20,
color_bar_padding_fraction=.5):
"""
Plots the cross-correlation matrix returned by
:py:func:`elephant.spike_train_correlation.corrcoef` function and adds a
color bar.
Parameters
----------
correlation_coefficient_matrix : np.ndarray
Pearson's correlation coefficient matrix
axes : object
Matplotlib figure Axes
correlation_minimum : float
minimum correlation for colour mapping. Default: -1
correlation_maximum : float
maximum correlation for colour mapping. Default: 1
colormap : str
colormap. Default: 'bwr'
color_bar_aspect : float
aspect ratio of the color bar. Default: 20
color_bar_padding_fraction : float
padding between matrix plot and color bar relative to color bar width.
Default: .5
Examples
--------
Create correlation coefficient matrix from Elephant `corrcoef` example
and save the result to `corrcoef_matrix`.
>>> import seaborn
>>> seaborn.set_style('ticks')
>>> fig, ax = plt.subplots(1, 1, subplot_kw={'aspect': 'equal'})
...
>>> plot_corrcoef(correlation_coefficient_matrix, axes=ax)
"""
image = axes.imshow(correlation_coefficient_matrix,
vmin=correlation_minimum,
vmax=correlation_maximum,
cmap=colormap)
# Initialise colour bar axis
divider = make_axes_locatable(axes)
width = axes_size.AxesY(axes, aspect=1. / color_bar_aspect)
pad = axes_size.Fraction(color_bar_padding_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
plt.colorbar(image, cax=cax)
def cbar(ax, aspect=20, pad_fraction=0.5, **cbar_kwargs):
from mpl_toolkits.axes_grid1 import make_axes_locatable, axes_size
from matplotlib.pyplot import colorbar
from matplotlib.colorbar import ColorbarBase
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
c = ColorbarBase(cax, **cbar_kwargs)
# c = colorbar(im, cax=cax, norm=norm, **cbar_kwargs)
return c
def plot_single_gwas_scatter(cur_ds, df_all_hg_pval, df_all_hg_size):
fig, ax = plt.subplots(figsize=(15, 15))
x = np.arange(len(df_all_hg_pval.columns))
y = np.arange(len(df_all_hg_pval.index))
xx, yy = zip(*[(a, b) for a in x for b in y
if df_all_hg_pval.iloc[b, a] != 0])
c = [
df_all_hg_pval.iloc[b, a] for a in x for b in y
if df_all_hg_pval.iloc[b, a] != 0
]
s = [
df_all_hg_size.iloc[b, a] for a in x for b in y
if df_all_hg_pval.iloc[b, a] != 0
]
s = np.array(s)
# im = plt.imshow(np.array(c).reshape(len(c), 1), cmap='bwr')
# im.remove()
sc = ax.scatter(xx,
yy,
s / float(max(s)) * 1000,
c=c,
cmap='bwr',
vmin=np.percentile(c, 10),
vmax=np.percentile(c, 90))
for s_i, a in enumerate(s):
ax.annotate("%.2f" % a, (xx[s_i], yy[s_i]))
ax.legend(loc='upper left')
ax.margins(0.03, 0.03)
# ax.locator_params(axis='x', nbins=len(df_all_hg_pval.columns))
# ax.locator_params(axis='y', nbins=len(df_all_hg_pval.index))
ax.set_xlabel("modules")
plt.subplots_adjust(left=0.25, right=0.99, top=0.99, bottom=0.05)
plt.xticks(np.arange(len(df_all_hg_pval.columns)),
tuple(list(df_all_hg_pval.columns.values)),
rotation='vertical')
ax.set_ylabel("GO terms")
plt.yticks(np.arange(len(df_all_hg_pval.index)),
tuple(list(df_all_hg_pval.index.values)))
ax_ = plt.gca()
aspect = 20
pad_fraction = 0.5
divider = make_axes_locatable(ax_)
width = axes_size.AxesY(ax_, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=0.3, pad=0.4)
plt.colorbar(mappable=sc, cax=cax)
plt.tight_layout()
plt.savefig(
os.path.join(constants.OUTPUT_GLOBAL_DIR,
"go_to_modules_{}.png".format(cur_ds)))
plt.cla()
def plot_grad_img(named_parameters, save_path):
r"""
Plot gardient of every layer for debugging.
Args:
named_parameters (layers):
save_path (string): Path to save the plots.
"""
# format names for better visualization
with sns.axes_style("whitegrid", {'axes.grid': False}):
aspect = 20
pad_fraction = 0.5
for n, p in named_parameters:
if (p.requires_grad) and ("bias" not in n):
fig, axs = plt.subplots(1, 2)
im = axs[0].imshow(p.abs().cpu().data.numpy())
weight_label = format2latex('$' + n + '_weight$')
axs[0].title.set_text(weight_label)
divider = make_axes_locatable(axs[0])
width = axes_size.AxesY(axs[0], aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
fig.colorbar(im, cax=cax, use_gridspec=True)
im = axs[1].imshow(p.grad.abs().cpu().data.numpy())
grad_label = format2latex('$' + n + '_grad$')
axs[1].title.set_text(grad_label)
divider = make_axes_locatable(axs[1])
width = axes_size.AxesY(axs[1], aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
fig.colorbar(im, cax=cax, use_gridspec=True)
fig.set_tight_layout(True)
plt.savefig(save_path + n + '.pdf')
plt.close()
def plot_anno_pred(anno_img, img, pred, save_path=None):
# plot_anno_pred(anno, img, pred, save_path=save_path)
min_det_score = 0.5 # 最低阈值
pred = np.array(pred)
boxes = pred[:, :, :3].astype(np.int) # 预测到的box
scores = pred[:, 4] # 预测到的分数
valid_idx = (scores >= min_det_score) # 判断有效框
print(valid_idx)
print(boxes)
boxes = boxes[valid_idx]
#scores = scores[valid_idx] # 获得有效框的box和分数
fig = plt.figure(figsize=(30, 15)) # 画图
fig.add_subplot(121) # 1，2，1 一行分成两列，第一个子图
#plt.imshow(anno_img[:,:,::-1]) # 接收标注图像 ::-1 倒序输出
fig.add_subplot(122) # 第二个子图
ax = plt.gca() # 挪动坐标轴
plt.imshow(img[:, :, ::-1]) # 接收原图像
# cmap=plt.cm.Wistia
cmap = plt.cm.spring # 获取不同的颜色color map
normal = plt.Normalize(min_det_score,
max(scores)) # 归一化[0,1]，最小值为最低阈值，最大值为score最大值
colors = cmap(scores) # 不同分数对应不同颜色
print(zip(boxes, colors))
print("#################")
for box, c in zip(boxes, colors): # 预测值化为了四个值+color
rect = patches.Rectangle(box[:2],
*box[2:],
linewidth=2,
edgecolor=c,
facecolor='none')
ax.add_patch(rect)
# cax, _ = cbar.make_axes(ax)
from mpl_toolkits.axes_grid1 import make_axes_locatable, axes_size
pad_fraction = 0.5
aspect = 20
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
cb2 = cbar.ColorbarBase(cax, cmap=cmap, norm=normal)
if save_path is not None:
fig.savefig(save_path, bbox_inches='tight', pad_inches=0, dpi=200)
def plot_fluxmap(ax1,image,name,title=False):
cmap = mpl.cm.hot
cmap.set_bad('k',1.)
im = np.log10(image)
pic = ax1.imshow(im,cmap=cmap, vmax=np.nanmax(im),
interpolation='nearest',origin='lower')
if title:
plt.title(r'%s Flux Map' % name)
aspect = 20
pad_fraction = 0.5
divider = make_axes_locatable(ax1)
width = axes_size.AxesY(ax1, aspect=1./aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("left", size=width, pad=pad)
plt.colorbar(pic, cax=cax)
ax1.yaxis.set_ticks_position('right')
cax.yaxis.set_ticks_position('left')
def add_controls(axes=None, slider=False):
""" Adds Start/Stop controls to an axes having been given a animation
instance. """
#If No axes specified use current axes.
if not axes:
axes = plt.gca()
fig = axes.get_figure()
#Split up the current axes so there is space for a start and a stop button
divider = make_axes_locatable(axes)
pad = 0.1 # Padding between axes
pad_size = Size.Fraction(pad, Size.AxesX(axes))
#Define size of usefult axes cells, 50% each in x 20% for buttons in y.
xsize = Size.Fraction((1. - 2. * pad) / 3., Size.AxesX(axes))
ysize = Size.Fraction((1. - 2. * pad) / 15., Size.AxesY(axes))
#Set up grid, 3x3 with cells for padding.
divider.set_horizontal([xsize, pad_size, xsize, pad_size, xsize])
if slider:
divider.set_vertical(
[ysize, pad_size, ysize, pad_size,
Size.AxesY(axes)])
bny = 2
else:
divider.set_vertical([ysize, pad_size, Size.AxesY(axes)])
bny = 0
#Main figure spans all horiz and is in the top (2) in vert.
axes.set_axes_locator(
divider.new_locator(0, len(divider.get_vertical()) - 1, nx1=-1))
#Add two axes for buttons and make them 50/50 spilt at the bottom.
bax1 = fig.add_axes((0., 0., 1., 1.))
locator = divider.new_locator(nx=0, ny=bny)
bax1.set_axes_locator(locator)
bax2 = fig.add_axes((0., 0., 0.8, 1.))
locator = divider.new_locator(nx=2, ny=bny)
bax2.set_axes_locator(locator)
bax3 = fig.add_axes((0., 0., 0.7, 1.))
locator = divider.new_locator(nx=4, ny=bny)
bax3.set_axes_locator(locator)
start = widgets.Button(bax1, "Start")
stop = widgets.Button(bax2, "Stop")
step = widgets.Button(bax3, "Step")
#Make dummy refernce to prevent garbage collection
bax1._button = start
bax2._button = stop
bax3._button = step
if slider:
bax4 = fig.add_axes((0., 0., 0.6, 1.))
locator = divider.new_locator(nx=0, ny=0, nx1=-1)
bax4.set_axes_locator(locator)
sframe = widgets.Slider(bax4, 'Frame', 0, 10, valinit=0, valfmt='%i')
bax4._slider = sframe
return axes, bax1, bax2, bax3, bax4
return axes, bax1, bax2, bax3
def userInput(ks_db, graphics, df, min_sub):
import io
from io import StringIO
import pandas as pd
import scipy.stats as st
import numpy as np
if graphics == "yes":
import matplotlib as mpl
mpl.use('Agg')
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import axes_size
from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable
from mpl_toolkits.axes_grid1.axes_size import AxesY, Fraction
from mpl_toolkits.axes_grid1.colorbar import colorbar
import seaborn as sns
# Function used to convert kinase z-scores to corresponding p-values.
# It is assmued z-scores are normally distributed.
def getpValue(z):
if z < 0:
p = st.norm.cdf(z)
return p
else:
dist = st.norm.cdf(z)
p = 1.0 - dist
return p
# Function to calculate the Z-score for each kinase.
def zScore(mean_kin, mean_all, sub_num, sd):
z = (mean_kin - mean_all) * sub_num**(1 / 2) / sd
return z
# Convert JSON-string datatset back into a DF.
f = pd.read_json(df, orient="split")
# User data is passed from the server and parsed as appropriate.
user_file = f.values.tolist()
header = f.columns.values.tolist()
col_length = len(header)
array = []
for line in user_file:
if line == "":
continue
else:
if "" not in line:
array.append(line)
kinase_dic = {}
dic = {}
ks_links = []
ks_info = []
pval_map = []
heatmap_array = []
zscore_info = []
z_columns = ["Kinase", "Sub.Count"]
ks_columns = ["Kinase", "Site", "Site.Seq(+/- 7AA)", "Source"]
heatmap_col = ["Kinase"]
# Columns 1 and onwards represent samples (e.g. cell lines).
# For the current column (sample) a set of operations is performed.
for col in range(1, col_length):
# Reset the values in each dictionary for a new column.
for key in dic:
dic[key] = []
for kin in kinase_dic:
kinase_dic[kin] = []
# Column names for relevant dataframes are created here dynamically.
# curr_col is current sample/column name.
curr_col = header[col]
z_columns.append("mnlog2(FC)." + curr_col)
z_columns.append("zSc." + curr_col)
z_columns.append("pVal." + curr_col)
ks_columns.append("log2(FC)." + curr_col)
heatmap_col.append(curr_col)
data = []
all_log2 = []
# Multiple phosphosites separated by a colon are split here.
# This ensures each phosphosite substrate and the log2(FC) value starts with a new line.
# This is ran for each sample in turn.
for n in range(0, len(array)):
site = array[n][0].upper()
fc = array[n][col]
site = site.split(";")
for s in site:
if s == '':
continue
else:
data.append([s, float(fc)])
# Mapping of phosphosite substrate keys to their (often multiple) log2(FCs) is achieved here.
for entry in data:
site = entry[0]
fc = entry[1]
if site not in dic:
dic[site] = [fc]
else:
dic[site].append(fc)
# If the same phosphosite has been detected more than once, its mean log2(FC) is calculated.
# Final dictionary contains unique phosphosites and individual log2(FC) values, averaged where appropriate.
for key in dic:
length = len(dic[key])
mean_fc = sum(dic[key]) / length
dic[key] = float(mean_fc)
# For each sample, the mean log2(FC) and standard deviation of all phosphosites in the dataset are calculated here. These values will be used to obtain a z-score for each identified kinase later on.
for key in dic:
all_log2.append(dic[key])
all_mean = sum(all_log2) / float(len(all_log2))
all_std = np.std(all_log2)
# Each phosphosite in the dictionary is scanned against the K-S db.
# If a match is found, relevant information for that phosphosite is retained.
# Scanning is only done for the first column.
if col == 1:
for x in dic:
for y in ks_db:
if x == y[0]:
# ks_links will be used to assign the current sample's log2(FCs) to each kinase later on.
ks_links.append([y[1], y[0], y[2], y[3], dic[x]])
# ks_info will contain kinase-substrate relationship info for each sample.
ks_info.append([y[1], y[0], y[2], y[3], dic[x]])
# Once the first column is passed, new log2(FCs) are removed and/or appended to the original arrays for each sample.
elif col > 1:
for s in ks_links:
s.remove(s[-1])
s.append(dic[s[1]])
for k in ks_info:
k.append(dic[k[1]])
# A dictionary containing unique kinases and substrate log2(FCs) is created.
# If the same kinase was identified for multiple substrates, multiple log2(FCs) are appended to the dictionary values.
for match in ks_links:
kinase = match[0]
log2fc = match[4]
if kinase not in kinase_dic:
kinase_dic[kinase] = [log2fc]
else:
kinase_dic[kinase].append(log2fc)
# The dictionary is used to calculate the number of substrates identified for each kinase.
# It also calculates the mean log2(FC) across each kinase's substrates.
# The algorithm then computes the z-score.
# A new array stores kinase gene, no. of substrates, mean log2(FC), z-score and p-value.
condition_ind = -1
index = -1
for key in kinase_dic:
index += 1
substrate_num = len(kinase_dic[key])
kin_fc_mean = sum(kinase_dic[key]) / float(substrate_num)
z_score = zScore(kin_fc_mean, all_mean, substrate_num, all_std)
z_pval = getpValue(z_score)
# For the heatmap, only z-scores for the kinases with the minimum substrate count specified by the user are extracted.
if substrate_num >= min_sub:
condition_ind += 1
if col == 1:
# An array of kinases and z-scores corresponding to multiple samples. Used for the heatmap.
heatmap_array.append([key, z_score])
# An array of p-values for each z-score across all samples. Used for heatmap annotation.
pval_map.append([z_pval])
else:
heatmap_array[condition_ind].append(z_score)
pval_map[condition_ind].append(z_pval)
if col == 1:
# KSEA results stored here.
zscore_info.append(
[key, substrate_num, kin_fc_mean, z_score, z_pval])
# If the program has gone past the first condition column, kin_fc_mean, z_score and zpval are appended in a repeating manner to the original array.
else:
zscore_info[index].append(kin_fc_mean)
zscore_info[index].append(z_score)
zscore_info[index].append(z_pval)
# p-values for the heatmap annotation are extracted from a nested list into a flat list.
pvalues = []
for entry in pval_map:
for pval in entry:
pvalues.append(pval)
# Score and kinase-substrate relationships DFs are generated.
zscore_df = pd.DataFrame(zscore_info, columns=z_columns)
ks_df = pd.DataFrame(ks_info, columns=ks_columns)
# Heatmap DFs for the heatmap generation.
heatmap_df = pd.DataFrame(heatmap_array, columns=heatmap_col)
heatmap_df = heatmap_df.set_index("Kinase")
# Heatmap only generated if the user chose to produce graphics during file upload.
if graphics == "no":
svg_fig = "Heatmap was not generated for this analysis."
elif graphics == "yes":
# Set the margins and square height for a single category.
topmargin = 0.1 #inches
bottommargin = 0.1 #inches
categorysize = 0.35 # inches
# Number of kinases identified.
n = len(heatmap_array)
leftmargin = 0.1
rightmargin = 0.1
catsize = 0.5
# Number of conditions (e.g. cell lines).
m = len(heatmap_col) - 1
# Parameters for color bar.
aspect = n
pad_fraction = 0.7
# Calculate a dynamic figure height.
figheight = topmargin + bottommargin + (n + 1) * categorysize
# Calculate a dynamic figure width.
figwidth = leftmargin + rightmargin + (m + 1) * catsize
fig, ax = plt.subplots(figsize=(figwidth, figheight))
# Format the axes.
ax.xaxis.set_ticks_position('top')
plt.yticks(fontsize=6)
plt.xticks(fontsize=6)
# Plot the heatmap.
ax = sns.heatmap(heatmap_df,
cmap='coolwarm',
annot=True,
fmt=".1f",
annot_kws={'size': 5},
cbar=False,
linewidths=0.3,
linecolor='white')
# Format the colour bar dynamically.
ax_div = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = ax_div.append_axes('right', size=width, pad=pad)
cb = plt.colorbar(ax.get_children()[0],
cax=cax,
orientation='vertical')
cax.yaxis.set_ticks_position('right')
cb.ax.tick_params(labelsize=6)
cb.set_label('Z-Score', fontsize=6, labelpad=7)
cb.outline.set_visible(False)
#Remove y-axis label.
ax.yaxis.set_label_text("")
# Rotate the axis labels.
for item in ax.get_yticklabels():
item.set_rotation(0)
for item in ax.get_xticklabels():
item.set_rotation(90)
# Annotate statistically significant scores with asterisks.
# * for p < 0.05 and ** for p < 0.01.
counter = -1
for text in ax.texts:
counter += 1
if pvalues[counter] < 0.05 and pvalues[counter] >= 0.01:
text.set_weight('bold')
text.set_text(text.get_text() + "*")
elif pvalues[counter] < 0.01:
text.set_weight('bold')
text.set_text(text.get_text() + "**")
# Create a StringIO object and use it to write SVG figure data to string buffer.
fig_file = StringIO()
fig.savefig(fig_file, format='svg', bbox_inches="tight")
# Seek beginning of the figure file.
fig_file.seek(0)
# Retrieve figure contents as a string.
svg_fig = '<svg' + fig_file.getvalue().split('<svg')[1]
# Free memory buffer.
fig_file.close()
# Convert results DFs into JSON strings.
zscore_df = zscore_df.to_json(orient='split')
ks_df = ks_df.to_json(orient='split')
return zscore_df, ks_df, svg_fig
def _ColorBar(self):
try:
if self.options.plot_type is not 0 and self.options.justvector is not 1:
try:
ax = plt.gca()
divider = make_axes_locatable(ax)
try:
if self.options.decimalcolorbar is not None:
decimal = '%.' + str(
self.options.decimalcolorbar) + 'f'
else:
decimal = None
except Exception as ex:
logging.info(
': Modulo Maps Functions : Error 012 : Failed to calculate decimacolorbar '
+ ex)
logging.shutdown()
sys.exit()
try:
aux = np.float(self.options.scalarMax -
self.options.scalarMin)
if self.options.LogMap == 1:
cba = plt.colorbar(self.pa)
else:
if self.options.colorbar == 1 or self.options.colorbar == 2:
try:
if self.options.scalarMin >= self.options.scalarMax:
logging.info(
': Modulo Maps Functions : Error 013a : Scalar ´Min is bigger then Max. '
+ ex)
logging.shutdown()
sys.exit()
except Exception as ex:
logging.info(
': Modulo Maps Functions : Error 013a : Scalar ´Min is bigger then Max. '
+ ex)
logging.shutdown()
sys.exit()
v2 = np.linspace(
self.options.scalarMin,
self.options.scalarMax,
round(
(aux / self.options.colorbarSpacing) +
1, 4))
if self.options.dynamic_limits == 1:
v2 = np.linspace(self.options.scalarMin,
self.options.scalarMax,
11)
if len(v2) > 200:
logging.info(
': Modulo Maps Functions : Error 013 : you requested more then 200 colorbar splits, please reduce'
)
logging.shutdown()
sys.exit()
if self.options.orientationcolorbar == 'horizontal':
width = axes_size.AxesX(ax, aspect=1 / 50)
pad = axes_size.Fraction(4, width)
cba = plt.colorbar(
selfpa,
ticks=v2,
extend='max',
spacing='proportional',
orientation='horizontal',
format=decimal)
elif self.options.orientationcolorbar == 'vertical':
width = axes_size.AxesY(ax, aspect=1 / 35)
pad = axes_size.Fraction(0.55, width)
if self.options.plot_type == 2:
divider = make_axes_locatable(ax)
cax = divider.append_axes("right",
size="5%",
pad=0.05)
cba = plt.colorbar(
self.pa,
cax=cax,
ticks=v2,
extend='max',
spacing='proportional',
orientation='vertical',
format=decimal)
elif self.options.plot_type == 1:
width = axes_size.AxesY(ax,
aspect=1 / 35)
pad = axes_size.Fraction(0.55, width)
cba = plt.colorbar(
self.pa,
cax=divider.append_axes("right",
size=0.085,
pad=pad),
ticks=v2,
extend='max',
spacing='proportional',
orientation='vertical',
format=decimal)
except Exception as ex:
logging.info(
': Modulo Maps Functions : Error 013 : Failed to calculate width, pad and cba from colorbar. '
+ ex)
logging.shutdown()
sys.exit()
try:
mpl.rcParams.update(
{'font.size': self.options.fontsize})
if self.options.legend is not None and self.options.colorbar != 0:
if self.options.plot_type == 2:
cba.set_label(self.options.legend,
fontsize=self.options.fontsize,
rotation=270,
labelpad=7)
for t in cba.ax.get_yticklabels():
t.set_horizontalalignment('right')
t.set_x(2.2)
else:
cba.set_label(self.options.legend,
fontsize=self.options.fontsize)
except Exception as ex:
logging.info(
': Modulo Maps Functions : Error 014 : Failed to draw colorbar title. '
+ ex)
logging.shutdown()
sys.exit()
except Exception as ex:
logging.info(
': Modulo Maps Functions : Error 015 : Failed inside colorbar manipulation '
)
logging.shutdown()
sys.exit()
return self
except Exception as ex:
logging.info(
': Modulo Maps Functions : Error 016 : Failed inside colorbar manipulation '
)
logging.shutdown()
sys.exit()
def plot_quant_aud_figure(weights,
sparse_weights,
rstrfs,
Y_mds,
t_pow_real,
t_pow_model,
t_pow_sparse,
save_path=None,
use_blobs=False):
fig = plt.figure(figsize=[10, 20])
gs = plt.GridSpec(200, 100)
pop_ax = np.empty((2, 3), dtype=object)
hist_ax = np.empty((2, 2), dtype=object)
mds_ax = fig.add_subplot(gs[:45, :45])
temp_ax = fig.add_subplot(gs[:45, 64:])
pop_ax[0, 0] = fig.add_subplot(gs[55:85, :30])
pop_ax[0, 1] = fig.add_subplot(gs[55:85, 35:65])
pop_ax[0, 2] = fig.add_subplot(gs[55:85, 70:])
hist_ax[0, 0] = fig.add_subplot(gs[95:110, :45])
hist_ax[0, 1] = fig.add_subplot(gs[95:110, 55:])
pop_ax[1, 0] = fig.add_subplot(gs[120:150, :30])
pop_ax[1, 1] = fig.add_subplot(gs[120:150, 35:65])
pop_ax[1, 2] = fig.add_subplot(gs[120:150, 70:])
hist_ax[1, 0] = fig.add_subplot(gs[160:175, :45])
hist_ax[1, 1] = fig.add_subplot(gs[160:175, 55:])
# gs.update(wspace=0.005, hspace=0.05) # set the spacing between axes.
labels = ['A1', 'predict', 'sparse', 'noise']
azure = '#006FFF'
clors = ['red', 'black', azure, 'y'] # markers = ['o', '_', '|']
markers = ['8', 'o', '^']
# mds_ax.set_axis_off()
# mds_ax.margins = [0,0]
mds_axlim = 20
mds_axes = plotting_funcs.plot_2D_projection_with_hists(Y_mds,
mds_ax,
labels=None,
clors=clors,
markers=markers)
mds_axes[0].set_xlim([-mds_axlim, mds_axlim])
mds_axes[0].set_ylim([-mds_axlim, mds_axlim])
for ax in mds_axes:
ax.set_xticks([])
ax.set_yticks([])
ax.set_axis_off()
ax = temp_ax
divider = make_axes_locatable(ax)
aspect = 4
pad_fraction = 0.05
width = axes_size.AxesY(ax, aspect=1 / aspect)
pad = axes_size.Fraction(pad_fraction, width)
dummy_ax_x = divider.append_axes("top", size=width, pad=0.1, sharex=ax)
# dummy_ax_y = divider.append_axes("right", size=width, pad=0.1, sharey=ax)
dummy_ax_x.set_axis_off()
# dummy_ax_y.set_axis_off()
if use_blobs:
markers = ['o', 'o', 'o']
else:
markers = ['blob', 'blob', 'blob']
t_plot_kwargs = {}
t_plot_kwargs['color'] = clors[0]
t_plot_kwargs['label'] = 'A1'
t_plot_kwargs['linewidth'] = 3
# ax.plot(real_measures.t_pow.mean(axis=0)/sum(real_measures.t_pow.mean(axis=0)),'o', **t_plot_kwargs )
# t_plot_kwargs['label']=''
ax.plot(t_pow_real, **t_plot_kwargs)
t_plot_kwargs = {}
t_plot_kwargs['color'] = clors[1]
t_plot_kwargs['label'] = 'prediction'
t_plot_kwargs['linewidth'] = 3
# ax.plot(res_pd.iloc[0].t_pow.mean(axis=0)[2:]/sum(res_pd.iloc[0].t_pow.mean(axis=0)[2:]),'_', **t_plot_kwargs)
# t_plot_kwargs['label']=''
ax.plot(t_pow_model, **t_plot_kwargs)
t_plot_kwargs['color'] = clors[2]
t_plot_kwargs['label'] = 'sparse'
t_plot_kwargs['linewidth'] = 3
# ax.plot(sparse_pd.iloc[11].t_pow.mean(axis=0)[2:]/sum(sparse_pd.iloc[11].t_pow.mean(axis=0)[2:]),'|', **t_plot_kwargs)
# t_plot_kwargs['label']=''
ax.plot(t_pow_sparse, **t_plot_kwargs)
handles, labels = ax.get_legend_handles_labels()
ax.legend(handles, labels)
temp_ax = ax
temp_ax.set_xticklabels(['-250', '-200', '-150', '-100', '-50', '0'])
temp_ax.set_ylabel('Proportion of power')
temp_ax.set_xlabel('Time (msec)')
[
mf_peak_pos, mf_peak_neg, mf_bw_pos, mf_bw_neg, mt_peak_pos,
mt_peak_neg, mt_bw_pos, mt_bw_neg, m_pow
] = quant.quantify_strfs(weights)
[
sf_peak_pos, sf_peak_neg, sf_bw_pos, sf_bw_neg, st_peak_pos,
st_peak_neg, st_bw_pos, st_bw_neg, s_pow
] = quant.quantify_strfs(sparse_weights)
[
rf_peak_pos, rf_peak_neg, rf_bw_pos, rf_bw_neg, rt_peak_pos,
rt_peak_neg, rt_bw_pos, rt_bw_neg, r_pow
] = quant.quantify_strfs(rstrfs, n_h=38)
mf_ix = [mf_bw_neg > 0] #and [mf_bw_pos>0]
rf_ix = [rf_bw_neg > 0] #and [rf_bw_pos>0]
mt_ix = [mt_bw_neg > 0] #and [mt_bw_pos>0]
rt_ix = [rt_bw_neg > 0] #and [rt_bw_pos>0]
sf_ix = [sf_bw_neg > 0] #and [mf_bw_pos>0]
st_ix = [st_bw_neg > 0] #and [mt_bw_pos>0]
print('Excluding units with 0 bw')
print('model proportion included: ')
print(np.sum(mt_ix[:]) / len(mt_ix[0]))
print('total: %i' % len(mt_ix[0]))
print('included: %i' % np.sum(mt_ix[:]))
print('excluded: %i' % (len(mt_ix[0]) - np.sum(mt_ix[:])))
print('sparse proportion included: ')
print(np.sum(st_ix[:]) / len(st_ix[0]))
print('total: %i' % len(st_ix[0]))
print('included: %i' % np.sum(st_ix[:]))
print('excluded: %i' % (len(st_ix[0]) - np.sum(st_ix[:])))
print('real proportion included: ')
print(np.sum(rt_ix[:]) / len(rt_ix[0]))
print('total: %i' % len(rt_ix[0]))
print('included: %i' % np.sum(rt_ix[:]))
print('excluded: %i' % (len(rt_ix[0]) - np.sum(rt_ix[:])))
mf_bw_pos = mf_bw_pos[mf_ix]
rf_bw_pos = rf_bw_pos[rf_ix]
sf_bw_pos = sf_bw_pos[sf_ix]
mt_bw_pos = mt_bw_pos[mt_ix]
rt_bw_pos = rt_bw_pos[rt_ix]
st_bw_pos = st_bw_pos[st_ix]
mf_bw_neg = mf_bw_neg[mf_ix]
rf_bw_neg = rf_bw_neg[rf_ix]
sf_bw_neg = sf_bw_neg[sf_ix]
mt_bw_neg = mt_bw_neg[mt_ix]
rt_bw_neg = rt_bw_neg[rt_ix]
st_bw_neg = st_bw_neg[st_ix]
xs = np.empty((2, 3), dtype=object)
ys = np.empty((2, 3), dtype=object)
xs[0, :] = [rt_bw_pos, mt_bw_pos, st_bw_pos]
ys[0, :] = [rt_bw_neg, mt_bw_neg, st_bw_neg]
xs[1, :] = [rf_bw_pos, mf_bw_pos, sf_bw_pos]
ys[1, :] = [rf_bw_neg, mf_bw_neg, sf_bw_neg]
lims = [225, 6]
#Make the scatter plots on the population axes
for ii in range(xs.shape[0]):
for jj, ax in enumerate(pop_ax[ii, :]):
x = xs[ii, jj]
y = ys[ii, jj]
clor = clors[jj] # '#444444'
if use_blobs:
pop_ax[ii, jj], _ = plotting_funcs.blobscatter(x,
y,
ax=ax,
**{
'facecolor':
'none',
'edgecolor':
clor
})
else:
ax.scatter(x, y)
plt_kwargs = {'color': 'k', 'linestyle': '--', 'alpha': 0.8}
pop_ax[ii, jj].plot(range(lims[ii] + 1), **plt_kwargs)
pop_ax[ii, jj].set_xlim([0, lims[ii]])
pop_ax[ii, jj].set_ylim([0, lims[ii]])
if ii == 0:
pop_ax[ii, jj].set_yticks([0, 50, 100, 150, 200])
pop_ax[ii, jj].set_xticks([0, 50, 100, 150, 200])
print('x or y>100', sum(np.logical_or(x > 100, y > 100)),
'out of ', len(x))
if ii == 1:
pop_ax[ii, jj].set_yticks([0, 2, 4, 6])
print('x or y>4', sum(np.logical_or(x > 4, y > 4)), 'out of ',
len(x))
if jj > 0:
# pop_ax[ii,jj].spines['left'].set_visible(False)
# pop_ax[ii,jj].set_yticks([])
pop_ax[ii, jj].set_yticklabels([])
inset_lims = [50, 1.5]
inset_ticks = [[25, 50], [0.75, 1.5]]
inset_binss = [np.arange(0.1, 50, 5), np.arange(0.05, 2, 0.15)]
#Make insets to show details on first two scatter plots
for ii in range(xs.shape[0]):
for jj, ax in enumerate(pop_ax[ii, :2]):
x = xs[ii, jj]
y = ys[ii, jj]
clor = clors[jj] # '#444444'
inset_axes_kwargs = {
'xlim': [0, inset_lims[ii]],
'ylim': [0, inset_lims[ii]],
'xticks': inset_ticks[ii],
'yticks': inset_ticks[ii]
}
inset_ax = inset_axes(
pop_ax[ii, jj],
width="40%", # width = 30% of parent_bbox
height="40%", # height : 1 inch
loc=1,
axes_kwargs=inset_axes_kwargs)
if use_blobs:
inset_ax, _ = plotting_funcs.blobscatter(x,
y,
ax=inset_ax,
**{
'facecolor':
'none',
'edgecolor': clor
})
else:
inset_ax.scatter(x, y)
# inset_ax.hist2d(x,y, bins=inset_binss[ii])
# plt_kwargs = {'color':'k', 'linestyle':'--', 'alpha':0.8}
# inset_ax.plot(range(lims[ii]+1), **plt_kwargs)
binss = [np.arange(-2.5, 200, 5), np.arange(0, 6, 0.15)]
#Make the scatter plots on the population axes
for ii in range(xs.shape[0]):
bins = binss[ii]
bincenters = 0.5 * (bins[1:] + bins[:-1])
for jj in range(xs.shape[1]):
clor = clors[jj]
plt_kwargs = {'color': clor, 'linestyle': '-', 'alpha': 0.8}
x = xs[ii, jj]
y = ys[ii, jj]
xx, binEdges = np.histogram(x, bins=bins)
yy, binEdges = np.histogram(y, bins=bins)
hist_ax[ii, 0].plot(bincenters, xx / sum(xx), **plt_kwargs)
hist_ax[ii, 1].plot(bincenters, yy / sum(yy), **plt_kwargs)
hist_ax[0, 0].set_yticks([0, 0.2, 0.4, 0.6, 0.8])
hist_ax[0, 1].set_yticks([0, 0.2, 0.4, 0.6, 0.8])
hist_ax[1, 0].set_yticks([0, 0.1, 0.2, 0.3, 0.4])
hist_ax[1, 1].set_yticks([0, 0.1, 0.2, 0.3, 0.4])
all_axes = fig.get_axes()
for ii, ax in enumerate(all_axes):
# 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')
pop_ax[0, 0].set_ylabel('Temporal span of inhibition (msec)')
pop_ax[0, 0].set_xlabel('Temporal span of excitation (msec)')
pop_ax[0, 1].set_xlabel('Temporal span of excitation (msec)')
pop_ax[0, 2].set_xlabel('Temporal span of excitation (msec)')
hist_ax[0, 0].set_xlabel('Temporal span of excitation (msec)')
hist_ax[0, 1].set_xlabel('Temporal span of inhibition (msec)')
hist_ax[0, 0].set_ylabel('Proportion of units')
pop_ax[1, 0].set_ylabel('Frequency span of inhibition (octave)')
pop_ax[1, 0].set_xlabel('Frequency span of excitation (octave)')
pop_ax[1, 1].set_xlabel('Frequency span of excitation (octave)')
pop_ax[1, 2].set_xlabel('Frequency span of excitation (octave)')
hist_ax[1, 0].set_xlabel('Frequency span of excitation (octave)')
hist_ax[1, 1].set_xlabel('Frequency span of inhibition (octave)')
hist_ax[1, 0].set_ylabel('Proportion of units')
hist_ax[0, 0].set_xticks([0, 50, 100, 150, 200])
hist_ax[0, 1].set_xticks([0, 50, 100, 150, 200])
if save_path is not None:
fig.savefig(os.path.join(save_path + '.svg'))
Green_trip_total_riverflux + gice_total_riverflux
#mld_avg=ahy_afil_total_riverflux*Maskout_only_Gr
mld_avg = np.ma.masked_where(mld_avg<=0.0,mld_avg)
mx=mld_avg.max()
mn=mld_avg.min()
clim=[mn, mx]
clim=[0.0, 2.0]
#clim=[0.2, 2.0]
P=bm.pcolormesh(xi,yi,mld_avg,cmap=cmap)
bm.drawcoastlines(linewidth=0.5)
#bm.fillcontinents(color='.8',lake_color='white')
#
aspect = 20
pad_fraction = 0.5
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1./aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
cb=ax.figure.colorbar(P,cax=cax,extend='both')
P.set_clim(clim)
ax.set_title('Total AEHYPE clim + Greenland(icemelt) + Greenland(TRIP) river flux')
fig.canvas.print_figure("Total_AEhype_GreenlandiceTrip_%03d.png"%(record+9))
ax.clear()
cb.remove()
xticks = np.arange(0,12)
xticklabels = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')
#
tripafil=1
if tripafil :
fig = plt.figure(figsize=(8,8))
def plot_2D_projection_with_hists(Y,
axScatter,
n_examples=100,
labels=None,
clors=None,
markers=None):
# create new axes on the right and on the top of the current axes.
divider = make_axes_locatable(axScatter)
aspect = 4
pad_fraction = 0.05
width = axes_size.AxesY(axScatter, aspect=1 / aspect)
pad = axes_size.Fraction(pad_fraction, width)
axHistx = divider.append_axes("top", size=width, pad=0.1, sharex=axScatter)
axHisty = divider.append_axes("right",
size=width,
pad=0.1,
sharey=axScatter)
lim = 20
binwidth = 1
bins = np.arange(-lim, lim + binwidth, binwidth)
linewidth = 3
bincenters = 0.5 * (bins[1:] + bins[:-1])
n_plots = int(Y.shape[0] / n_examples)
for ii in range(n_plots):
if labels is not None:
label = labels[ii]
else:
label = ''
if clors is not None:
clor = clors[ii]
else:
clor = np.random.rand(3, 1)
if markers is not None:
marker = markers[ii]
else:
marker = 'o'
alpha = 1
if marker == 'o' or marker == '^':
axScatter.scatter(Y[ii * n_examples:(ii + 1) * n_examples, 0],
Y[ii * n_examples:(ii + 1) * n_examples, 1],
edgecolor=clor,
facecolors='none',
marker=marker,
alpha=alpha,
label=label)
# elif marker == 'blob':
# print('using blob scttaer')
# plt_kwargs = {'edgecolor':clor, 'facecolors':'none', 'alpha':alpha, 'label':label}
# blobscatter(Y[ii*n_examples:(ii+1)*n_examples, 0], Y[ii*n_examples:(ii+1)*n_examples, 1], ax=axScatter, **plt_kwargs)
else:
axScatter.scatter(Y[ii * n_examples:(ii + 1) * n_examples, 0],
Y[ii * n_examples:(ii + 1) * n_examples, 1],
edgecolor=clor,
facecolors=clor,
marker=marker,
alpha=alpha,
label=label)
xx, binEdges = np.histogram(Y[ii * n_examples:(ii + 1) * n_examples,
0],
bins=bins,
density=1)
yy, binEdges = np.histogram(Y[ii * n_examples:(ii + 1) * n_examples,
1],
bins=bins,
density=1)
plt_kwargs = {'color': clor, 'linewidth': linewidth, 'alpha': alpha}
axHistx.plot(bincenters, xx, **plt_kwargs)
axHisty.plot(yy, bincenters, **plt_kwargs)
if labels is not None:
handles, labels = axScatter.get_legend_handles_labels()
axScatter.legend(handles, labels)
return [axScatter, axHistx, axHisty]
def plot_scatter_hist(x,
y,
axScatter,
bins,
hist_axes=None,
label=None,
clor=None,
marker='o',
alpha=1,
n_examples=None):
# create new axes on the right and on the top of the current axes.
if hist_axes is None:
divider = make_axes_locatable(axScatter)
aspect = 4
pad_fraction = 0.05
width = axes_size.AxesY(axScatter, aspect=1 / aspect)
pad = axes_size.Fraction(pad_fraction, width)
axHistx = divider.append_axes("top",
size=width,
pad=0.1,
sharex=axScatter)
axHisty = divider.append_axes("right",
size=width,
pad=0.1,
sharey=axScatter)
else:
axHistx = hist_axes[0]
axHisty = hist_axes[1]
linewidth = 3
bincenters = 0.5 * (bins[1:] + bins[:-1])
if n_examples is not None:
ix = np.arange(len(x))
random.shuffle(ix)
ix = ix[:n_examples]
else:
ix = np.arange(len(x))
binwidth = bins[1] - bins[0]
x_jitter = 0.5 * binwidth * (2 * np.random.rand(len(ix)) - 1)
y_jitter = 0.5 * binwidth * (2 * np.random.rand(len(ix)) - 1)
# x_jitter = 0
# y_jitter = 0
if marker == 'o':
axScatter.scatter(x[ix] + x_jitter,
y[ix] + y_jitter,
edgecolor=clor,
facecolors='none',
marker=marker,
alpha=alpha,
label=label)
# elif marker == 'blob':
# if clor == 'black' or clor == 'k':
# facecolors = clor
# else:
# facecolors = 'none'
# plt_kwargs = {'edgecolor':clor, 'facecolors':facecolors, 'marker':'o', 'alpha':alpha, 'label':label, 'linewidth':2}
# blobscatter(x, y, ax=axScatter, minsize=10*binwidth, **plt_kwargs)
else:
axScatter.scatter(x[ix] + x_jitter,
y[ix] + y_jitter,
edgecolor=clor,
facecolors=clor,
marker=marker,
alpha=alpha,
label=label)
xx, binEdges = np.histogram(x, bins=bins, density=1)
yy, binEdges = np.histogram(y, bins=bins, density=1)
plt_kwargs = {'color': clor, 'linewidth': linewidth, 'alpha': alpha}
axHistx.plot(bincenters, xx, **plt_kwargs)
axHisty.plot(yy, bincenters, **plt_kwargs)
return [axScatter, axHistx, axHisty]
def plotResolutionImage(file_name):
"""
Plots an image of the array with the energy resolution as a color for the solution
file (file_name).
Args:
file_name: the wavecal solution file including the path (string)
"""
wave_cal = tb.open_file(file_name, mode='r')
beamImage = wave_cal.root.header.beamMap.read()
wavelengths = wave_cal.root.header.wavelengths.read()[0]
calsoln = wave_cal.root.wavecal.calsoln.read()
wave_flag = calsoln["wave_flag"]
R0 = calsoln["R"]
R0[R0 == -1] = 0
rows = calsoln['pixel_row']
columns = calsoln['pixel_col']
wave_cal.close()
R = np.zeros((len(wavelengths) + 1, *beamImage.shape))
for pixel_ind, flag in enumerate(wave_flag):
# add good fits to the image
if flag == 4 or flag == 5:
row = rows[pixel_ind]
col = columns[pixel_ind]
for wave_ind, _ in enumerate(wavelengths):
R[wave_ind, row, col] = R0[pixel_ind, wave_ind]
R[-1, row, col] = 1
R = np.transpose(R, (0, 2, 1))
fig, ax = plt.subplots(figsize=(8, 8))
image = ax.imshow(R[0])
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1. / 20)
pad = axes_size.Fraction(0.5, width)
cax = divider.append_axes("right", size=width, pad=pad)
maximum = np.max(R)
cbar_ticks = np.linspace(0., maximum, num=11)
cbar = fig.colorbar(image, cax=cax, ticks=cbar_ticks)
cbar.set_clim(vmin=0, vmax=maximum)
cbar.draw_all()
plt.tight_layout()
plt.subplots_adjust(bottom=0.15)
position = ax.get_position()
middle = position.x0 + 3 * position.width / 4
ax_prev = plt.axes([middle - 0.18, 0.05, 0.15, 0.03])
ax_next = plt.axes([middle + 0.02, 0.05, 0.15, 0.03])
ax_slider = plt.axes([position.x0, 0.05, position.width / 2, 0.03])
class Index(object):
def __init__(self, ax_slider, ax_prev, ax_next):
self.ind = 0
self.num = len(wavelengths)
self.bnext = Button(ax_next, 'Next')
self.bnext.on_clicked(self.next)
self.bprev = Button(ax_prev, 'Previous')
self.bprev.on_clicked(self.prev)
self.slider = Slider(ax_slider,
"Energy Resolution: {:.2f} nm".format(
wavelengths[0]),
0,
self.num,
valinit=0,
valfmt='%d')
self.slider.valtext.set_visible(False)
self.slider.label.set_horizontalalignment('center')
self.slider.on_changed(self.update)
position = ax_slider.get_position()
self.slider.label.set_position((0.5, -0.5))
self.slider.valtext.set_position((0.5, -0.5))
def next(self, event):
i = (self.ind + 1) % (self.num + 1)
self.slider.set_val(i)
def prev(self, event):
i = (self.ind - 1) % (self.num + 1)
self.slider.set_val(i)
def update(self, i):
self.ind = int(i)
image.set_data(R[self.ind])
if self.ind != len(wavelengths):
self.slider.label.set_text(
"Energy Resolution: {:.2f} nm".format(
wavelengths[self.ind]))
else:
self.slider.label.set_text("Calibrated Pixels")
if self.ind != len(wavelengths):
number = 11
cbar.set_clim(vmin=0, vmax=maximum)
cbar_ticks = np.linspace(0.,
maximum,
num=number,
endpoint=True)
else:
number = 2
cbar.set_clim(vmin=0, vmax=1)
cbar_ticks = np.linspace(0., 1, num=number)
cbar.set_ticks(cbar_ticks)
cbar.draw_all()
plt.draw()
indexer = Index(ax_slider, ax_prev, ax_next)
plt.show(block=True)
# fontsize=mpl.rcParams['font.size'])
#plt.subplot(gs[12,0]).set_visible(False)
#plt.subplot(gs[11,0]).set_visible(False)
labeler = Labeler(xpad=.12, ypad=.01, fontsize=10)
vmin = 1e3
vmax = 1E7
#panel C
ax = plt.subplot(gs[0:12, 1])
im = count_cells(ax,sort_name,'cells', \
ylabel=True, vmax=vmax, vmin=vmin)
labeler.label_subplot(ax, 'C')
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1 / 30.)
pad = axes_size.Fraction(0.75, width)
cax = divider.append_axes("right", size=width, pad=pad)
#cax = fig.add_axes([0.92, 0.5375, 0.025, 0.4125])
cbar = fig.colorbar(im, cax=cax, orientation='vertical')
#cbar.set_label(r'number of sorted cells')
cbar.solids.set_rasterized(True)
# Panel D
ax = plt.subplot(gs[16:28, 1])
im = count_reads(ax, rep, 'reads', ylabel=True, vmax=vmax, vmin=vmin)
labeler.label_subplot(ax, 'D')
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1 / 30.)
pad = axes_size.Fraction(0.75, width)
def main(lon1,lat1,lon2,lat2,variable,files,filetype="archive",clim=None,sectionid="",
ijspace=False,xaxis="distance",section_map=False,ncfiles="",dpi=180) :
#TP4Grd='/cluster/work/users/aal069/TP4a0.12/mfile/'
logger.info("Filetype is %s"% filetype)
gfile = abf.ABFileGrid("regional.grid","r")
plon=gfile.read_field("plon")
plat=gfile.read_field("plat")
# Set up section info
if ijspace :
sec = gridxsec.SectionIJSpace([lon1,lon2],[lat1,lat2],plon,plat)
else :
sec = gridxsec.Section([lon1,lon2],[lat1,lat2],plon,plat)
I,J=sec.grid_indexes
dist=sec.distance
print('dit.shae=',dist.shape)
slon=sec.longitude
slat=sec.latitude
# In testing
#J,I,slon,slat,case,dist=sec.find_intersection(qlon,qlat)
#print I,J
#raise NameError,"test"
logger.info("Min max I-index (starts from 0):%d %d"%(I.min(),I.max()))
logger.info("Min max J-index (starts from 0):%d %d"%(J.min(),J.max()))
#
#
if section_map :
ll_lon=slon.min()-10.
ur_lon=slon.max()+10.
ll_lat=np.maximum(-90.,slat.min()-10.)
ur_lat=np.minimum(90. ,slat.max()+10.)
proj=ccrs.Stereographic(central_latitude=90.0,central_longitude=-40.0)
#pxy = proj.transform_points(ccrs.PlateCarree(), plon, plat)
#px=pxy[:,:,0]
#py=pxy[:,:,1]
#x,y=np.meshgrid(np.arange(slon.shape[0]),np.arange(slat.shape[0]))
figure =plt.figure(figsize=(8,8))
ax=figure.add_subplot(111,projection=proj)
#ax = plt.axes(projection=ccrs.PlateCarree())
ax.set_extent([-179, 179, 53, 85],ccrs.PlateCarree())
#ax = plt.axes(projection=ccrs.Stereographic())
ax.add_feature(cfeature.GSHHSFeature('auto', edgecolor='grey'))
ax.add_feature(cfeature.GSHHSFeature('auto', facecolor='grey'))
ax.gridlines()
#ax.coastlines(resolution='110m')
ax.plot(slon,slat,"r-",lw=1,transform=ccrs.PlateCarree())
pos = ax.get_position()
asp=pos.height/pos.width
w=figure.get_figwidth()
h=asp*w
figure.set_figheight(h)
if sectionid :
figure.canvas.print_figure("map_%s.png"%sectionid,dpi=dpi,bbox_inches='tight')
else :
figure.canvas.print_figure("map.png",dpi=dpi,bbox_inches='tight')
# Get layer thickness variable used in hycom
dpname = modeltools.hycom.layer_thickness_variable[filetype]
logger.info("Filetype %s: layer thickness variable is %s"%(filetype,dpname))
if xaxis == "distance" :
x=dist/1000.
xlab="Distance along section[km]"
elif xaxis == "i" :
x=I
xlab="i-index"
elif xaxis == "j" :
x=J
xlab="j-index"
elif xaxis == "lon" :
x=slon
xlab="longitude"
elif xaxis == "lat" :
x=slat
xlab="latitude"
else :
logger.warning("xaxis must be i,j,lo,lat or distance")
x=dist/1000.
xlab="Distance along section[km]"
# get kdm from the first file:
# Remove [ab] ending if present
print('firstfilw', files[0])
m=re.match("(.*)\.[ab]",files[0])
print('m=',m.group(1))
myf=m.group(1)
fi_abfile = abf.ABFileArchv(myf,"r")
kdm=max(fi_abfile.fieldlevels)
# Loop over archive files
figure = plt.figure()
ax=figure.add_subplot(111)
pos = ax.get_position()
count_sum=0
intfsec_sum=np.zeros((kdm+1,I.size))
datasec_sum=np.zeros((kdm+1,I.size))
for fcnt,myfile0 in enumerate(files) :
count_sum=count_sum+1
print('count_sum==', count_sum)
print('fcnt=', fcnt)
print('mfile0=', myfile0)
# Remove [ab] ending if present
m=re.match("(.*)\.[ab]",myfile0)
if m :
myfile=m.group(1)
else :
myfile=myfile0
# Add more filetypes if needed. By def we assume archive
if filetype == "archive" :
i_abfile = abf.ABFileArchv(myfile,"r")
elif filetype == "restart" :
i_abfile = abf.ABFileRestart(myfile,"r",idm=gfile.idm,jdm=gfile.jdm)
else :
raise NotImplementedError("Filetype %s not implemented"%filetype)
# kdm assumed to be max level in ab file
kdm=max(i_abfile.fieldlevels)
# Set up interface and daat arrays
xx=np.zeros((kdm+1,I.size))
intfsec=np.zeros((kdm+1,I.size))
datasec=np.zeros((kdm+1,I.size))
# Loop over layers in file.
logger.info("File %s"%(myfile))
for k in range(kdm) :
logger.debug("File %s, layer %03d/%03d"%(myfile,k,kdm))
# Get 2D fields
dp2d=i_abfile.read_field(dpname,k+1)
data2d=i_abfile.read_field(variable,k+1)
#print('---mn,mx data=', data2d.min(),data2d.max())
if (k%kdm==49):
print("---Reach bottom layer" )
dp2d=np.ma.filled(dp2d,0.)/modeltools.hycom.onem
data2d=np.ma.filled(data2d,1e30)
# Place data into section arrays
intfsec[k+1,:] = intfsec[k,:] + dp2d[J,I]
if k==0 : datasec[k,:] = data2d[J,I]
datasec[k+1,:] = data2d[J,I]
intfsec_sum=intfsec_sum + intfsec
datasec_sum=datasec_sum + datasec
#print 'prs_intafce=', np.transpose(intfsec[:,15])
i_abfile.close()
# end loop over files
intfsec_avg=intfsec_sum/count_sum
datasec_avg=datasec_sum/count_sum
if ncfiles :
MLDGS_sum=np.zeros((1,I.size))
count_sum=0
for fcnt,ncfile in enumerate(ncfiles) :
count_sum=count_sum+1
print('ncfile count_sum==', count_sum)
print('ncfile fcnt=', fcnt)
print('ncfilefile=', ncfile)
MLDGS=np.zeros((1,I.size))
ncfile0 = netCDF4.Dataset(ncfile,'r')
MLD_2D = ncfile0.variables['GS_MLD'][:]
#MLD_2D = ncfile0.variables['mlp'][:]
MLDGS[0,:]=MLD_2D[0,J,I]
MLDGS_sum= MLDGS_sum + MLDGS
ncfile0.close()
# end loop over files
MLDGS_avg=MLDGS_sum/count_sum
#
#-----------------------------------------------------------------
# read from clim mld TP5netcdf
if ncfiles :
if 'TP2' in files[0]:
fh=netCDF4.Dataset('mld_dr003_l3_modif_Interp_TP2grd.nc')
else:
fh=netCDF4.Dataset('mld_dr003_l3_modif_Interp_TP5grd.nc')
fhmldintrp = fh.variables['TP5mld'][:]
fh.close()
#fhMLDintrp_sum=np.zeros((760,800))
MLDclim_sum=np.zeros((1,I.size))
cunt_sum=0
for ii in range(12) :
cunt_sum=cunt_sum +1
MLDclim=np.zeros((1,I.size))
MLDclim[0,:]=fhmldintrp[ii,J,I]
MLDclim_sum= MLDclim_sum + MLDclim
print('clim count_sum==', cunt_sum)
MLDclim_avg=MLDclim_sum/cunt_sum
#-----------------------------------------------------------------
i_maxd=np.argmax(np.abs(intfsec_avg[kdm,:]))
#print i_maxd
for k in range(kdm+1) :
xx[k,:] = x[:]
# Set up section plot
#datasec = np.ma.masked_where(datasec==1e30,datasec)
datasec_avg = np.ma.masked_where(datasec_avg>0.5*1e30,datasec_avg)
#print datasec.min(),datasec.max()
#P=ax.pcolormesh(dist/1000.,-intfsec,datasec)
#print i_maxd
for k in range(kdm+1) :
xx[k,:] = x[:]
if clim is not None : lvls = MaxNLocator(nbins=30).tick_values(clim[0], clim[1])
#print 'levels=', lvls
mf='sawtooth_0-1.txt'
LinDic=mod_hyc2plot.cmap_dict(mf)
my_cmap = matplotlib.colors.LinearSegmentedColormap('my_colormap',LinDic)
cmap=my_cmap
#cmap = matplotlib.pyplot.get_cmap('gist_rainbow_r')
norm = BoundaryNorm(lvls, ncolors=cmap.N, clip=True)
print('x.shape=' , x.shape)
print('x.min,xmax=' , x.min(),x.max())
print('xx.shape=' , xx.shape)
print('xx.min,xxmax=' , xx.min(),xx.max())
print('intfsec_avg.shape=', intfsec_avg.shape)
print('datasec_avg.shape=', datasec_avg.shape)
#P=ax.pcolormesh(x,-intfsec,datasec,cmap=cmap)
P=ax.contourf(xx,-intfsec_avg,datasec_avg,extend='both',cmap=cmap,levels=lvls)
if 'sal' in variable:
P1=ax.contour(xx,-intfsec_avg,datasec_avg,levels=[32.0,33.0,34.0,35.0,35.5],
colors=('k',),linestyles=('-',),linewidths=(1.5,))
else:
P1=ax.contour(xx,-intfsec_avg,datasec_avg,levels=[-1,0.0,2.0],
colors=('k',),linestyles=('-',),linewidths=(1.5,))
matplotlib.pyplot.clabel(P1, fmt = '%2.1d', colors = 'k', fontsize=10) #contour line labels
# Plot layer interfaces
for k in range(1,kdm+1) :
if k%100 == 0 :
PL=ax.plot(x,-intfsec_avg[k,:],"-",color="k")
elif k%5 == 0 and k <= 10:
PL=ax.plot(x,-intfsec_avg[k,:],"--",color="k", linewidth=0.5)
textx = x[i_maxd]
texty = -0.5*(intfsec_avg[k-1,i_maxd] + intfsec_avg[k,i_maxd])
ax.text(textx,texty,str(k),verticalalignment="center",horizontalalignment="center",fontsize=6)
elif k%2 and k > 10 :
PL=ax.plot(x,-intfsec_avg[k,:],"--",color="k", linewidth=0.5)
textx = x[i_maxd]
texty = -0.5*(intfsec_avg[k-1,i_maxd] + intfsec_avg[k,i_maxd])
ax.text(textx,texty,str(k),verticalalignment="center",horizontalalignment="center",fontsize=6)
if ncfiles :
PL=ax.plot(x,-MLDGS_avg[0,:],"-",color="w", linewidth=1.50)
PL=ax.plot(x,-MLDclim_avg[0,:],"--",color="r", linewidth=1.50)
### else :
### PL=ax.plot(x,-intfsec_avg[k,:],"-",color=".5")
# Print figure and remove wite space.
aspect = 50
pad_fraction = 0.25
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1./aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
cb=ax.figure.colorbar(P,cax=cax,extend='both')
#cb=ax.figure.colorbar(P,extend='both')
if clim is not None : P.set_clim(clim)
#cb=ax.figure.colorbar(P,extend='both')
ax.set_title(variable+':'+myfile+'AVG-')
ax.set_ylabel('Depth [m]')
ax.set_xlabel(xlab)
#ax.set_position(pos)
#matplotlib.pyplot.tight_layout()
# Print in different y-lims
suff=os.path.basename(myfile)
if sectionid : suff=suff+"_"+sectionid
figure.canvas.print_figure("sec_AVG_%s_full_%s.png"%(variable,suff),dpi=dpi)
#ax.set_ylim(-1000,0)
if 'Fram' in sectionid or 'Svin' in sectionid:
print('sectionid=', sectionid)
ax.set_ylim(-600,0)
figure.canvas.print_figure("sec_AVG_%s_600m_%s.png"%(variable,suff),dpi=dpi)
else:
#ax.set_ylim(-2500,0)
#figure.canvas.print_figure("sec_AVG_%s_2500m_%s.png"%(variable,suff),dpi=dpi)
ax.set_ylim(-3000,0)
figure.canvas.print_figure("sec_AVG_%s_3000m_%s.png"%(variable,suff),dpi=dpi)
# Close input file
#i_abfile.close()
#
ax.clear()
cb.remove()
def align_colorbar(ax, aspect=20, pad_fraction=0.5):
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
return divider.append_axes('right', size=width, pad=pad)
import mpl_toolkits.axes_grid1.axes_size as Size
from mpl_toolkits.axes_grid1 import Divider
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(5.5, 4))
rect = (0.1, 0.1, 0.8, 0.8)
ax = [fig.add_axes(rect, label="%d" % i) for i in range(4)]
horiz = [Size.AxesX(ax[0]), Size.Fixed(.5), Size.AxesX(ax[1])]
vert = [Size.AxesY(ax[0]), Size.Fixed(.5), Size.AxesY(ax[2])]
divider = Divider(fig, rect, horiz, vert, aspect=False)
ax[0].set_axes_locator(divider.new_locator(nx=0, ny=0))
ax[1].set_axes_locator(divider.new_locator(nx=2, ny=0))
ax[2].set_axes_locator(divider.new_locator(nx=0, ny=2))
ax[3].set_axes_locator(divider.new_locator(nx=2, ny=2))
ax[0].set_xlim(0, 2)
ax[1].set_xlim(0, 1)
ax[0].set_ylim(0, 1)
ax[2].set_ylim(0, 2)
divider.set_aspect(1.)
for ax1 in ax:
ax1.tick_params(labelbottom=False, labelleft=False)
plt.show()
def draw_vibfreq_scatter_plot_n_overlap_matrix(name, engine, ref_eigvals, ref_eigvecs, freqs_rearr, normal_modes_rearr):
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import make_axes_locatable, axes_size
plt.switch_backend('agg')
fig, axs = plt.subplots(1,2, figsize=(10,6))
overlap_matrix = np.array([[(vib_overlap(engine, v1, v2)) for v2 in normal_modes_rearr] for v1 in ref_eigvecs])
qm_overlap_matrix = np.array([[(vib_overlap(engine,v1, v2)) for v2 in ref_eigvecs] for v1 in ref_eigvecs])
axs[0].scatter(ref_eigvals, freqs_rearr, label='MM vibrational frequencies(rearr.)')
axs[0].plot(ref_eigvals,ref_eigvals, 'k-')
axs[0].legend()
axs[0].set_xlabel(r'QM vibrational frequency ($cm^{-1}$)')
axs[0].set_ylabel(r'MM vibrational frequency ($cm^{-1}$)')
mae = np.sum(np.abs(ref_eigvals - freqs_rearr))/ len(ref_eigvals)
axs[0].set_title(f'QM vs. MM vibrational frequencies\n MAE= {mae:.2f}')
x0,x1 = axs[0].get_xlim()
y0,y1 = axs[0].get_ylim()
axs[0].set_aspect((x1-x0)/(y1-y0))
# move ax x axis to top
axs[1].xaxis.tick_top()
# move ax x ticks inside
axs[1].tick_params(axis="y", direction='in')
axs[1].tick_params(axis="x", direction='in')
# draw matrix
im = axs[1].imshow(overlap_matrix, cmap= 'OrRd', vmin=0,vmax=1)
# colorbar
aspect = 20
pad_fraction = 0.5
divider = make_axes_locatable(axs[1])
width = axes_size.AxesY(axs[1], aspect=1./aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
cax.yaxis.tick_right()
cax.xaxis.set_visible(False)
plt.colorbar(im, cax=cax)
corr_coef = cal_corr_coef(overlap_matrix)
err = np.linalg.norm(qm_overlap_matrix - overlap_matrix)/np.linalg.norm(qm_overlap_matrix) # measure of error in matrix (Relative error)
axs[1].set_title(f'QM vs. MM normal modes\n Correlation coef. ={corr_coef:.4f}, Error={err:.4f}')
# # move ax x axis to top
# axs[2].xaxis.tick_top()
# # move ax x ticks inside
# axs[2].tick_params(axis="y", direction='in')
# axs[2].tick_params(axis="x", direction='in')
# # draw matrix
# im = axs[2].imshow(qm_overlap_matrix, cmap= 'OrRd', vmin=0,vmax=1)
# # colorbar
# aspect = 20
# pad_fraction = 0.5
# divider = make_axes_locatable(axs[2])
# width = axes_size.AxesY(axs[2], aspect=1./aspect)
# pad = axes_size.Fraction(pad_fraction, width)
# cax = divider.append_axes("right", size=width, pad=pad)
# cax.yaxis.tick_right()
# cax.xaxis.set_visible(False)
# plt.colorbar(im, cax=cax)
# axs[2].set_title(f'(QM normal modes for reference)')
plt.tight_layout()
plt.subplots_adjust(top=0.85)
fig.suptitle('Hessian: iteration %i\nSystem: %s' % (Counter(), name))
fig.savefig('vibfreq_scatter_plot_n_overlap_matrix.pdf')
def plot_usa_daybyday_case_diffs(
states_df: pd.DataFrame,
*,
geo_df: geopandas.GeoDataFrame = None,
stage: Union[DiseaseStage, Literal[Select.ALL]],
count: Union[Counting, Literal[Select.ALL]],
dates: List[pd.Timestamp] = None,
) -> pd.DataFrame:
Counting.verify(count, allow_select=True)
DiseaseStage.verify(stage, allow_select=True)
if geo_df is None:
geo_df = get_geo_df()
DIFF_COL = "Diff_"
ASPECT_RATIO = 1 / 20
PAD_FRAC = 0.5
N_CBAR_BUCKETS = 6 # only used when bucketing colormap into discrete regions
N_BUCKETS_BTWN_MAJOR_TICKS = 1
N_MINOR_TICKS_BTWN_MAJOR_TICKS = 8 # major_1, minor_1, ..., minor_n, major_2
N_CBAR_MAJOR_TICKS = N_CBAR_BUCKETS // N_BUCKETS_BTWN_MAJOR_TICKS + 1
CMAP = cmocean.cm.matter
# CMAP = ListedColormap(cmocean.cm.matter(np.linspace(0, 1, N_CBAR_BUCKETS)))
DPI = 300
NOW_STR = datetime.now(timezone.utc).strftime(r"%b %-d, %Y at %H:%M UTC")
ID_COLS = [
Columns.TWO_LETTER_STATE_CODE,
Columns.DATE,
Columns.STAGE,
Columns.COUNT_TYPE,
]
save_fig_kwargs = {
"dpi": "figure",
"bbox_inches": "tight",
"facecolor": "w"
}
if count is Select.ALL:
count_list = list(Counting)
else:
count_list = [count]
if stage is Select.ALL:
stage_list = list(DiseaseStage)
else:
stage_list = [stage]
count_list: List[Counting]
stage_list: List[DiseaseStage]
if dates is None:
dates: List[pd.Timestamp] = states_df[Columns.DATE].unique()
dates = sorted(pd.Timestamp(date) for date in dates)
# Get day-by-day case diffs per location, date, stage, count-type
case_diffs_df = states_df[
(states_df[Columns.TWO_LETTER_STATE_CODE].isin(USA_STATE_CODES))
&
(~states_df[Columns.TWO_LETTER_STATE_CODE].isin(["AK", "HI"]))].copy()
# Make sure data exists for every date for every state so that the entire country is
# plotted each day; fill missing data with 0 (missing really *is* as good as 0)
state_date_stage_combos = pd.MultiIndex.from_product(
[
case_diffs_df[Columns.TWO_LETTER_STATE_CODE].unique(),
dates,
[s.name for s in DiseaseStage],
[c.name for c in Counting],
],
names=ID_COLS,
)
case_diffs_df = (state_date_stage_combos.to_frame(index=False).merge(
case_diffs_df,
how="left",
on=ID_COLS,
).sort_values(ID_COLS))
case_diffs_df[Columns.CASE_COUNT] = case_diffs_df[
Columns.CASE_COUNT].fillna(0)
case_diffs_df[DIFF_COL] = case_diffs_df.groupby(
[Columns.TWO_LETTER_STATE_CODE, Columns.STAGE,
Columns.COUNT_TYPE])[Columns.CASE_COUNT].diff()
case_diffs_df = case_diffs_df[case_diffs_df[DIFF_COL].notna()]
dates = case_diffs_df[Columns.DATE].unique()
vmins = {
Counting.TOTAL_CASES:
1,
Counting.PER_CAPITA:
case_diffs_df.loc[case_diffs_df[DIFF_COL] > 0, DIFF_COL].min(),
}
vmaxs = case_diffs_df.groupby([Columns.STAGE,
Columns.COUNT_TYPE])[DIFF_COL].max()
fig: plt.Figure = plt.figure(facecolor="white", dpi=DPI)
# Don't put too much stock in these, we tweak them later to make sure they're even
fig_width_px = len(count_list) * 1800
fig_height_px = len(stage_list) * 1000 + 200
max_date = max(dates)
# The order doesn't matter, but doing later dates first lets us see interesting
# output in Finder earlier, which is good for debugging
for date in reversed(dates):
date: pd.Timestamp = pd.Timestamp(date)
# Data is associated with the right endpoint of the data collection period,
# e.g., data collected *on* March 20 is labeled March 21 -- this is done so that
# data collected today (on the day the code is run) has a meaningful date
# associated with it (today's current time)
# Anyway, here we undo that and display data on the date it was collected
# in order to show a meaningful title on the graph
if date == date.normalize():
collection_date = date - pd.Timedelta(days=1)
else:
collection_date = date.normalize()
fig.suptitle(collection_date.strftime(r"%b %-d, %Y"))
for subplot_index, (stage, count) in enumerate(itertools.product(
stage_list, count_list),
start=1):
ax: plt.Axes = fig.add_subplot(len(stage_list), len(count_list),
subplot_index)
# Add timestamp to top right axis
if subplot_index == 2:
ax.text(
1.25, # Coords are arbitrary magic numbers
1.23,
f"Last updated {NOW_STR}",
horizontalalignment="right",
fontsize="small",
transform=ax.transAxes,
)
# Filter to just this axes: this stage, this count-type, this date
stage_date_df = case_diffs_df[
(case_diffs_df[Columns.STAGE] == stage.name)
& (case_diffs_df[Columns.COUNT_TYPE] == count.name)
& (case_diffs_df[Columns.DATE] == date)]
# Should have length 49 (50 + DC - AK - HI)
stage_geo_df: geopandas.GeoDataFrame = geo_df.merge(
stage_date_df,
how="inner",
left_on="STUSPS",
right_on=Columns.TWO_LETTER_STATE_CODE,
)
assert len(stage_geo_df) == 49
vmin = vmins[count]
vmax = vmaxs.loc[(stage.name, count.name)]
# Create log-scaled color mapping
# https://stackoverflow.com/a/43807666
norm = LogNorm(vmin, vmax)
scm = plt.cm.ScalarMappable(norm=norm, cmap=CMAP)
# Actually plot the data. Omit legend, since we'll want to customize it and
# it's easier to create a new one than customize the existing one.
stage_geo_df.plot(
column=DIFF_COL,
ax=ax,
legend=False,
vmin=vmin,
vmax=vmax,
cmap=CMAP,
norm=norm,
)
# Plot state boundaries
stage_geo_df.boundary.plot(ax=ax, linewidth=0.06, edgecolor="k")
# Add colorbar axes to right side of graph
# https://stackoverflow.com/a/33505522
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=ASPECT_RATIO)
pad = axes_size.Fraction(PAD_FRAC, width)
cax = divider.append_axes("right", size=width, pad=pad)
# Add colorbar itself
cbar = fig.colorbar(scm, cax=cax)
# Add evenly spaced ticks and their labels
# First major, then minor
# Adapted from https://stackoverflow.com/a/50314773
bucket_size = (vmax / vmin)**(1 / N_CBAR_BUCKETS)
tick_dist = bucket_size**N_BUCKETS_BTWN_MAJOR_TICKS
# Simple log scale math
major_tick_locs = (
vmin * (tick_dist**np.arange(0, N_CBAR_MAJOR_TICKS))
# * (bucket_size ** 0.5) # Use this if centering ticks on buckets
)
cbar.set_ticks(major_tick_locs)
# Get minor locs by linearly interpolating between major ticks
minor_tick_locs = []
for major_tick_index, this_major_tick in enumerate(
major_tick_locs[:-1]):
next_major_tick = major_tick_locs[major_tick_index + 1]
# Get minor ticks as numbers in range [this_major_tick, next_major_tick]
# and exclude the major ticks themselves (once we've used them to
# compute the minor tick locs)
minor_tick_locs.extend(
np.linspace(
this_major_tick,
next_major_tick,
N_MINOR_TICKS_BTWN_MAJOR_TICKS + 2,
)[1:-1])
cbar.ax.yaxis.set_ticks(minor_tick_locs, minor=True)
cbar.ax.yaxis.set_minor_formatter(NullFormatter())
# Add major tick labels
if count is Counting.PER_CAPITA:
fmt_func = "{:.2e}".format
else:
fmt_func = functools.partial(format_float,
max_digits=5,
decimal_penalty=2)
cbar.set_ticklabels(
[fmt_func(x) if x != 0 else "0" for x in major_tick_locs])
# Set axes titles
ax_stage_name: str = {
DiseaseStage.CONFIRMED: "Cases",
DiseaseStage.DEATH: "Deaths",
}[stage]
ax_title_components: List[str] = ["New Daily", ax_stage_name]
if count is Counting.PER_CAPITA:
ax_title_components.append("Per Capita")
ax.set_title(" ".join(ax_title_components))
# Remove axis ticks (I think they're lat/long but we don't need them)
for spine in [ax.xaxis, ax.yaxis]:
spine.set_major_locator(NullLocator())
spine.set_minor_locator(NullLocator())
# Save figure, and then deal with matplotlib weirdness that doesn't exactly
# respect the dimensions we set due to bbox_inches='tight'
save_path: Path = DOD_DIFF_DIR / f"dod_diff_{date.strftime(r'%Y%m%d')}.png"
fig.set_size_inches(fig_width_px / DPI, fig_height_px / DPI)
fig.savefig(save_path, **save_fig_kwargs)
# x264 video encoder requires frames have even width and height
resize_to_even_dims(save_path)
# Save poster (preview frame for video on web)
if date == max_date:
(GEO_FIG_DIR / "dod_diff_poster.png").write_bytes(
save_path.read_bytes())
fig.clf()
print(f"Saved '{save_path}'")
# if date < pd.Timestamp("2020-4-16"):
# break
return case_diffs_df
def main(lon1,
lat1,
lon2,
lat2,
variable,
files,
filetype="archive",
clim=None,
sectionid="",
ijspace=False,
xaxis="distance",
section_map=False,
dens=False,
dpi=180):
logger.info("Filetype is %s" % filetype)
gfile = abf.ABFileGrid("regional.grid", "r")
plon = gfile.read_field("plon")
plat = gfile.read_field("plat")
# Set up section info
if ijspace:
sec = gridxsec.SectionIJSpace([lon1, lon2], [lat1, lat2], plon, plat)
else:
sec = gridxsec.Section([lon1, lon2], [lat1, lat2], plon, plat)
I, J = sec.grid_indexes
dist = sec.distance
print('dit.shae=', dist.shape)
slon = sec.longitude
slat = sec.latitude
logger.info("Min max I-index (starts from 0):%d %d" % (I.min(), I.max()))
logger.info("Min max J-index (starts from 0):%d %d" % (J.min(), J.max()))
#
#
if section_map:
ll_lon = slon.min() - 10.
ur_lon = slon.max() + 10.
ll_lat = np.maximum(-90., slat.min() - 10.)
ur_lat = np.minimum(90., slat.max() + 10.)
proj = ccrs.Stereographic(central_latitude=90.0,
central_longitude=-40.0)
pxy = proj.transform_points(ccrs.PlateCarree(), plon, plat)
px = pxy[:, :, 0]
py = pxy[:, :, 1]
x, y = np.meshgrid(np.arange(slon.shape[0]), np.arange(slat.shape[0]))
figure = plt.figure(figsize=(10, 8))
ax = figure.add_subplot(111)
ax = plt.axes(projection=ccrs.PlateCarree())
ax.set_extent([-179, 179, 53, 85], ccrs.PlateCarree())
ax.add_feature(cfeature.GSHHSFeature('auto', edgecolor='grey'))
ax.add_feature(cfeature.GSHHSFeature('auto', facecolor='grey'))
ax.gridlines()
ax.plot(slon, slat, "r-", lw=1)
pos = ax.get_position()
asp = pos.height / pos.width
w = figure.get_figwidth()
h = asp * w
figure.set_figheight(h)
if sectionid:
figure.canvas.print_figure("map_%s.png" % sectionid, dpi=dpi)
else:
figure.canvas.print_figure("map.png", dpi=dpi)
# Get layer thickness variable used in hycom
dpname = modeltools.hycom.layer_thickness_variable[filetype]
logger.info("Filetype %s: layer thickness variable is %s" %
(filetype, dpname))
if xaxis == "distance":
x = dist / 1000.
xlab = "Distance along section[km]"
elif xaxis == "i":
x = I
xlab = "i-index"
elif xaxis == "j":
x = J
xlab = "j-index"
elif xaxis == "lon":
x = slon
xlab = "longitude"
elif xaxis == "lat":
x = slat
xlab = "latitude"
else:
logger.warning("xaxis must be i,j,lo,lat or distance")
x = dist / 1000.
xlab = "Distance along section[km]"
# Loop over archive files
figure = plt.figure()
ax = figure.add_subplot(111)
pos = ax.get_position()
for fcnt, myfile0 in enumerate(files):
# Remove [ab] ending if present
m = re.match("(.*)\.[ab]", myfile0)
if m:
myfile = m.group(1)
else:
myfile = myfile0
# Add more filetypes if needed. By def we assume archive
if filetype == "archive":
i_abfile = abf.ABFileArchv(myfile, "r")
elif filetype == "restart":
i_abfile = abf.ABFileRestart(myfile,
"r",
idm=gfile.idm,
jdm=gfile.jdm)
else:
raise NotImplementedError("Filetype %s not implemented" % filetype)
# kdm assumed to be max level in ab file
kdm = max(i_abfile.fieldlevels)
# Set up interface and daat arrays
xx = np.zeros((kdm + 1, I.size))
intfsec = np.zeros((kdm + 1, I.size))
datasec = np.zeros((kdm + 1, I.size))
if dens:
datasec_sal = np.zeros((kdm + 1, I.size))
sigma_sec = np.zeros((kdm + 1, I.size))
# Loop over layers in file.
logger.info("File %s" % (myfile))
for k in range(kdm):
logger.debug("File %s, layer %03d/%03d" % (myfile, k, kdm))
# Get 2D fields
dp2d = i_abfile.read_field(dpname, k + 1)
data2d = i_abfile.read_field(variable, k + 1)
dp2d = np.ma.filled(dp2d, 0.) / modeltools.hycom.onem
data2d = np.ma.filled(data2d, 1e30)
# Place data into section arrays
intfsec[k + 1, :] = intfsec[k, :] + dp2d[J, I]
if k == 0: datasec[k, :] = data2d[J, I]
datasec[k + 1, :] = data2d[J, I]
if dens:
data2d_sal = i_abfile.read_field('salin', k + 1)
data2d_sal = np.ma.filled(data2d_sal, 1e30)
datasec_sal[k + 1, :] = data2d_sal[J, I]
i_maxd = np.argmax(np.abs(intfsec[kdm, :]))
for k in range(kdm + 1):
xx[k, :] = x[:]
datasec = np.ma.masked_where(datasec > 0.5 * 1e30, datasec)
print("datasec min, max=", datasec.min(), datasec.max())
if dens:
datasec_sal = np.ma.masked_where(datasec_sal > 0.5 * 1e30,
datasec_sal)
print("datasec_sal min, max=", datasec_sal.min(),
datasec_sal.max())
sigma_sec = mod_hyc2plot.sig(datasec, datasec_sal)
sigma_sec = np.ma.masked_where(sigma_sec < 0.0, sigma_sec)
datasec = sigma_sec
# Set up section plot
datasec = np.ma.masked_where(datasec > 0.5 * 1e30, datasec)
print("min, max=", datasec.min(), datasec.max())
if clim is None:
clim = [datasec.min(), datasec.max()]
#clim=[0.0,13]
print("clim=", clim[0], clim[1])
if clim is not None:
lvls = MaxNLocator(nbins=70).tick_values(clim[0], clim[1])
mf = 'sawtooth_fc100.txt'
LinDic = mod_hyc2plot.cmap_dict(mf)
my_cmap = matplotlib.colors.LinearSegmentedColormap(
'my_colormap', LinDic)
cmap = my_cmap
norm = BoundaryNorm(lvls, ncolors=cmap.N, clip=True)
P = ax.contourf(xx, -intfsec, datasec, cmap=cmap, levels=lvls)
# Plot layer interfaces
for k in range(1, kdm + 1):
if k % 100 == 0:
PL = ax.plot(x, -intfsec[k, :], "-", color="k")
textx = x[i_maxd]
texty = -0.5 * (intfsec[k - 1, i_maxd] + intfsec[k, i_maxd])
ax.text(textx,
texty,
str(k),
verticalalignment="center",
horizontalalignment="center",
fontsize=6)
elif k % 5 == 0:
PL = ax.plot(x, -intfsec[k, :], "--", color="k", linewidth=0.5)
textx = x[i_maxd]
texty = -0.5 * (intfsec[k - 1, i_maxd] + intfsec[k, i_maxd])
ax.text(textx,
texty,
str(k),
verticalalignment="center",
horizontalalignment="center",
fontsize=6)
else:
if k > 2 and k % 2 == 0:
PL = ax.plot(x,
-intfsec[k, :],
"-",
color=".5",
linewidth=0.5)
textx = x[i_maxd]
texty = -0.5 * (intfsec[k - 1, i_maxd] +
intfsec[k, i_maxd])
ax.text(textx,
texty,
str(k),
verticalalignment="center",
horizontalalignment="center",
fontsize=6)
else:
continue
# Print figure
ax.set_facecolor('xkcd:gray')
aspect = 90
pad_fraction = 0.25
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
cb = ax.figure.colorbar(P, cax=cax)
if clim is not None: P.set_clim(clim)
if dens:
ax.set_title('[P. density ]: ' + myfile)
else:
ax.set_title('[' + variable + ']: ' + myfile)
ax.set_ylabel('Depth [m]')
ax.set_xlabel(xlab)
# Print in different y-lims
suff = os.path.basename(myfile)
if sectionid: suff = suff + "_" + sectionid
if dens: variable = "dens"
figure.canvas.print_figure("sec_%s_full_%s.png" % (variable, suff),
dpi=dpi)
ax.set_ylim(-1000, 0)
figure.canvas.print_figure("sec_%s_1000m_%s.png" % (variable, suff),
dpi=dpi)
# Close input file
i_abfile.close()
#
ax.clear()
cb.remove()
def main(args):
# pt_criterion = ChamfersDistance3()
img_criterion = nn.L1Loss(reduction="sum")
tsne = TSNE(n_components=2, init='pca', random_state=0)
modelist = ['5by20', '2by10']
#plt.style.use('ggplot')
'''
fig, ax = plt.subplots(figsize=(20, 20))
colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22']
plt.rcParams['axes.titlesize'] = 25
plt.rcParams['axes.titleweight'] = 'bold'
plt.rcParams['axes.labelsize'] = 24
for idx, mode in enumerate(modelist):
train_pt_mod = []
pred_pt_mod = []
train_img_mod = []
args.first_plot = False
if mode == '5by20':
sparselist = [1, 2, 3, 4, 5, 6, 7]
partition = 20*[0] + 20 *[1] + 20*[2] + 20*[3] + 20 *[4]
elif mode == '2by10':
sparselist = [1, 5, 10, 15, 20, 30, 35]
partition = 10*[0] + 10 *[1]
print(mode, partition)
test_json = 'test_interp_1000.json'
json_file = os.path.join(args.data_dir, test_json)
data_path = open(json_file, 'r')
testdata = json.load(data_path)
interp_list = []
for i in range(len(testdata)):
index_key_pair = (i, testdata[i]['shapekey_value'])
interp_list.append(index_key_pair)
interp_list.sort(key=lambda pair: pair[1])
for sparse in sparselist:
if mode == '5by20':
train_json = 'cluster_interp_5by20_%d.json'%sparse
results_dir = "../experiment/cubesphere_5by20_resnet/results_{}/final_vis".format(sparse)
similarity_dir = "../experiment/cubesphere_5by20_resnet/results_{}".format(sparse)
elif mode == '2by10':
train_json = 'cluster_samept_2by10_%d.json'%sparse
results_dir = "../experiment/cubesphere_2by10_resnet/results_{}/final_vis".format(sparse)
similarity_dir = "../experiment/cubesphere_2by10_resnet/results_{}".format(sparse)
results_name = 'fineptcloud_'
print('results_dir',results_dir)
print('similarity_dir',similarity_dir)
## If true, then load test results, compute distance matrix
## If false, then load distance matrix computed before
if args.first_plot:
gt_ptcloud, gt_image = load_gt(test_json, args.data_dir)
########pred_ptcloud, pred_image, _ , pred_codeword = load_pred(args.data_dir, results_dir, args.test_json)
#train_ptcloud, train_image = load_gt(train_json, args.data_dir)
#pred_ptcloud = load_predpts(results_path = results_dir, results_name = results_name, total_num = 200, origin_test_batch = 100)
#pred_ptcloud = torch.from_numpy(pred_ptcloud).float()
sorted_predptcloud = torch.zeros(len(testdata), 1024, 3)
sorted_gtptcloud = torch.zeros(len(testdata), 1024, 3)
for i in range(len(testdata)):
#sorted_predptcloud[i] = pred_ptcloud[interp_list[i][0]]
sorted_gtptcloud[i] = gt_ptcloud[interp_list[i][0]]
#train_ptcloud = train_ptcloud.cuda()
#sorted_predptcloud = sorted_predptcloud.cuda()
#train_image = train_image.cuda()
sorted_gtptcloud = sorted_gtptcloud.cuda()
pt_criterion = pt_criterion.cuda()
img_criterion = img_criterion.cuda()
train_pt_matrix = compute_squared_EDM_method(train_ptcloud, pt_criterion, True,
'%s_pt_similarity_matrix.npy'%'train', similarity_dir)
pred_pt_matrix = compute_squared_EDM_method(sorted_predptcloud, pt_criterion, True,
'%s_pt_similarity_matrix.npy'%'results', similarity_dir)
train_img_matrix = compute_squared_EDM_method(train_image, img_criterion, True,
'%s_img_similarity_matrix.npy'%'train', similarity_dir)
gt_pt_matrix = compute_squared_EDM_method(sorted_gtptcloud, pt_criterion, True,
'%s_pt_similarity_matrix.npy'%'gt', similarity_dir)
else:
#pred_ptcloud, pred_image, _ , pred_codeword = load_pred(args.data_dir, results_dir, args.test_json)
train_pt_matrix = np.load(os.path.join(similarity_dir, '%s_pt_similarity_matrix.npy'%'train'))
pred_pt_matrix = np.load(os.path.join(similarity_dir, '%s_pt_similarity_matrix.npy'%'results'))
train_img_matrix = np.load(os.path.join(similarity_dir, '%s_img_similarity_matrix.npy'%'train'))
gt_pt_matrix = np.load(os.path.join(similarity_dir, '%s_pt_similarity_matrix.npy'%'gt'))
## compute modularity
#gt_part = gt_partition(gt_pt_matrix)
pred_part = gt_partition(pred_pt_matrix)
train_pt_mod += [silhouette(train_pt_matrix, partition)]
train_img_mod += [silhouette(train_img_matrix, partition)]
#pred_pt_mod += [silhouette(pred_pt_matrix, gt_part)]
pred_pt_mod += [silhouette(pred_pt_matrix, pred_part)]
print(idx)
#############################################################################
################################################################################
################################################################################
########Visualtion of Sil... Score##############################
plt.subplot(2,2,1+idx*2)
for i in range(len(train_img_mod)):
plt.scatter(train_img_mod[i], pred_pt_mod[i], c = colors[i], s = 600,label = 'dataset index = {}'.format(i+1))
plt.plot(train_img_mod, pred_pt_mod, linewidth = 7, c= 'k')
if idx == 1:
plt.xlabel('Training Image Dataset Silhouette Score',labelpad = 25)
plt.ylabel('Predicted Point Cloud Results Silhouette Score',labelpad = 22)
plt.yticks(np.arange(0.25, 0.9, step=0.05))
#plt.xticks(np.arange(0.5, 1, step=0.1))
plt.legend(loc = 3, fontsize = 23)
if mode =='5by20':
plt.title('Subsampled dataset 1.1')
if mode =='2by10':
plt.title('Subsampled dataset 1.2')
plt.tick_params(labelsize=16)
for x, y in zip(train_img_mod, pred_pt_mod):
label = "index = {}".format()
plt.annotate(label, # this is the text
(x,y), # this is the point to label
textcoords="offset points", # how to position the text
xytext=(0,12), # distance from text to points (x,y)
ha='center',
fontsize=14,
fontname='sans')
plt.subplot(2,2,2+idx*2)
for i in range(len(train_pt_mod)):
plt.scatter(train_pt_mod[i], pred_pt_mod[i], c = colors[i], s = 600, label = 'dataset index = {}'.format(i+1))
plt.plot(train_pt_mod, pred_pt_mod, linewidth = 7, c= 'k')
if idx == 1:
plt.xlabel('Training Point Cloud Dataset Silhouette Score', labelpad = 25)
plt.yticks(np.arange(0.25, 0.9, step=0.05))
if mode =='5by20':
plt.title('Subsampled dataset 1.1')
if mode =='2by10':
plt.title('Subsampled dataset 1.2')
plt.legend(loc = 3, fontsize = 23)
plt.tick_params(labelsize=16)
plt.tight_layout()
plt.savefig('../img/cluster/sparse/cluster_score_method1.png')
'''
#############Visualization of Point cloud#####################################################
##############################################################################################
##############################################################################################
mode = '5by20'
# mode = '2by10'
if mode == '2by10':
sparselist = [1, 5, 10, 15, 20, 30, 35]
elif mode == '5by20':
sparselist = [1, 2, 3, 4, 5, 6, 7]
#fig.suptitle('Distance Matrices',fontsize=30,fontname="Times New Roman")
for row, sparse in enumerate(sparselist):
titles = [
"train_img_similarity_matrix", "train_pt_similarity_matrix",
"results_pt_similarity_matrix"
]
for col, title in enumerate(titles):
if mode == '5by20':
d = np.load(
"../experiment/cubesphere_5by20_resnet/results_{0}/{1}.npy"
.format(sparse, title))
elif mode == '2by10':
d = np.load(
"../experiment/cubesphere_2by10_resnet/results_{0}/{1}.npy"
.format(sparse, title))
print(np.max(np.max(d, axis=1)))
#plt.subplot(len(sparselist), 3, row * 3 + col + 1)
fig, ax = plt.subplots(figsize=(12, 12))
im = ax.imshow(d,
interpolation='nearest',
cmap=plt.cm.get_cmap("jet"))
# plt.imshow(d, interpolation='nearest', cmap=plt.cm.get_cmap("jet"))
# plt.xticks([])
# plt.yticks([])
ax.set_xticks([])
ax.set_yticks([])
aspect = 20
pad_fraction = 0.5
#plt.tight_layout()
if col == 0:
v = np.linspace(0, 8000, 10, endpoint=True)
# plt.clim(0, 8000)
# cb = plt.colorbar(ticks=v)
# cb = plt.colorbar(im,fraction=0.046, pad=0.04)
# cb.set_ticks([v])
# #np.arange(0, 8000, 2)
# plt.colorbar().ax.set_yticklabels(v,
# fontsize=16, weight='bold')
#plt.colorbar().ax.tick_params(labelsize =14)
# cb.ax.tick_params(labelsize=16)
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
cbar = plt.colorbar(im, cax=cax, ticks=v)
cbar.remove()
# cbar.ax.locator_params(nbins=4)
# # cbar.set_clim(0, 9000)
# # cbar.set_ticks([0, 3000, 6000])
# cbar.ax.tick_params(labelsize=16)
# cbar.set_ticklabels([0, 4000, 8000])
# plt.ylabel("dataset index = {0}".format(row+1), fontsize=45, labelpad = 30,fontweight ='bold',fontname="Times New Roman")
elif col == 1:
v = np.linspace(0, 0.45, 10, endpoint=True)
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
cbar = plt.colorbar(im, cax=cax, ticks=v)
cbar.remove()
# # cbar.set_ticks([0, 0.18, 0.36])
# cbar.ax.tick_params(labelsize=16)
# cbar.ax.locator_params(nbins=4)
# #plt.clim(0, 0.6) np.arange(0, 0.6, 2)
# # plt.colorbar().ax.set_yticklabels(v,
# # fontsize=16, weight='bold')
# #plt.colorbar().ax.tick_params(labelsize =14)
elif col == 2:
v = np.linspace(0, 0.45, 10, endpoint=True)
divider = make_axes_locatable(ax)
width = axes_size.AxesY(ax, aspect=1. / aspect)
pad = axes_size.Fraction(pad_fraction, width)
cax = divider.append_axes("right", size=width, pad=pad)
cbar = plt.colorbar(im, cax=cax, ticks=v) #, ticks=v)
cbar.remove()
# cbar.ax.locator_params(nbins=4)
# cbar.ax.tick_params(labelsize=16)
# #plt.clim(0, 0.6)np.arange(0, 0.6, 2)
# # plt.colorbar().ax.set_yticklabels(v,
# # fontsize=16, weight='bold')
# #plt.colorbar().ax.tick_params(labelsize =14)
'''
if row == 0 and col ==0:
plt.title('Training Image',fontsize=48, fontweight = 'bold', fontname="Times New Roman",pad=30)
if row == 0 and col ==1:
plt.title('Training Point Cloud',fontsize=48,fontweight = 'bold',fontname="Times New Roman",pad=30)
if row == 0 and col ==2:
plt.title('Predicted Point Cloud',fontsize=48,fontweight = 'bold',fontname="Times New Roman",pad=30)
'''
plt.savefig('cluster_{}_{}_{}.png'.format(mode, row + 1, col + 1),
bbox_inches='tight')
print("cluster-level higher means more separate clusters")
'''
