408 lines
13 KiB
Python
408 lines
13 KiB
Python
import cmocean as cmo
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
from cycler import cycler
|
|
from matplotlib.colors import ListedColormap
|
|
|
|
|
|
def PlotStyle() -> None:
|
|
class style:
|
|
|
|
# lightcmap = cmocean.tools.lighten(cmocean.cm.haline, 0.8)
|
|
|
|
# units
|
|
cm = 1 / 2.54
|
|
mm = 1 / 25.4
|
|
|
|
# colors
|
|
black = "#111116"
|
|
white = "#e0e4f7"
|
|
gray = "#6c6e7d"
|
|
blue = "#89b4fa"
|
|
sapphire = "#74c7ec"
|
|
sky = "#89dceb"
|
|
teal = "#94e2d5"
|
|
green = "#a6e3a1"
|
|
yellow = "#f9d67f"
|
|
orange = "#faa472"
|
|
maroon = "#eb8486"
|
|
red = "#f37588"
|
|
purple = "#d89bf7"
|
|
pink = "#f59edb"
|
|
lavender = "#b4befe"
|
|
gblue1 = "#89b4fa"
|
|
gblue2 = "#89dceb"
|
|
gblue3 = "#a6e3a1"
|
|
g = "#76a0fa"
|
|
|
|
@classmethod
|
|
def lims(cls, track1, track2):
|
|
"""Helper function to get frequency y axis limits from two
|
|
fundamental frequency tracks.
|
|
|
|
Args:
|
|
track1 (array): First track
|
|
track2 (array): Second track
|
|
start (int): Index for first value to be plotted
|
|
stop (int): Index for second value to be plotted
|
|
padding (int): Padding for the upper and lower limit
|
|
|
|
Returns:
|
|
lower (float): lower limit
|
|
upper (float): upper limit
|
|
|
|
"""
|
|
allfunds_tmp = (
|
|
np.concatenate(
|
|
[
|
|
track1,
|
|
track2,
|
|
]
|
|
)
|
|
.ravel()
|
|
.tolist()
|
|
)
|
|
lower = np.min(allfunds_tmp)
|
|
upper = np.max(allfunds_tmp)
|
|
return lower, upper
|
|
|
|
@classmethod
|
|
def circled_annotation(cls, text, axis, xpos, ypos, padding=0.25):
|
|
axis.text(
|
|
xpos,
|
|
ypos,
|
|
text,
|
|
ha="center",
|
|
va="center",
|
|
zorder=1000,
|
|
bbox=dict(
|
|
boxstyle=f"circle, pad={padding}", fc="white", ec="black", lw=1
|
|
),
|
|
)
|
|
|
|
@classmethod
|
|
def fade_cmap(cls, cmap):
|
|
|
|
my_cmap = cmap(np.arange(cmap.N))
|
|
my_cmap[:, -1] = np.linspace(0, 1, cmap.N)
|
|
my_cmap = ListedColormap(my_cmap)
|
|
|
|
return my_cmap
|
|
|
|
@classmethod
|
|
def hide_ax(cls, ax):
|
|
ax.xaxis.set_visible(False)
|
|
plt.setp(ax.spines.values(), visible=False)
|
|
ax.tick_params(left=False, labelleft=False)
|
|
ax.patch.set_visible(False)
|
|
|
|
@classmethod
|
|
def hide_xax(cls, ax):
|
|
ax.xaxis.set_visible(False)
|
|
ax.spines["bottom"].set_visible(False)
|
|
|
|
@classmethod
|
|
def hide_yax(cls, ax):
|
|
ax.yaxis.set_visible(False)
|
|
ax.spines["left"].set_visible(False)
|
|
|
|
@classmethod
|
|
def set_boxplot_color(cls, bp, color):
|
|
plt.setp(bp["boxes"], color=color)
|
|
plt.setp(bp["whiskers"], color=white)
|
|
plt.setp(bp["caps"], color=white)
|
|
plt.setp(bp["medians"], color=black)
|
|
|
|
@classmethod
|
|
def label_subplots(cls, labels, axes, fig):
|
|
for axis, label in zip(axes, labels):
|
|
X = axis.get_position().x0
|
|
Y = axis.get_position().y1
|
|
fig.text(X, Y, label, weight="bold")
|
|
|
|
@classmethod
|
|
def letter_subplots(
|
|
cls, axes=None, letters=None, xoffset=-0.1, yoffset=1.0, **kwargs
|
|
):
|
|
"""Add letters to the corners of subplots (panels). By default each axis is
|
|
given an uppercase bold letter label placed in the upper-left corner.
|
|
Args
|
|
axes : list of pyplot ax objects. default plt.gcf().axes.
|
|
letters : list of strings to use as labels, default ["A", "B", "C", ...]
|
|
xoffset, yoffset : positions of each label relative to plot frame
|
|
(default -0.1,1.0 = upper left margin). Can also be a list of
|
|
offsets, in which case it should be the same length as the number of
|
|
axes.
|
|
Other keyword arguments will be passed to annotate() when panel letters
|
|
are added.
|
|
Returns:
|
|
list of strings for each label added to the axes
|
|
Examples:
|
|
Defaults:
|
|
>>> fig, axes = plt.subplots(1,3)
|
|
>>> letter_subplots() # boldfaced A, B, C
|
|
|
|
Common labeling schemes inferred from the first letter:
|
|
>>> fig, axes = plt.subplots(1,4)
|
|
# panels labeled (a), (b), (c), (d)
|
|
>>> letter_subplots(letters='(a)')
|
|
Fully custom lettering:
|
|
>>> fig, axes = plt.subplots(2,1)
|
|
>>> letter_subplots(axes, letters=['(a.1)', '(b.2)'], fontweight='normal')
|
|
Per-axis offsets:
|
|
>>> fig, axes = plt.subplots(1,2)
|
|
>>> letter_subplots(axes, xoffset=[-0.1, -0.15])
|
|
|
|
Matrix of axes:
|
|
>>> fig, axes = plt.subplots(2,2, sharex=True, sharey=True)
|
|
# fig.axes is a list when axes is a 2x2 matrix
|
|
>>> letter_subplots(fig.axes)
|
|
"""
|
|
|
|
# get axes:
|
|
if axes is None:
|
|
axes = plt.gcf().axes
|
|
# handle single axes:
|
|
try:
|
|
iter(axes)
|
|
except TypeError:
|
|
axes = [axes]
|
|
|
|
# set up letter defaults (and corresponding fontweight):
|
|
fontweight = "bold"
|
|
ulets = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ"[: len(axes)])
|
|
llets = list("abcdefghijklmnopqrstuvwxyz"[: len(axes)])
|
|
if letters is None or letters == "A":
|
|
letters = ulets
|
|
elif letters == "(a)":
|
|
letters = ["({})".format(lett) for lett in llets]
|
|
fontweight = "normal"
|
|
elif letters == "(A)":
|
|
letters = ["({})".format(lett) for lett in ulets]
|
|
fontweight = "normal"
|
|
elif letters in ("lower", "lowercase", "a"):
|
|
letters = llets
|
|
|
|
# make sure there are x and y offsets for each ax in axes:
|
|
if isinstance(xoffset, (int, float)):
|
|
xoffset = [xoffset] * len(axes)
|
|
else:
|
|
assert len(xoffset) == len(axes)
|
|
if isinstance(yoffset, (int, float)):
|
|
yoffset = [yoffset] * len(axes)
|
|
else:
|
|
assert len(yoffset) == len(axes)
|
|
|
|
# defaults for annotate (kwargs is second so it can overwrite these defaults):
|
|
my_defaults = dict(
|
|
fontweight=fontweight,
|
|
fontsize="large",
|
|
ha="center",
|
|
va="center",
|
|
xycoords="axes fraction",
|
|
annotation_clip=False,
|
|
)
|
|
kwargs = dict(list(my_defaults.items()) + list(kwargs.items()))
|
|
|
|
list_txts = []
|
|
for ax, lbl, xoff, yoff in zip(axes, letters, xoffset, yoffset):
|
|
t = ax.annotate(lbl, xy=(xoff, yoff), **kwargs)
|
|
list_txts.append(t)
|
|
return list_txts
|
|
|
|
pass
|
|
|
|
# rcparams text setup
|
|
SMALL_SIZE = 12
|
|
MEDIUM_SIZE = 14
|
|
BIGGER_SIZE = 16
|
|
black = "#111116"
|
|
white = "#e0e4f7"
|
|
gray = "#6c6e7d"
|
|
dark_gray = "#2a2a32"
|
|
|
|
# rcparams
|
|
plt.rc("font", size=MEDIUM_SIZE) # controls default text sizes
|
|
plt.rc("axes", titlesize=MEDIUM_SIZE) # fontsize of the axes title
|
|
plt.rc("axes", labelsize=MEDIUM_SIZE) # fontsize of the x and y labels
|
|
plt.rc("xtick", labelsize=SMALL_SIZE) # fontsize of the tick labels
|
|
plt.rc("ytick", labelsize=SMALL_SIZE) # fontsize of the tick labels
|
|
plt.rc("legend", fontsize=SMALL_SIZE) # legend fontsize
|
|
plt.rc("figure", titlesize=BIGGER_SIZE) # fontsize of the figure title
|
|
|
|
plt.rcParams["image.cmap"] = "cmo.haline"
|
|
plt.rcParams["axes.xmargin"] = 0.05
|
|
plt.rcParams["axes.ymargin"] = 0.1
|
|
plt.rcParams["axes.titlelocation"] = "left"
|
|
plt.rcParams["axes.titlesize"] = BIGGER_SIZE
|
|
# plt.rcParams["axes.titlepad"] = -10
|
|
plt.rcParams["legend.frameon"] = False
|
|
plt.rcParams["legend.loc"] = "best"
|
|
plt.rcParams["legend.borderpad"] = 0.4
|
|
plt.rcParams["legend.facecolor"] = black
|
|
plt.rcParams["legend.edgecolor"] = black
|
|
plt.rcParams["legend.framealpha"] = 0.7
|
|
plt.rcParams["legend.borderaxespad"] = 0.5
|
|
plt.rcParams["legend.fancybox"] = False
|
|
|
|
# # specify the custom font to use
|
|
# plt.rcParams["font.family"] = "sans-serif"
|
|
# plt.rcParams["font.sans-serif"] = "Helvetica Now Text"
|
|
|
|
# dark mode modifications
|
|
plt.rcParams["boxplot.flierprops.color"] = white
|
|
plt.rcParams["boxplot.flierprops.markeredgecolor"] = gray
|
|
plt.rcParams["boxplot.boxprops.color"] = gray
|
|
plt.rcParams["boxplot.whiskerprops.color"] = gray
|
|
plt.rcParams["boxplot.capprops.color"] = gray
|
|
plt.rcParams["boxplot.medianprops.color"] = black
|
|
plt.rcParams["text.color"] = white
|
|
plt.rcParams["axes.facecolor"] = black # axes background color
|
|
plt.rcParams["axes.edgecolor"] = white # axes edge color
|
|
# plt.rcParams["axes.grid"] = True # display grid or not
|
|
# plt.rcParams["axes.grid.axis"] = "y" # which axis the grid is applied to
|
|
plt.rcParams["axes.labelcolor"] = white
|
|
plt.rcParams["axes.axisbelow"] = True # draw axis gridlines and ticks:
|
|
plt.rcParams["axes.spines.left"] = True # display axis spines
|
|
plt.rcParams["axes.spines.bottom"] = True
|
|
plt.rcParams["axes.spines.top"] = False
|
|
plt.rcParams["axes.spines.right"] = False
|
|
plt.rcParams["axes.prop_cycle"] = cycler(
|
|
"color",
|
|
[
|
|
"#b4befe",
|
|
"#89b4fa",
|
|
"#74c7ec",
|
|
"#89dceb",
|
|
"#94e2d5",
|
|
"#a6e3a1",
|
|
"#f9e2af",
|
|
"#fab387",
|
|
"#eba0ac",
|
|
"#f38ba8",
|
|
"#cba6f7",
|
|
"#f5c2e7",
|
|
],
|
|
)
|
|
plt.rcParams["xtick.color"] = white # color of the ticks
|
|
plt.rcParams["ytick.color"] = white # color of the ticks
|
|
plt.rcParams["grid.color"] = white # grid color
|
|
plt.rcParams["figure.facecolor"] = black # figure face color
|
|
plt.rcParams["figure.edgecolor"] = black # figure edge color
|
|
plt.rcParams["savefig.facecolor"] = black # figure face color when saving
|
|
|
|
return style
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
s = PlotStyle()
|
|
|
|
import matplotlib.cbook as cbook
|
|
import matplotlib.cm as cm
|
|
import matplotlib.pyplot as plt
|
|
from matplotlib.patches import PathPatch
|
|
from matplotlib.path import Path
|
|
|
|
# Fixing random state for reproducibility
|
|
np.random.seed(19680801)
|
|
|
|
delta = 0.025
|
|
x = y = np.arange(-3.0, 3.0, delta)
|
|
X, Y = np.meshgrid(x, y)
|
|
Z1 = np.exp(-(X**2) - Y**2)
|
|
Z2 = np.exp(-((X - 1) ** 2) - (Y - 1) ** 2)
|
|
Z = (Z1 - Z2) * 2
|
|
|
|
fig1, ax = plt.subplots()
|
|
im = ax.imshow(
|
|
Z,
|
|
interpolation="bilinear",
|
|
cmap=cm.RdYlGn,
|
|
origin="lower",
|
|
extent=[-3, 3, -3, 3],
|
|
vmax=abs(Z).max(),
|
|
vmin=-abs(Z).max(),
|
|
)
|
|
|
|
plt.show()
|
|
|
|
fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(9, 4))
|
|
|
|
# Fixing random state for reproducibility
|
|
np.random.seed(19680801)
|
|
|
|
# generate some random test data
|
|
all_data = [np.random.normal(0, std, 100) for std in range(6, 10)]
|
|
|
|
# plot violin plot
|
|
axs[0].violinplot(all_data, showmeans=False, showmedians=True)
|
|
axs[0].set_title("Violin plot")
|
|
|
|
# plot box plot
|
|
axs[1].boxplot(all_data)
|
|
axs[1].set_title("Box plot")
|
|
|
|
# adding horizontal grid lines
|
|
for ax in axs:
|
|
ax.yaxis.grid(True)
|
|
ax.set_xticks(
|
|
[y + 1 for y in range(len(all_data))], labels=["x1", "x2", "x3", "x4"]
|
|
)
|
|
ax.set_xlabel("Four separate samples")
|
|
ax.set_ylabel("Observed values")
|
|
|
|
plt.show()
|
|
|
|
# Fixing random state for reproducibility
|
|
np.random.seed(19680801)
|
|
|
|
# Compute pie slices
|
|
N = 20
|
|
theta = np.linspace(0.0, 2 * np.pi, N, endpoint=False)
|
|
radii = 10 * np.random.rand(N)
|
|
width = np.pi / 4 * np.random.rand(N)
|
|
colors = cmo.cm.haline(radii / 10.0)
|
|
|
|
ax = plt.subplot(projection="polar")
|
|
ax.bar(theta, radii, width=width, bottom=0.0, color=colors, alpha=0.5)
|
|
|
|
plt.show()
|
|
|
|
methods = [
|
|
None,
|
|
"none",
|
|
"nearest",
|
|
"bilinear",
|
|
"bicubic",
|
|
"spline16",
|
|
"spline36",
|
|
"hanning",
|
|
"hamming",
|
|
"hermite",
|
|
"kaiser",
|
|
"quadric",
|
|
"catrom",
|
|
"gaussian",
|
|
"bessel",
|
|
"mitchell",
|
|
"sinc",
|
|
"lanczos",
|
|
]
|
|
|
|
# Fixing random state for reproducibility
|
|
np.random.seed(19680801)
|
|
|
|
grid = np.random.rand(4, 4)
|
|
|
|
fig, axs = plt.subplots(
|
|
nrows=3, ncols=6, figsize=(9, 6), subplot_kw={"xticks": [], "yticks": []}
|
|
)
|
|
|
|
for ax, interp_method in zip(axs.flat, methods):
|
|
ax.imshow(grid, interpolation=interp_method)
|
|
ax.set_title(str(interp_method))
|
|
|
|
plt.tight_layout()
|
|
plt.show()
|