def get_roi(fig: plt.Figure, df: pd.DataFrame, params: dict) -> dict:
"""
use the drawn figure to extract the relevant data in order to build an animation
Parameters
----------
fig : plt.Figure
the figure to get data from.
df : pd.DataFrame
waves recording.
params : dict of parameters
Returns
-------
dict :
containing ylims, xlims(point, dtime and sec)
"""
ylims = tuple([_.get_ylim() for _ in fig.get_axes()])
# xlims
ax = fig.get_axes()[0]
if params["dtime"]:
dtime_lims = [pd.to_datetime(mdates.num2date(_)) for _ in ax.get_xlim()]
# remove timezone
dtime_lims = [_.tz_localize(None) for _ in dtime_lims]
i_lims = [
df.set_index("datetime").index.get_loc(_, method="nearest")
for _ in dtime_lims
]
else:
# index = sec
i_lims = [
df.set_index("sec").index.get_loc(_, method="nearest")
for _ in ax.get_xlim()
]
roidict = {}
for k, v in {"dt": "datetime", "pt": "point", "sec": "sec"}.items():
if v in df.columns:
lims = tuple([df.iloc[_][[v]].values[0] for _ in i_lims])
else:
# no dt values for televet
lims = (np.nan, np.nan)
roidict[k] = lims
print(f"{'-' * 10} defined a roi")
# append ylims and traces
roidict["ylims"] = ylims
return roidict
def plot_deeppoly(ele: deeppoly.Ele,
x_lim=(-1, 1),
y_lim=(-1, 1),
fig: plt.Figure = None):
lb = ele.lb().detach().numpy().squeeze()
ub = ele.ub().detach().numpy().squeeze()
step_size = 0.01
assert len(lb) == 2
h_bound_x = np.arange(lb[0], ub[0], step_size)
h_bound_y1 = np.full_like(h_bound_x, lb[1])
h_bound_y2 = np.full_like(h_bound_x, ub[1])
v_bound_y = np.arange(lb[1], ub[1], step_size)
v_bound_x1 = np.full_like(v_bound_y, lb[0])
v_bound_x2 = np.full_like(v_bound_y, ub[0])
if fig is None:
fig, ax = plt.subplots()
else:
ax = fig.get_axes()[0]
ax.set_xlim(x_lim)
ax.set_ylim(y_lim)
ax.grid(True)
ax.plot(h_bound_x, h_bound_y1, "r-", alpha=0.5)
ax.plot(h_bound_x, h_bound_y2, "r-", alpha=0.5)
ax.plot(v_bound_x1, v_bound_y, "r-", alpha=0.5)
ax.plot(v_bound_x2, v_bound_y, "r-", alpha=0.5)
ax.fill_between(h_bound_x, h_bound_y1, h_bound_y2, alpha=0.5)
return fig, ax
def plot_roc(roc: ROC,
title: str = "",
label: str = "",
show=False,
save=False,
fig: plt.Figure = None):
if fig is None:
fig = plt.figure()
ax = fig.add_axes([0.1, 0.1, 0.85, 0.8])
else:
ax = fig.get_axes()
assert len(ax) == 1
ax = ax[0]
lw = 2
fpr, tpr, _ = roc
ax.plot(fpr, tpr, lw=lw, label=label)
ax.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
ax.set(xlabel='FPR', ylabel='TPR', ylim=[0.0, 1.05], xlim=[0.0, 1.0])
ax.set_title(title, fontsize=15)
ax.legend(loc="lower right")
# fig.tight_layout()
if show:
fig.show()
if save:
fig.savefig(f'figs/{title}_{label}.png')
return fig
def set_figure_properties(fig: plt.Figure, **kwargs) -> None:
"""
Ease the configuration of a :class:`matplotlib.figure.Figure`.
Parameters
----------
fig : matplotlib.figure.Figure
The figure.
Keyword arguments
-----------------
fontsize : int
Font size to use for the plot titles, and axes ticks and labels.
Defaults to 12.
tight_layout : bool
`True` to fit the whole subplots into the figure area,
`False` otherwise. Defaults to `True`.
tight_layout_rect : Sequence[float]
A rectangle (left, bottom, right, top) in the normalized figure
coordinate that the whole subplots area (including labels) will
fit into. Defaults to (0, 0, 1, 1).
suptitle : str
The figure title. Defaults to an empty string.
xlabel : str
TODO
ylabel : str
TODO
figlegend_on : bool
TODO
figlegend_ax : int
TODO
figlegend_loc : `str` or `Tuple[float, float]`
TODO
figlegend_framealpha : float
TODO
figlegend_ncol : int
TODO
subplots_adjust_hspace : float
TODO
subplots_adjust_vspace : float
TODO
"""
fontsize = kwargs.get("fontsize", 12)
tight_layout = kwargs.get("tight_layout", True)
tight_layout_rect = kwargs.get("tight_layout_rect", (0, 0, 1, 1))
suptitle = kwargs.get("suptitle", "")
x_label = kwargs.get("x_label", "")
x_labelpad = kwargs.get("x_labelpad", 20)
y_label = kwargs.get("y_label", "")
y_labelpad = kwargs.get("y_labelpad", 20)
figlegend_on = kwargs.get("figlegend_on", False)
figlegend_ax = kwargs.get("figlegend_ax", 0)
figlegend_loc = kwargs.get("figlegend_loc", "lower center")
figlegend_framealpha = kwargs.get("figlegend_framealpha", 1.0)
figlegend_ncol = kwargs.get("figlegend_ncol", 1)
wspace = kwargs.get("subplots_adjust_wspace", None)
hspace = kwargs.get("subplots_adjust_hspace", None)
rcParams["font.size"] = fontsize
if suptitle is not None and suptitle != "":
fig.suptitle(suptitle, fontsize=fontsize + 1)
if x_label != "" or y_label != "":
ax = fig.add_subplot(111)
ax.set_frame_on(False)
ax.set_xticks([])
ax.set_xticklabels([], visible=False)
ax.set_yticks([])
ax.set_yticklabels([], visible=False)
if x_label != "":
ax.set_xlabel(x_label, labelpad=x_labelpad)
if y_label != "":
ax.set_ylabel(y_label, labelpad=y_labelpad)
if tight_layout:
fig.tight_layout(rect=tight_layout_rect)
if figlegend_on:
handles, labels = fig.get_axes()[figlegend_ax].get_legend_handles_labels()
fig.legend(
handles,
labels,
loc=figlegend_loc,
framealpha=figlegend_framealpha,
ncol=figlegend_ncol,
)
if wspace is not None:
fig.subplots_adjust(wspace=wspace)
if hspace is not None:
fig.subplots_adjust(hspace=hspace)
def append_beat(
beatdf: pd.DataFrame,
ekgdf: pd.DataFrame,
tochangedf: pd.DataFrame,
fig: plt.Figure,
lim: Tuple = None,
yscale: float = 1,
) -> pd.DataFrame:
"""
append a beat coordonate from the figure to the tochangedf['toAppend']
Parameters
----------
beatdf : pd.Dataframe
beat position (point based location : p_locs)
ekgdf : pd.Dataframe
waves data (wekg_lowpass).
tochangedf : pd.Dataframe
the beat to add or remove (point based toAppend & toRemove)
fig : plt.Figure
the figure to get the location.
lim : TYPE, optional (default is None)
ptBasedLim optional to give it manually
yscale : TYPE, optional (default is 1)
amplitude mutliplication factor for detection.
Returns
-------
tochangedf : pd.DataFrame
incremented changedf (pt location).
methods :
locate the beat in the figure, append to a dataframe['toAppend']
0.: if not present : build a dataframe:
>>> to_change_df = pd.DataFrame(columns=['toAppend', 'toRemove'])
1.: locate the extra beat in the figure (cf plot_beats())
and zoom to observe only a negative peak
2.: call the function:
>>> to_change_df = remove_beat(beatdf, ekgdf, tochangedf, fig)
-> the beat parameters will be added the dataFrame
.in the end of the manual check, update the beat_df
- first : save beat_df and to_change_df
- second : run:
>>> beat_df = update_beat_df())
"""
# find the limits of the figure
if lim is None:
lims = fig.get_axes()[0].get_xlim()
lim = (int(lims[0]), int(lims[1]))
# restrict area around the undetected pic (based on pt x val)
df = ekgdf.wekg_lowpass.loc[lim[0]:lim[1]]
# locate the beat (external call)
onepoint_beatdf = detect_beats(df, mult=yscale)
onepoint_beatdf["action"] = "append"
if len(onepoint_beatdf) < 1:
print("no beat founded")
return tochangedf
found_loc = onepoint_beatdf.p_loc.values[0]
y_loc = onepoint_beatdf.y_loc.values[0]
# reassign the pt value
p_loc = ekgdf.wekg_lowpass.loc[lim[0]:lim[1]].index[found_loc]
onepoint_beatdf["p_loc"] = p_loc
print("founded ", p_loc)
# append to figure
fig.get_axes()[0].plot(p_loc, y_loc, "og")
onepoint_beatdf.p_loc = p_loc
onepoint_beatdf.left_bases += p_loc - found_loc
onepoint_beatdf.right_bases.values[0] += p_loc - found_loc
# insert in the tochangedf
# beatdf = beatdf.drop_duplicates('p_loc')
tochangedf = tochangedf.append(onepoint_beatdf)
return tochangedf
