def __init__(self, *args, **kwargs):
from ipywidgets import Image
from ipyevents import Event
#self.plot = None # set in super?
super().__init__(*args, **kwargs)
self.image = Image(value=blank_png, format='png')
self.no_drag = Event(source=self.image,
watched_events=['dragstart'],
prevent_default_action=True)
self.events = Event(source=self.image,
watched_events=['click', 'contextmenu'],
prevent_default_action=True)
self.events.on_dom_event(self.__on_click)
self.update_plot()
def __init__(self, df, to_show, widths, wrap_around, **kwargs):
super().__init__(**kwargs)
self.add_class("content")
d = Event(source=self,
watched_events=['wheel', "mousemove", "mouseleave"])
d.on_dom_event(self.event_handler)
self.to_show = to_show
self.num_rows = min(len(df),
to_show if to_show % 2 == 0 else to_show + 1)
self.idx = 0
self.wrap_around = wrap_around
self.df = df
self.records = df.to_records()
def row_on_click(event):
if event["new"] != -1:
self.value = event["new"]
self.rows = deque([
_Row(data=self.records[i],
widths=widths,
on_click=row_on_click,
style=["row_even", "row_odd"][i % 2])
for i in range(self.num_rows)
])
self.children = list(self.rows)[0:self.to_show]
def test_setting_xy_coordinates_good_value():
# Setting to a value should just work
event_widget = Event()
good_name = 'data'
event_widget.xy_coordinate_system = good_name
assert event_widget.xy_coordinate_system == good_name
def test_callbacks():
# Test that the initial callbacks look right, that we can add one, and
# that clearing removes them all.
event_widget = Event()
assert len(event_widget._dom_handlers.callbacks) == 0
def noop(event):
pass
def noop2(event):
pass
event_widget.on_dom_event(noop)
assert noop in event_widget._dom_handlers.callbacks
assert len(event_widget._dom_handlers.callbacks) == 1
# Add noop2....
event_widget.on_dom_event(noop2)
assert event_widget._dom_handlers.callbacks == [noop, noop2]
# Try removing noop2
event_widget.on_dom_event(noop2, remove=True)
assert event_widget._dom_handlers.callbacks == [noop]
# Finally, clear all callbacks
event_widget.reset_callbacks()
assert len(event_widget._dom_handlers.callbacks) == 0
def test_floating_point_wait_raises_error():
# A floating point value should reaise a TraitletError
event_widget = Event()
with pytest.raises(traitlets.traitlets.TraitError) as e:
event_widget.wait = 15.0
assert "'wait' trait of an Event instance" in str(e)
def test_negative_wait_raises_error():
# negative wait should raise an error.
event_widget = Event()
with pytest.raises(ValueError) as e:
event_widget.wait = -20
assert 'wait must be set to a non-negative integer. ' in str(e)
def test_invalid_event_name():
# An unrecognized event name should generate a ValueError
event_widget = Event()
bad_name = 'this is not a valid event name'
with pytest.raises(ValueError) as e:
event_widget.watched_events = [bad_name]
assert bad_name in str(e)
assert 'not supported. The supported ' in str(e)
def test_properties_work():
# These are a little silly, but will get this to 100% test coverage
event_widget = Event()
# Note the extra underscore on the right hand sides
assert (event_widget.supported_key_events ==
event_widget._supported_key_events)
assert (event_widget.supported_mouse_events ==
event_widget._supported_mouse_events)
def construct_arrow_handler(self):
""" Should only be run once """
disp_events = Event(source=self, watched_events=['keydown'])
def handle_disp(event):
if event["type"] == "keydown":
self.key_funcs[event["key"]]()
disp_events.on_dom_event(handle_disp)
def __init__(self, data, widths, on_click, style, _types=None, **kwargs):
super().__init__(**kwargs)
self.add_class(style)
self.observe(on_click, "value")
d = Event(source=self, watched_events=['click'])
d.on_dom_event(self.on_click)
self.data = data
self.cells = [_Cell(x, w) for x, w in zip(data, widths)]
self.cells[0].add_class("index")
self.children = self.cells
def test_setting_xy_coordinate_bad_value():
# Setting xy_coordinate_system to a bad value should raise a ValueError
event_widget = Event()
bad_name = 'this is not a valid name'
with pytest.raises(ValueError) as e:
event_widget.xy_coordinate_system = bad_name
assert "are not supported. The supported coordinates are" in str(e)
assert bad_name in str(e)
def __init__(self, **kwargs):
"""Same constructor as `ipywidgets.widgets.Button`"""
self.el_btn = widgets.Button(**kwargs)
self.el_btn.on_click(self.fire_on_click_event)
self.on_click_callback = lambda x: x
self.on_mouseenter_callback = lambda x: x
self.on_mouseleave_callback = lambda x: x
self.event_listener = Event(
source=self.el_btn, watched_events=['mouseenter', 'mouseleave'])
self.event_listener.on_dom_event(self.fire_mouse_event)
def test_invalid_slow_method_raises_error():
# Setting throttle_or_debounce to an invalid name should raise
# a ValueError.
event_widget = Event()
bad_name = 'this is not a valid name'
with pytest.raises(ValueError) as e:
event_widget.throttle_or_debounce = bad_name
assert bad_name in str(e)
assert 'The event rate limiting method' in str(e)
def __init__(self, scene_proxy, bridge, *args, **kw):
super(IPyRemoteWidget, self).__init__(scene_proxy, bridge, *args, **kw)
self.image = Image(format='PNG')
self.event = Event(source=self.image,
watched_events=[
'dragstart', 'mouseenter', 'mouseleave',
'mousedown', 'mouseup', 'mousemove', 'wheel',
'keyup', 'keydown'
],
prevent_default_action=True)
self.event.on_dom_event(self.handle_ipyevent)
self._update_image()
def construct_click_handler(self):
""" Should only be run once """
disp_events = Event(source=self, watched_events=['click'])
def handle_disp(event):
if event["type"] == "click":
x = self.images[self.page_index]._size[0]
if event["relativeX"] > (x / 2):
self.next_page()
elif event["relativeX"] < (x / 2):
self.previous_page()
disp_events.on_dom_event(handle_disp)
def setup_jupyter(self):
"""
Sets up elements on the page for use with a Jupyter notebook.
"""
self._label = Label('Move the cursor over the cell and use the left and right arrow keys to navigate')
self._hbox = HBox()
self._html = HTML('<h3>Label position?</h3>')
self._inner = VBox()
self._vbox = VBox([self._html, self._inner, self._label])
self._event = Event(source=self._vbox, watched_events=['keydown'])
self._event.on_dom_event(self.handle_event)
return self
def __init__(self, fontawesome_icon: str):
"""Clickable icon
Parameters
----------
fontawesome_icon: str
icon string from the fontawesome https://fontawesome.com. For example, "fab fa-500px"
"""
self.el_icon = widgets.HTML(
value=f'<i class="{fontawesome_icon}"></i>')
self.on_click_callback = lambda: 1
self.event_listener = Event(source=self.el_icon,
watched_events=['click'])
self.event_listener.on_dom_event(self.fire_on_click_event)
def test_setting_wait_with_debounce_set_preserves_debounce(slow_method):
# If debounce is set but wait is zero and wait is then set to something
# non-zero then throttle_or_debounce should still stay debounce.
event_widget = Event()
event_widget.throttle_or_debounce = slow_method
# Make sure wait is currently zero...
assert event_widget.wait == 0
# This shouldn't change throttle or debounce
event_widget.wait = 20
assert event_widget.throttle_or_debounce == slow_method
def __init__(self, obj):
self.value = obj # we should compute it -- or use it -- as a 'member'
if hasattr(obj, '_latex_list'):
s = obj._latex_list()
elif hasattr(obj, '_latex_'):
s = obj._latex_()
else:
s = obj.__str__()
h = HTMLMath('$%s$' % s)
h.add_class('explorable-value')
self.clc = Event(source=h, watched_events=['click'])
super(ExplorableValue, self).__init__(
(h,),
layout = Layout(border='1px solid green', padding='2px 50px 2px 2px')
)
def test_setting_wait_with_no_throttle_or_debounce():
# If wait is set to something non-zero AND neither throttle
# nor debounce has been set then it should be set to
# throttle.
event_widget = Event()
# Make sure throttle_or_debounce is not set...
assert not event_widget.throttle_or_debounce
# ...and that wait is currently zero
assert event_widget.wait == 0
# This implicitly sets throttle_or_debounce
event_widget.wait = 20
assert event_widget.throttle_or_debounce == 'throttle'
def __init__(self, globals_dict):
self.status_text = display(Code(""), display_id=True)
self._globals_dict = globals_dict
self._methods = {}
self.stop_button = Button(description="Stop")
self.stop_button.on_click(self.on_stop_button_clicked)
self._globals_dict["canvas"] = Canvas()
self.kb_mon = Event(source=self.canvas,
watched_events=['keydown', 'keyup'],
wait=1000 // FRAME_RATE,
prevent_default_actions=True)
self.output_text = ""
self.color_strings = {"default": "#888888"}
match_255 = r"(?:(?:2(?:(?:5[0-5])|(?:[0-4][0-9])))|(?:[01]?[0-9]{1,2}))"
match_alpha = r"(?:(?:1(?:\.0*)?)|(?:0(?:\.[0-9]*)?))"
match_360 = r"(?:(?:3[0-5][0-9])|(?:[0-2]?[0-9]{1,2}))"
match_100 = r"(?:100|[0-9]{1,2})"
self.regexes = [
re.compile(r"#[0-9A-Fa-f]{6}"),
re.compile(r"rgb\({},{},{}\)".format(match_255, match_255,
match_255)),
re.compile(r"rgba\({},{},{},{}\)".format(match_255, match_255,
match_255, match_alpha)),
re.compile(r"hsl\({},{}%,{}%\)".format(match_360, match_100,
match_100)),
re.compile(r"hsla\({},{}%,{}%,{}\)".format(match_360, match_100,
match_100, match_alpha))
]
self.width, self.height = DEFAULT_CANVAS_SIZE
self.mouse_x = 0
self.mouse_y = 0
self.mouse_is_pressed = False
self.key = ""
self._keys_held = {}
# Settings for drawing text (https://ipycanvas.readthedocs.io/en/latest/drawing_text.html).
self.font_settings = {
'size': 12.0,
'font': 'sans-serif',
'baseline': 'top',
'align': 'left'
}
def __init__(self,
im_path=None,
label=None,
im_name=None,
im_index=None,
display_label=True,
image_width='50px',
image_height=None):
self.display_label = display_label
self.label = 'None'
self.image = Image(layout=Layout(display='flex',
justify_content='center',
align_items='center',
align_content='center',
width=image_width,
height=image_height), )
if self.display_label: # both image and label
self.label = HTML(
value='?',
layout=Layout(display='flex',
justify_content='center',
align_items='center',
align_content='center'),
)
else: # no label (capture image case)
self.im_name = im_name
self.im_index = im_index
self.image.layout.border = 'solid 1px gray'
self.image.layout.object_fit = 'contain'
super().__init__(
layout=Layout(align_items='center', margin='3px', padding='2px'))
if not im_path:
self.clear()
self.d = Event(source=self, watched_events=['click'])
def __init__(self, label_name):
self.clix = 0 # current landmark index
self.length = len(db)
self.n_panels = 5
self.panels = [ImageAndLabel() for _ in range(self.n_panels)]
self.label_name = label_name
self.landmarks = Landmarks({k: None for k in db.keys()})
self.c = widgets.HTML('Click or type on me!')
button = widgets.Button(description="Save",
layout=widgets.Layout(width='auto'))
button.on_click(self.save)
w = widgets.HBox([*self.panels])
w = widgets.VBox([w, self.c, button])
self.widget = w
self.d = Event(source=self.widget, watched_events=['keydown'])
self.d.on_dom_event(self.handle_event)
self.target_label = 'q'
self.render()
display(self.widget)
def init(*args, **kwargs):
global flag, downflag, shiftflag
w = widgets.Image(value=m.system.image_data(), width=600)
d = Event(source=w,
watched_events=[
'mousedown', 'mouseup', 'mousemove', 'keyup', 'keydown',
'wheel'
])
no_drag = Event(source=w,
watched_events=['dragstart'],
prevent_default_action=True)
d.on_dom_event(listen_mouse)
run = widgets.ToggleButton(
value=False,
description='Run',
disabled=False,
button_style='', # 'success', 'info', 'warning', 'danger' or ''
tooltip='run the simulation',
icon='play')
pause = widgets.ToggleButton(
value=False,
description='Pause',
disabled=False,
button_style='', # 'success', 'info', 'warning', 'danger' or ''
tooltip='pause the simulation',
icon='pause')
reset = widgets.ToggleButton(
value=False,
description='Reset',
disabled=False,
button_style='', # 'success', 'info', 'warning', 'danger' or ''
tooltip='reset the simulation',
icon='stop')
def onToggleRun(b):
global flag
if run.value:
run.button_style = 'success'
pause.value = False
pause.button_style = ''
reset.value = False
reset.button_style = ''
flag = True
else:
run.button_style = ''
flag = False
def onTogglePause(b):
global flag
if pause.value:
pause.button_style = 'success'
run.value = False
run.button_style = ''
reset.value = False
reset.button_style = ''
flag = False
else:
pause.button_style = ''
flag = True
def onToggleReset(b):
global flag
if reset.value:
reset.button_style = 'success'
pause.value = False
pause.button_style = ''
run.value = False
run.button_style = ''
flag = False
m.Universe.reset()
else:
reset.button_style = ''
#w = create_simulation()
buttons = widgets.HBox([run, pause, reset])
run.observe(onToggleRun, 'value')
pause.observe(onTogglePause, 'value')
reset.observe(onToggleReset, 'value')
box = widgets.VBox([w, buttons])
display(box)
def background_threading():
global flag
while True:
m.Simulator.context_make_current()
if flag:
m.step()
w.value = m.system.image_data()
m.Simulator.context_release()
time.sleep(0.01)
t = threading.Thread(target=background_threading)
t.start()
def __init__(self,
render_window,
log_events=True,
transparent_background=False,
allow_wheel=True,
quality=85,
quick_quality=50,
on_close=None,
**kwargs):
"""Accepts a vtkRenderWindow."""
super().__init__(**kwargs)
if quality < 0 or quality > 100:
raise ValueError('`quality` parameter must be between 0 and 100')
self._quality = quality
self._render_window = weakref.ref(render_window)
self.render_window.SetOffScreenRendering(1) # Force off screen
self.transparent_background = transparent_background
self._full_quality = quality
self._quick_quality = quick_quality
# Frame rate (1/renderDelay)
self.last_render_time = 0
self.quick_render_delay_sec = 0.01
self.quick_render_delay_sec_range = [0.02, 2.0]
self.adaptive_render_delay = True
self.last_mouse_move_event = None
# refresh if mouse is just moving (not dragging)
self.track_mouse_move = False
self.message_timestamp_offset = None
self.layout.width = '100%'
self.layout.height = 'auto'
# Set Canvas size from window size
self.width, self.height = self.render_window.GetSize()
# record first render time
tstart = time.time()
self.update_canvas()
self._first_render_time = time.time() - tstart
log.debug('First image in %.5f seconds', self._first_render_time)
# this is the minimum time to render anyway
self.set_quick_render_delay(self._first_render_time)
self.dragging = False
self.interaction_events = Event()
# Set the throttle or debounce time in millseconds (must be an non-negative integer)
# See https://github.com/mwcraig/ipyevents/pull/55
self.interaction_events.throttle_or_debounce = "throttle"
self.interaction_events.wait = INTERACTION_THROTTLE
self.interaction_events.source = self
allowed_events = [
"dragstart",
"mouseenter",
"mouseleave",
"mousedown",
"mouseup",
"mousemove",
"keyup",
"keydown",
"contextmenu", # prevent context menu from appearing on right-click
]
# May be disabled out so that user can scroll through the
# notebook using mousewheel
if allow_wheel:
allowed_events.append("wheel")
self.interaction_events.watched_events = allowed_events
# self.interaction_events.msg_throttle = 1 # does not seem to have effect
self.interaction_events.prevent_default_action = True
self.interaction_events.on_dom_event(self.handle_interaction_event)
# Errors are not displayed when a widget is displayed,
# this variable can be used to retrieve error messages
self.error = None
# Enable logging of UI events
self.log_events = log_events
self.logged_events = []
self.elapsed_times = []
self.age_of_processed_messages = []
if hasattr(on_close, '__call__'):
self._on_close = on_close
else:
self._on_close = lambda: None
def showCmd(b, layout, out):
layout.toggle_hide(names=("show",))
params, summary = layout["view"].children
controls, view, fov_controls = params.children
with out:
logger.info("Loading results ...")
show_ret = show(
**layout.kwargs,
n=0,
f1=None,
f2=None,
gui=True,
)
if show_ret == 1:
out.clear_output(wait=True)
return
model, fig, item, ax, fov = show_ret
with view:
plt.show()
with summary:
display(model.summary)
n = widgets.BoundedIntText(
value=0,
min=0,
max=model.data.Nt - 1,
description=f"AOI (0-{model.data.Nt-1})",
style={"description_width": "initial"},
layout={"width": "150px"},
)
n_counter = widgets.BoundedIntText(
min=0,
max=model.data.Nt - 1,
)
f1_text = widgets.BoundedIntText(
value=0,
min=0,
max=model.data.F - 15,
step=1,
description=f"Frame (0-{model.data.F-1})",
style={"description_width": "initial"},
layout={"width": "300px"},
)
f1_counter = widgets.BoundedIntText(
min=0,
max=model.data.F - 15,
)
f1_slider = widgets.IntSlider(
value=0,
min=0,
max=model.data.F - 15,
step=1,
continuous_update=True,
readout=False,
readout_format="d",
layout={"width": "210px"},
)
f1_box = widgets.VBox(layout=widgets.Layout(width="310px"))
f1_incr = widgets.Button(description="+15", layout=widgets.Layout(width="45px"))
f1_decr = widgets.Button(description="-15", layout=widgets.Layout(width="45px"))
f1_controls = widgets.HBox(
children=[f1_decr, f1_slider, f1_incr],
layout=widgets.Layout(width="305px"),
)
f1_box.children = [f1_text, f1_controls]
widgets.jslink((f1_slider, "value"), (f1_text, "value"))
widgets.jslink((f1_text, "value"), (f1_counter, "value"))
widgets.jslink((n, "value"), (n_counter, "value"))
zoom = widgets.Checkbox(
value=False,
description="Zoom out frames ['z']",
indent=False,
layout={"width": "240px"},
)
labels = widgets.Checkbox(
value=False,
description="Show labels",
indent=False,
layout={"width": "240px"},
)
targets = widgets.Checkbox(
value=False,
description="Show target location ['o']",
indent=False,
layout={"width": "240px"},
)
nonspecific = widgets.Checkbox(
value=True,
description="Show non-specific spots ['n']",
indent=False,
layout={"width": "240px"},
)
exclude_aoi = widgets.Checkbox(
value=not model.data.mask[0],
description="Exclude AOI from analysis ['e']",
indent=False,
layout={"width": "240px"},
)
checkboxes = widgets.VBox(layout=widgets.Layout(width="250px"))
if model.data.labels is None:
checkboxes.children = [zoom, targets, nonspecific, exclude_aoi]
else:
checkboxes.children = [zoom, targets, nonspecific, exclude_aoi, labels]
controls.children = [n, f1_box, checkboxes]
# fov controls
if fov is not None:
for dtype in fov.dtypes:
fov_controls.add_child(
dtype, widgets.Checkbox(value=True, description=f"Show {dtype} AOIs")
)
fov_controls[dtype].observe(
partial(
showAOIs,
fov=fov,
n=n_counter,
item=item,
fig=fig,
),
names="value",
)
fov_controls.add_child("save_data", widgets.Button(description="Save data"))
# callbacks
n.observe(
partial(
updateParams,
f1=f1_slider,
model=model,
fig=fig,
item=item,
ax=ax,
targets=targets,
nonspecific=nonspecific,
labels=labels,
fov_controls=fov_controls,
exclude_aoi=exclude_aoi,
show_fov=layout["show_fov"],
),
names="value",
)
f1_slider.observe(
partial(
updateRange,
n=n,
model=model,
fig=fig,
item=item,
ax=ax,
zoom=zoom,
targets=targets,
fov=fov,
),
names="value",
)
f1_incr.on_click(partial(incrementRange, x=15, counter=f1_counter))
f1_decr.on_click(partial(incrementRange, x=-15, counter=f1_counter))
zoom.observe(
partial(zoomOut, f1=f1_slider, model=model, fig=fig, item=item, ax=ax),
names="value",
)
labels.observe(
partial(showLabels, n=n_counter, model=model, item=item, ax=ax),
names="value",
)
targets.observe(
partial(
showTargets,
n=n_counter,
f1=f1_slider,
model=model,
item=item,
ax=ax,
),
names="value",
)
nonspecific.observe(
partial(showNonspecific, n=n_counter, model=model, item=item, ax=ax),
names="value",
)
exclude_aoi.observe(
partial(
excludeAOI, n=n_counter, model=model, item=item, show_fov=layout["show_fov"]
),
names="value",
)
fov_controls["save_data"].on_click(
partial(saveData, data=model.data, path=model.path, out=out)
)
# mouse click UI
fig.canvas.mpl_connect(
"button_release_event",
partial(onFrameClick, counter=f1_counter),
)
# key press UI
d = Event(source=layout, watched_events=["keyup"], prevent_default_action=True)
d.on_dom_event(
partial(
onKeyPress,
n=n_counter,
f1=f1_counter,
zoom=zoom,
targets=targets,
nonspecific=nonspecific,
exclude_aoi=exclude_aoi,
)
)
with out:
logger.info("Loading results: Done")
out.clear_output(wait=True)
b.disabled = True
def run():
# Time to build the figure!
fig, ax = plt.subplots(figsize=[9, 9])
# Draw the stars.
def scatter_stars():
marker_size = (0.5 + limiting_magnitude - stars['magnitude']) ** 2.0
mask = (
(marker_size > 0.25)
& (stars['x'] > -0.3)
& (stars['x'] < 0.3)
& (stars['y'] > -0.3)
& (stars['y'] < 0.3)
)
#print('Number of stars:', mask.sum())
#scatter.set_data(stars['x'][mask], stars['y'][mask])
xy = np.array([stars['x'][mask], stars['y'][mask]])
scatter.set_offsets(xy.T)
s = marker_size[mask] #[bright_stars]]
scatter.set_sizes(s)
scatter = ax.scatter([], [], color='k')
scatter_stars()
# Finally, title the plot and set some final parameters.
angle = np.pi - field_of_view_degrees / 360.0 * np.pi
limit = np.sin(angle) / (1.0 - np.cos(angle))
#print(limit)
ax.set_xlim(-limit, limit)
ax.set_ylim(-limit, limit)
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
ax.set_aspect(1.0)
ax.set_title('Stars')
from ipywidgets import Label, HTML, HBox, Image, VBox, Box, HBox, interact
from ipyevents import Event
from IPython.display import display
l = Label('Click or type on me!')
l.layout.border = '2px solid red'
h = HTML('Event info')
d = Event(source=l, watched_events=['click', 'keydown', 'mouseenter'])
def handle_event(event):
lines = ['{}: {}'.format(k, v) for k, v in event.items()]
content = '<br>'.join(lines)
h.value = content
d.on_dom_event(handle_event)
#display(l, h)
import ipywidgets as widgets
def demo(i):
field_of_view_degrees = 45.0 - i
angle = np.pi - field_of_view_degrees / 360.0 * np.pi
limit = np.sin(angle) / (1.0 - np.cos(angle))
ax.set_xlim(-limit, limit)
ax.set_ylim(-limit, limit)
return fig
#widgets.interact(demo, i = d)
def callback(event):
try:
return callback2(event)
except Exception as e:
place.value = str(e)
def callback2(event):
nonlocal limit
place.value = str(event['code'])
code = event['code']
if event['code'] == 'PageUp':
limit /= 1.1
ax.set_xlim(-limit, limit)
ax.set_ylim(-limit, limit)
elif event['code'] == 'PageDown':
limit *= 1.1
ax.set_xlim(-limit, limit)
ax.set_ylim(-limit, limit)
elif code.startswith('Arrow'):
if code == 'ArrowUp':
set_center(0, 0.5)
elif code == 'ArrowDown':
set_center(0, -0.5)
elif code == 'ArrowLeft':
set_center(0.1, 0)
elif code == 'ArrowRight':
set_center(-0.1, 0)
set_positions()
scatter_stars()
place.value = 'Surv'
#PageUp: bigger
# PageDown: smaller
redraw()
from io import BytesIO
def redraw():
io = BytesIO()
plt.savefig(io, format="png")
#plt.close()
plt.ioff()
image.value = io.getvalue()
image = Image(format='png')
redraw()
# The layout bits below make sure the image display looks the same in lab and classic notebook
image.layout.max_width = '4in'
image.layout.height = 'auto'
im_events = Event()
im_events.source = image
im_events.watched_events = ['keydown']
im_events.on_dom_event(callback)
place = HTML('Test')
return VBox([place, image])
def mouse_hover(widget, callback):
e = Event(source=widget, watched_events=['mousemove'])
e.on_dom_event(callback)
def __init__(self,
scipp_obj_dict=None,
axes=None,
masks=None,
cmap=None,
log=None,
vmin=None,
vmax=None,
color=None,
aspect=None):
super().__init__(scipp_obj_dict=scipp_obj_dict,
axes=axes,
masks=masks,
cmap=cmap,
log=log,
vmin=vmin,
vmax=vmax,
color=color,
aspect=aspect,
button_options=['X', 'Y', 'Z'])
self.cube = None
self.members.update({"surfaces": {}, "wireframes": {}})
# Initialise Figure and VBox objects
self.fig = ipv.figure(width=config.plot.width,
height=config.plot.height,
animation=0)
self.scalar_map = cm.ScalarMappable(
norm=self.params["values"][self.name]["norm"],
cmap=self.params["values"][self.name]["cmap"])
self.permutations = {"x": ["y", "z"], "y": ["x", "z"], "z": ["x", "y"]}
# Store min/max for each dimension for invisible scatter
self.xminmax = dict()
for dim, var in self.slider_x[self.name].items():
self.xminmax[dim] = [var.values[0], var.values[-1]]
self.set_axes_range()
self.wireframes = dict()
self.surfaces = dict()
# #====================================================================
# wframes = self.get_outlines()
# meshes = self.get_meshes()
# surf_args = dict.fromkeys(self.permutations)
# wfrm_args = dict.fromkeys(self.permutations)
# # print(wframes)
# for xyz, perm in self.permutations.items():
# print(xyz, perm)
# key = self.button_axis_to_dim[xyz]
# wfrm_args[xyz] = np.ones_like(wframes[xyz][perm[0]]) * \
# self.slider_x[key].values[self.slider[key].value]
# surf_args[xyz] = np.ones_like(meshes[xyz][perm[0]]) * \
# self.slider_x[key].values[self.slider[key].value]
# for p in perm:
# wfrm_args[p] = wframes[xyz][p]
# surf_args[p] = meshes[xyz][p]
# self.wireframes[xyz] = ipv.plot_wireframe(**wfrm_args,
# color="red")
# self.surfaces[xyz] = ipv.plot_surface(**surf_args, color="red")
# #====================================================================
self.mouse_events = dict()
self.last_changed_slider_dim = None
for dim, sl in self.slider.items():
self.mouse_events[dim] = Event(source=sl,
watched_events=['mouseup'])
self.mouse_events[dim].on_dom_event(self.update_surface)
# Call update_slice once to make the initial image
self.update_axes()
self.box = [ipv.gcc()] + self.vbox
self.box = widgets.VBox(self.box)
self.box.layout.align_items = 'center'
self.members["fig"] = self.fig
return
def test_valid_event_name():
# A valid event name should result in that attribute being set.
event_widget = Event()
event_widget.watched_events = ['click']
assert ['click'] == event_widget.watched_events
