def smooth_savitzky_golay_ipy(obj, **kwargs):
wdict = {}
window_length = OddIntSlider(value=3,
step=2,
min=3,
max=max(int(obj.axis.size * 0.25), 3))
polynomial_order = ipywidgets.IntSlider(value=3,
min=1,
max=window_length.value - 1)
# Polynomial order must be less than window length
def update_bound(change):
polynomial_order.max = change.new - 1
window_length.observe(update_bound, "value")
differential_order = ipywidgets.IntSlider(value=0, min=0, max=10)
color = ipywidgets.ColorPicker()
close = ipywidgets.Button(
description="Close",
tooltip=
"Close widget and remove the smoothed line from the signal figure.")
apply = ipywidgets.Button(
description="Apply",
tooltip="Perform the operation using the selected range.")
link((obj, "polynomial_order"), (polynomial_order, "value"))
link((obj, "window_length"), (window_length, "value"))
link((obj, "differential_order"), (differential_order, "value"))
# Differential order must be less or equal to polynomial_order
link((polynomial_order, "value"), (differential_order, "max"))
link((obj, "line_color_ipy"), (color, "value"))
box = ipywidgets.VBox([
labelme("Window length", window_length),
labelme("polynomial order", polynomial_order),
labelme("Differential order", differential_order),
labelme("Color", color),
ipywidgets.HBox((apply, close))
])
wdict["window_length"] = window_length
wdict["polynomial_order"] = polynomial_order
wdict["differential_order"] = differential_order
wdict["color"] = color
wdict["close_button"] = close
wdict["apply_button"] = apply
def on_apply_clicked(b):
obj.apply()
apply.on_click(on_apply_clicked)
def on_close_clicked(b):
obj.close()
box.close()
close.on_click(on_close_clicked)
return {
"widget": box,
"wdict": wdict,
}
def image_constast_editor_ipy(obj, **kwargs):
wdict = {}
left = ipywidgets.FloatText(disabled=True)
right = ipywidgets.FloatText(disabled=True)
help = ipywidgets.HTML(
"Click on the histogram figure and drag to the right to select a"
"range. Press `Apply` to set the new contrast limits, `Reset` to reset "
"them or `Close` to cancel.", )
wdict["help"] = help
help = ipywidgets.Accordion(children=[help])
help.set_title(0, "Help")
close = ipywidgets.Button(
description="Close",
tooltip="Close widget and remove span selector from the signal figure."
)
apply = ipywidgets.Button(
description="Apply",
tooltip="Perform the operation using the selected range.")
reset = ipywidgets.Button(
description="Reset",
tooltip="Reset the contrast to the previous value.")
wdict["left"] = left
wdict["right"] = right
wdict["close_button"] = close
wdict["apply_button"] = apply
wdict["reset_button"] = reset
# Connect
link((obj, "ss_left_value"), (left, "value"))
link((obj, "ss_right_value"), (right, "value"))
def on_apply_clicked(b):
obj.apply()
apply.on_click(on_apply_clicked)
def on_reset_clicked(b):
obj.reset()
reset.on_click(on_reset_clicked)
box = ipywidgets.VBox([
labelme("vmin", left),
labelme("vmax", right), help,
ipywidgets.HBox((apply, reset, close))
])
def on_close_clicked(b):
obj.close()
box.close()
close.on_click(on_close_clicked)
return {
"widget": box,
"wdict": wdict,
}
def _get_axis_widgets(obj):
widgets = []
wd = {}
name = ipywidgets.Text()
widgets.append(labelme(ipywidgets.Label("Name"), name))
link((obj, "name"), (name, "value"))
wd["name"] = name
size = ipywidgets.IntText(disabled=True)
widgets.append(labelme("Size", size))
link((obj, "size"), (size, "value"))
wd["size"] = size
index_in_array = ipywidgets.IntText(disabled=True)
widgets.append(labelme("Index in array", index_in_array))
link((obj, "index_in_array"), (index_in_array, "value"))
wd["index_in_array"] = index_in_array
if obj.navigate:
index = ipywidgets.IntSlider(min=0, max=obj.size - 1)
widgets.append(labelme("Index", index))
link((obj, "index"), (index, "value"))
wd["index"] = index
value = ipywidgets.FloatSlider(
min=obj.low_value,
max=obj.high_value,
)
wd["value"] = value
widgets.append(labelme("Value", value))
link((obj, "value"), (value, "value"))
link((obj, "high_value"), (value, "max"))
link((obj, "low_value"), (value, "min"))
link((obj, "scale"), (value, "step"))
units = ipywidgets.Text()
widgets.append(labelme("Units", units))
link((obj, "units"), (units, "value"))
wd["units"] = units
if hasattr(obj, "scale"):
scale = ipywidgets.FloatText()
widgets.append(labelme("Scale", scale))
link((obj, "scale"), (scale, "value"))
wd["scale"] = scale
if hasattr(obj, "offset"):
offset = ipywidgets.FloatText()
widgets.append(labelme("Offset", offset))
link((obj, "offset"), (offset, "value"))
wd["offset"] = offset
if "_expression" in obj.__dict__.keys():
expression = ipywidgets.Text(disabled=True)
widgets.append(labelme("Expression", expression))
link((obj, "_expression"), (expression, "value"))
wd["expression"] = expression
return {"widget": ipywidgets.VBox(widgets), "wdict": wd}
def fit_component_ipy(obj, **kwargs):
wdict = {}
only_current = Checkbox()
iterpath = enum2dropdown(obj.traits()["iterpath"])
def disable_iterpath(change):
iterpath.disabled = change.new
only_current.observe(disable_iterpath, "value")
wdict["only_current"] = only_current
wdict["iterpath"] = iterpath
help_text = HTML(
"Click on the signal figure and drag to the right to select a"
"range. Press `Fit` to fit the component in that range. If only "
"current is unchecked the fit is performed in the whole dataset.",
layout=ipywidgets.Layout(width="auto"))
wdict["help_text"] = help_text
help = Accordion(children=[help_text], selected_index=None)
set_title_container(help, ["Help"])
link((obj, "only_current"), (only_current, "value"))
link((obj, "iterpath"), (iterpath, "value"))
fit = Button(description="Fit", tooltip="Fit in the selected signal range")
close = Button(
description="Close",
tooltip="Close widget and remove span selector from the signal figure."
)
wdict["close_button"] = close
wdict["fit_button"] = fit
def on_fit_clicked(b):
obj._fit_fired()
fit.on_click(on_fit_clicked)
box = VBox([
labelme("Only current", only_current),
labelme("Iterpath", wdict["iterpath"]), help,
HBox((fit, close))
])
def on_close_clicked(b):
obj.span_selector_switch(False)
box.close()
close.on_click(on_close_clicked)
return {
"widget": box,
"wdict": wdict,
}
def enum2dropdown(trait, label):
tooltip = trait.desc if trait.desc else ""
widget = ipywidgets.Dropdown(
options=trait.trait_type.values,
tooltip=tooltip,
)
return labelme(widget=widget, label=label)
def range2floatrangeslider(trait, label):
tooltip = trait.desc if trait.desc else ""
widget = ipywidgets.FloatSlider(
min=trait.trait_type._low,
max=trait.trait_type._high,
tooltip=tooltip,
)
return labelme(widget=widget, label=label)
def smooth_butterworth(obj, **kwargs):
wdict = {}
cutoff = ipywidgets.FloatSlider(min=0.01, max=1.)
order = ipywidgets.IntText()
type_ = ipywidgets.Dropdown(options=("low", "high"))
color = ipywidgets.ColorPicker()
close = ipywidgets.Button(
description="Close",
tooltip=
"Close widget and remove the smoothed line from the signal figure.")
apply = ipywidgets.Button(
description="Apply",
tooltip="Perform the operation using the selected range.")
link((obj, "cutoff_frequency_ratio"), (cutoff, "value"))
link((obj, "type"), (type_, "value"))
link((obj, "order"), (order, "value"))
wdict["cutoff"] = cutoff
wdict["order"] = order
wdict["type"] = type_
wdict["color"] = color
wdict["close_button"] = close
wdict["apply_button"] = apply
box = ipywidgets.VBox([
labelme("Cutoff frequency ration", cutoff),
labelme("Type", type_),
labelme("Order", order),
ipywidgets.HBox((apply, close))
])
def on_apply_clicked(b):
obj.apply()
apply.on_click(on_apply_clicked)
def on_close_clicked(b):
obj.close()
box.close()
close.on_click(on_close_clicked)
return {
"widget": box,
"wdict": wdict,
}
def smooth_tv_ipy(obj, **kwargs):
wdict = {}
smoothing_parameter = ipywidgets.FloatSlider(min=0.1, max=1000)
smoothing_parameter_max = ipywidgets.FloatText(
value=smoothing_parameter.max)
color = ipywidgets.ColorPicker()
close = ipywidgets.Button(
description="Close",
tooltip=
"Close widget and remove the smoothed line from the signal figure.")
apply = ipywidgets.Button(
description="Apply",
tooltip="Perform the operation using the selected range.")
link((obj, "smoothing_parameter"), (smoothing_parameter, "value"))
link((smoothing_parameter_max, "value"), (smoothing_parameter, "max"))
link((obj, "line_color_ipy"), (color, "value"))
wdict["smoothing_parameter"] = smoothing_parameter
wdict["smoothing_parameter_max"] = smoothing_parameter_max
wdict["color"] = color
wdict["close_button"] = close
wdict["apply_button"] = apply
box = ipywidgets.VBox([
labelme("Weight", smoothing_parameter),
labelme("Weight max", smoothing_parameter_max),
labelme("Color", color),
ipywidgets.HBox((apply, close))
])
def on_apply_clicked(b):
obj.apply()
apply.on_click(on_apply_clicked)
def on_close_clicked(b):
obj.close()
box.close()
close.on_click(on_close_clicked)
return {
"widget": box,
"wdict": wdict,
}
def smooth_lowess_ipy(obj, **kwargs):
wdict = {}
smoothing_parameter = ipywidgets.FloatSlider(min=0, max=1)
number_of_iterations = ipywidgets.IntText()
color = ipywidgets.ColorPicker()
close = ipywidgets.Button(
description="Close",
tooltip=
"Close widget and remove the smoothed line from the signal figure.")
apply = ipywidgets.Button(
description="Apply",
tooltip="Perform the operation using the selected range.")
link((obj, "smoothing_parameter"), (smoothing_parameter, "value"))
link((obj, "number_of_iterations"), (number_of_iterations, "value"))
link((obj, "line_color_ipy"), (color, "value"))
box = ipywidgets.VBox([
labelme("Smoothing parameter", smoothing_parameter),
labelme("Number of iterations", number_of_iterations),
labelme("Color", color),
ipywidgets.HBox((apply, close))
])
wdict["smoothing_parameter"] = smoothing_parameter
wdict["number_of_iterations"] = number_of_iterations
wdict["color"] = color
wdict["close_button"] = close
wdict["apply_button"] = apply
def on_apply_clicked(b):
obj.apply()
apply.on_click(on_apply_clicked)
def on_close_clicked(b):
obj.close()
box.close()
close.on_click(on_close_clicked)
return {
"widget": box,
"wdict": wdict,
}
def fit_component_ipy(obj, **kwargs):
wdict = {}
only_current = Checkbox()
wdict["only_current"] = only_current
help = HTML(
"Click on the signal figure and drag to the right to select a"
"range. Press `Fit` to fit the component in that range. If only "
"current is unchecked the fit is performed in the whole dataset.",
layout=ipywidgets.Layout(width="auto"))
wdict["help"] = only_current
help = Accordion(children=[help])
help.set_title(0, "Help")
link((obj, "only_current"), (only_current, "value"))
fit = Button(description="Fit", tooltip="Fit in the selected signal range")
close = Button(
description="Close",
tooltip="Close widget and remove span selector from the signal figure."
)
wdict["close_button"] = close
wdict["fit_button"] = fit
def on_fit_clicked(b):
obj._fit_fired()
fit.on_click(on_fit_clicked)
box = VBox(
[labelme("Only current", only_current), help,
HBox((fit, close))])
def on_close_clicked(b):
obj.span_selector_switch(False)
box.close()
close.on_click(on_close_clicked)
return {
"widget": box,
"wdict": wdict,
}
def bool2checkbox(trait, label):
description_tooltip = trait.desc if trait.desc else ""
widget = ipywidgets.Checkbox()
widget.description_tooltip = description_tooltip
return labelme(widget=widget, label=label)
def directory2unicode(trait, label):
tooltip = trait.desc if trait.desc else ""
widget = ipywidgets.Text(tooltip=tooltip, )
return labelme(widget=widget, label=label)
def bool2checkbox(trait, label):
tooltip = trait.desc if trait.desc else ""
widget = ipywidgets.Checkbox(tooltip=tooltip, )
return labelme(widget=widget, label=label)
def enum2dropdown(trait, label):
widget = ipywidgets.Dropdown(options=trait.trait_type.values)
return labelme(widget=widget, label=label)
def spikes_removal_ipy(obj, **kwargs):
wdict = {}
threshold = ipywidgets.FloatText()
add_noise = ipywidgets.Checkbox()
default_spike_width = ipywidgets.IntText()
interpolator_kind = enum2dropdown(obj.traits()["interpolator_kind"])
spline_order = ipywidgets.IntSlider(min=1, max=10)
progress_bar = ipywidgets.IntProgress(max=len(obj.coordinates) - 1)
help = ipywidgets.HTML(
value=SPIKES_REMOVAL_INSTRUCTIONS.replace('\n', '<br/>'))
help = ipywidgets.Accordion(children=[help])
help.set_title(0, "Help")
show_diff = ipywidgets.Button(
description="Show derivative histogram",
tooltip="This figure is useful to estimate the threshold.",
layout=ipywidgets.Layout(width="auto"))
close = ipywidgets.Button(
description="Close",
tooltip="Close widget and remove span selector from the signal figure.")
next = ipywidgets.Button(
description="Find next",
tooltip="Find next spike")
previous = ipywidgets.Button(
description="Find previous",
tooltip="Find previous spike")
remove = ipywidgets.Button(
description="Remove spike",
tooltip="Remove spike and find next one.")
wdict["threshold"] = threshold
wdict["add_noise"] = add_noise
wdict["default_spike_width"] = default_spike_width
wdict["interpolator_kind"] = interpolator_kind
wdict["spline_order"] = spline_order
wdict["progress_bar"] = progress_bar
wdict["show_diff_button"] = show_diff
wdict["close_button"] = close
wdict["next_button"] = next
wdict["previous_button"] = previous
wdict["remove_button"] = remove
def on_show_diff_clicked(b):
obj._show_derivative_histogram_fired()
show_diff.on_click(on_show_diff_clicked)
def on_next_clicked(b):
obj.find()
next.on_click(on_next_clicked)
def on_previous_clicked(b):
obj.find(back=True)
previous.on_click(on_previous_clicked)
def on_remove_clicked(b):
obj.apply()
remove.on_click(on_remove_clicked)
labeled_spline_order = labelme("Spline order", spline_order)
def enable_interpolator_kind(change):
if change.new == "Spline":
for child in labeled_spline_order.children:
child.layout.display = ""
else:
for child in labeled_spline_order.children:
child.layout.display = "none"
interpolator_kind.observe(enable_interpolator_kind, "value")
link((obj, "interpolator_kind"),
(interpolator_kind, "value"))
link((obj, "threshold"), (threshold, "value"))
link((obj, "add_noise"), (add_noise, "value"))
link((obj, "default_spike_width"),
(default_spike_width, "value"))
link((obj, "spline_order"), (spline_order, "value"))
link((obj, "index"), (progress_bar, "value"))
# Trigger the function that controls the visibility as
# setting the default value doesn't trigger it.
class Dummy:
new = interpolator_kind.value
enable_interpolator_kind(change=Dummy())
advanced = ipywidgets.Accordion((
ipywidgets.VBox([
labelme("Add noise", add_noise),
labelme("Interpolator kind", interpolator_kind),
labelme("Default spike width", default_spike_width),
labelme("Spline order", spline_order), ]),))
advanced.set_title(0, "Advanced settings")
box = ipywidgets.VBox([
ipywidgets.VBox([
show_diff,
labelme("Threshold", threshold),
labelme("Progress", progress_bar), ]),
advanced,
help,
ipywidgets.HBox([previous, next, remove, close])
])
def on_close_clicked(b):
obj.span_selector_switch(False)
box.close()
close.on_click(on_close_clicked)
return {
"widget": box,
"wdict": wdict,
}
def find_peaks2D_ipy(obj, **kwargs):
wdict = {}
# Define widgets
# For "local max" method
local_max_distance = ipywidgets.IntSlider(min=1, max=20, value=3)
local_max_threshold = ipywidgets.FloatSlider(min=0, max=20, value=10)
# For "max" method
max_alpha = ipywidgets.FloatSlider(min=0, max=6, value=3)
max_distance = ipywidgets.IntSlider(min=1, max=20, value=10)
# For "minmax" method
minmax_distance = ipywidgets.FloatSlider(min=0, max=6, value=3)
minmax_threshold = ipywidgets.FloatSlider(min=0, max=20, value=10)
# For "Zaefferer" method
zaefferer_grad_threshold = ipywidgets.FloatSlider(min=0,
max=0.2,
value=0.1,
step=0.2 * 1E-1)
zaefferer_window_size = ipywidgets.IntSlider(min=2, max=80, value=40)
zaefferer_distance_cutoff = ipywidgets.FloatSlider(min=0,
max=100,
value=50)
# For "stat" method
stat_alpha = ipywidgets.FloatSlider(min=0, max=2, value=1)
stat_window_radius = ipywidgets.IntSlider(min=5, max=20, value=10)
stat_convergence_ratio = ipywidgets.FloatSlider(min=0, max=0.1, value=0.05)
# For "Laplacian of Gaussians" method
log_min_sigma = ipywidgets.FloatSlider(min=0, max=2, value=1)
log_max_sigma = ipywidgets.FloatSlider(min=0, max=100, value=50)
log_num_sigma = ipywidgets.FloatSlider(min=0, max=20, value=10)
log_threshold = ipywidgets.FloatSlider(min=0, max=0.4, value=0.2)
log_overlap = ipywidgets.FloatSlider(min=0, max=1, value=0.5)
log_log_scale = ipywidgets.Checkbox()
# For "Difference of Gaussians" method
dog_min_sigma = ipywidgets.FloatSlider(min=0, max=2, value=1)
dog_max_sigma = ipywidgets.FloatSlider(min=0, max=100, value=50)
dog_sigma_ratio = ipywidgets.FloatSlider(min=0, max=3.2, value=1.6)
dog_threshold = ipywidgets.FloatSlider(min=0, max=0.4, value=0.2)
dog_overlap = ipywidgets.FloatSlider(min=0, max=1, value=0.5)
# For "Cross correlation" method
xc_distance = ipywidgets.FloatSlider(min=0, max=10., value=5.)
xc_threshold = ipywidgets.FloatSlider(min=0, max=2., value=0.5)
wdict["local_max_distance"] = local_max_distance
wdict["local_max_threshold"] = local_max_threshold
wdict["max_alpha"] = max_alpha
wdict["max_distance"] = max_distance
wdict["minmax_distance"] = minmax_distance
wdict["minmax_threshold"] = minmax_threshold
wdict["zaefferer_grad_threshold"] = zaefferer_grad_threshold
wdict["zaefferer_window_size"] = zaefferer_window_size
wdict["zaefferer_distance_cutoff"] = zaefferer_distance_cutoff
wdict["stat_alpha"] = stat_alpha
wdict["stat_window_radius"] = stat_window_radius
wdict["stat_convergence_ratio"] = stat_convergence_ratio
wdict["log_min_sigma"] = log_min_sigma
wdict["log_max_sigma"] = log_max_sigma
wdict["log_num_sigma"] = log_num_sigma
wdict["log_threshold"] = log_threshold
wdict["log_overlap"] = log_overlap
wdict["log_log_scale"] = log_log_scale
wdict["dog_min_sigma"] = dog_min_sigma
wdict["dog_max_sigma"] = dog_max_sigma
wdict["dog_sigma_ratio"] = dog_sigma_ratio
wdict["dog_threshold"] = dog_threshold
wdict["dog_overlap"] = dog_overlap
wdict["xc_distance"] = xc_distance
wdict["xc_threshold"] = xc_threshold
# Connect
link((obj, "local_max_distance"), (local_max_distance, "value"))
link((obj, "local_max_threshold"), (local_max_threshold, "value"))
link((obj, "max_alpha"), (max_alpha, "value"))
link((obj, "max_distance"), (max_distance, "value"))
link((obj, "minmax_distance"), (minmax_distance, "value"))
link((obj, "minmax_threshold"), (minmax_threshold, "value"))
link((obj, "zaefferer_grad_threshold"),
(zaefferer_grad_threshold, "value"))
link((obj, "zaefferer_window_size"), (zaefferer_window_size, "value"))
link((obj, "zaefferer_distance_cutoff"),
(zaefferer_distance_cutoff, "value"))
link((obj, "stat_alpha"), (stat_alpha, "value"))
link((obj, "stat_window_radius"), (stat_window_radius, "value"))
link((obj, "stat_convergence_ratio"), (stat_convergence_ratio, "value"))
link((obj, "log_min_sigma"), (log_min_sigma, "value"))
link((obj, "log_max_sigma"), (log_max_sigma, "value"))
link((obj, "log_num_sigma"), (log_num_sigma, "value"))
link((obj, "log_threshold"), (log_threshold, "value"))
link((obj, "log_overlap"), (log_overlap, "value"))
link((obj, "log_log_scale"), (log_log_scale, "value"))
link((obj, "dog_min_sigma"), (dog_min_sigma, "value"))
link((obj, "dog_max_sigma"), (dog_max_sigma, "value"))
link((obj, "dog_sigma_ratio"), (dog_sigma_ratio, "value"))
link((obj, "dog_threshold"), (dog_threshold, "value"))
link((obj, "dog_overlap"), (dog_overlap, "value"))
link((obj, "xc_distance"), (xc_distance, "value"))
link((obj, "xc_threshold"), (xc_threshold, "value"))
close = ipywidgets.Button(description="Close",
tooltip="Close widget and close figure.")
compute = ipywidgets.Button(
description="Compute over navigation axes.",
tooltip="Find the peaks by iterating over the navigation axes.")
box_local_max = ipywidgets.VBox([
labelme("Distance", local_max_distance),
labelme("Threshold", local_max_threshold),
])
box_max = ipywidgets.VBox([ #max_alpha, max_distance
labelme("Alpha", max_alpha),
labelme("Distance", max_distance),
])
box_minmax = ipywidgets.VBox([
labelme("Distance", minmax_distance),
labelme("Threshold", minmax_threshold),
])
box_zaefferer = ipywidgets.VBox([
labelme("Gradient threshold", zaefferer_grad_threshold),
labelme("Window size", zaefferer_window_size),
labelme("Distance cutoff", zaefferer_distance_cutoff),
])
box_stat = ipywidgets.VBox([
labelme("Alpha", stat_alpha),
labelme("Radius", stat_window_radius),
labelme("Convergence ratio", stat_convergence_ratio),
])
box_log = ipywidgets.VBox([
labelme("Min sigma", log_min_sigma),
labelme("Max sigma", log_max_sigma),
labelme("Num sigma", log_num_sigma),
labelme("Threshold", log_threshold),
labelme("Overlap", log_overlap),
labelme("Log scale", log_log_scale),
])
box_dog = ipywidgets.VBox([
labelme("Min sigma", dog_min_sigma),
labelme("Max sigma", dog_max_sigma),
labelme("Sigma ratio", dog_sigma_ratio),
labelme("Threshold", dog_threshold),
labelme("Overlap", dog_overlap),
])
box_xc = ipywidgets.VBox([
labelme("Distance", xc_distance),
labelme("Threshold", xc_threshold),
])
box_dict = {
"Local Max": box_local_max,
"Max": box_max,
"Minmax": box_minmax,
"Zaefferer": box_zaefferer,
"Stat": box_stat,
"Laplacian of Gaussians": box_log,
"Difference of Gaussians": box_dog,
"Template matching": box_xc
}
method = enum2dropdown(obj.traits()["method"])
def update_method_parameters(change):
# Remove all parameters vbox widgets
for item, value in box_dict.items():
value.layout.display = "none"
if change.new == "Local max":
box_local_max.layout.display = ""
elif change.new == "Max":
box_max.layout.display = ""
elif change.new == "Minmax":
box_minmax.layout.display = ""
elif change.new == "Zaefferer":
box_zaefferer.layout.display = ""
elif change.new == "Stat":
box_stat.layout.display = ""
elif change.new == "Laplacian of Gaussians":
box_log.layout.display = ""
elif change.new == "Difference of Gaussians":
box_dog.layout.display = ""
elif change.new == "Template matching":
box_xc.layout.display = ""
method.observe(update_method_parameters, "value")
link((obj, "method"), (method, "value"))
# Trigger the function that controls the visibility as
# setting the default value doesn't trigger it.
class Dummy:
new = method.value
update_method_parameters(change=Dummy())
widgets_list = []
if obj.show_navigation_sliders:
nav_widget = get_ipy_navigation_sliders(
obj.signal.axes_manager.navigation_axes,
in_accordion=True,
random_position_button=True)
widgets_list.append(nav_widget['widget'])
wdict.update(nav_widget['wdict'])
l = [labelme("Method", method)]
l.extend([value for item, value in box_dict.items()])
method_parameters = ipywidgets.Accordion((ipywidgets.VBox(l), ))
set_title_container(method_parameters, ["Method parameters"])
widgets_list.extend([method_parameters, ipywidgets.HBox([compute, close])])
box = ipywidgets.VBox(widgets_list)
def on_compute_clicked(b):
obj.compute_navigation()
obj.signal._plot.close()
obj.close()
box.close()
compute.on_click(on_compute_clicked)
def on_close_clicked(b):
obj.signal._plot.close()
obj.close()
box.close()
close.on_click(on_close_clicked)
return {
"widget": box,
"wdict": wdict,
}
def directory2unicode(trait, label):
description_tooltip = trait.desc if trait.desc else ""
widget = ipywidgets.Text()
widget.description_tooltip = description_tooltip
return labelme(widget=widget, label=label)
