def __init__(self):
super(Window, self).__init__()
box = QtGui.QBoxLayout(QtGui.QBoxLayout.LeftToRight, self)
self.resize(500, 200)
self.setLayout(box)
self.canvas_0 = SceneCanvas(bgcolor='w')
self.vb_0 = ViewBox(parent=self.canvas_0.scene, bgcolor='r')
self.vb_0.camera.rect = -1, -1, 2, 2
self.canvas_0.events.initialize.connect(self.on_init)
self.canvas_0.events.resize.connect(
partial(on_resize, self.canvas_0, self.vb_0))
box.addWidget(self.canvas_0.native)
# pass the context from the first canvas to the second
self.canvas_1 = SceneCanvas(bgcolor='w', shared=self.canvas_0.context)
self.vb_1 = ViewBox(parent=self.canvas_1.scene, bgcolor='b')
self.vb_1.camera.rect = -1, -1, 2, 2
self.canvas_1.events.resize.connect(
partial(on_resize, self.canvas_1, self.vb_1))
box.addWidget(self.canvas_1.native)
self.tick_count = 0
self.timer = Timer(interval=1., connect=self.on_timer, start=True)
self.setWindowTitle('Shared contexts')
self.show()
def reset(self):
""" Reset. """
# last key press (it should have a mutex, but visualization is not
# safety critical, so let's do things wrong)
self.action = "no" # no, next, back, quit are the possibilities
# new canvas prepared for visualizing data
self.canvas = SceneCanvas(keys='interactive',
show=True,
size=self.canvas_size)
# interface (n next, b back, q quit, very simple)
self.canvas.events.key_press.connect(self.key_press)
self.canvas.events.draw.connect(self.draw)
# laserscan part
self.scan_view = vispy.scene.widgets.ViewBox(border_color='white',
parent=self.canvas.scene)
self.scan_view.camera = vispy.scene.TurntableCamera(elevation=30,
azimuth=-90,
distance=30,
translate_speed=30,
up='+z')
# grid
self.grid = self.canvas.central_widget.add_grid()
self.grid.add_widget(self.scan_view)
self.scan_vis = visuals.Markers(parent=self.scan_view.scene)
self.scan_vis.antialias = 0
# self.scan_view.add(self.scan_vis)
visuals.XYZAxis(parent=self.scan_view.scene)
self.line = visuals.Line(width=1,
method='gl',
parent=self.scan_view.scene)
self.text = visuals.Text(color='red',
font_size=600,
bold=True,
parent=self.scan_view.scene)
self.gt_line = visuals.Line(width=1000, parent=self.scan_view.scene)
# self.sem_view.camera.link(self.scan_view.camera)
if self.show_img:
# img canvas size
# new canvas for img
self.img_canvas = SceneCanvas(keys='interactive',
show=True,
size=(1242, 375))
# grid
self.img_grid = self.img_canvas.central_widget.add_grid()
# interface (n next, b back, q quit, very simple)
self.img_canvas.events.key_press.connect(self.key_press)
self.img_canvas.events.draw.connect(self.draw)
# add a view for the depth
self.img_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.img_canvas.scene)
self.img_grid.add_widget(self.img_view, 0, 0)
self.img_vis = visuals.Image(cmap='viridis')
self.img_view.add(self.img_vis)
def __init__(self, width=800, height=800, show_axis=True):
self.canvas = SceneCanvas(size=(width, height), position=(0,0), keys='interactive', title=self.__class__.__name__)
self.view = self.canvas.central_widget.add_view()
self.view.camera = 'turntable'
if show_axis:
self.axis = visuals.XYZAxis(parent=self.view.scene)
self.canvas.show()
def __init__(self):
self._canvas = SceneCanvas()
self._viewbox = ViewBox(parent=self._canvas.scene)
self._canvas.central_widget.add_widget(self._viewbox)
self._viewbox.camera = TurntableCamera(
interactive=False,
fov=0, # Makes it an ortho camera.
azimuth=0,
elevation=-90,
)
self._reference_slice = Image(cmap='grays', parent=self._viewbox.scene)
self._reference_slice.attach(ColorFilter((1., .5, 0., 1.)))
self._reference_slice.set_gl_state('additive', depth_test=False)
self._slice = Image(cmap='grays', parent=self._viewbox.scene)
self._slice.attach(ColorFilter((0., .5, 1., 1.)))
self._slice.set_gl_state('additive', depth_test=False)
self._canvas.events.mouse_press.connect(self._vispy_mouse_event)
self._canvas.events.mouse_move.connect(self._vispy_mouse_event)
self._canvas.events.mouse_release.connect(self._vispy_mouse_event)
self._canvas.events.mouse_wheel.connect(self._vispy_mouse_event)
def __init__(self, N, width=600, height=600, decay_rate=1.0, hormone_secretion=None):
from PIL.Image import open as open_image
# setup simulation
self._N = N
self._INITIAL_FIELD = np.array(open_image(path.join(ENV_MAP_PATH, 'envmap01.png'))).astype(np.float32) / 255.
#self._INITIAL_FIELD = np.zeros(self._INITIAL_FIELD.shape)
self._FIELD_WIDTH = self._INITIAL_FIELD.shape[1]
self._FIELD_HEIGHT = self._INITIAL_FIELD.shape[0]
self._FIELD_DECAY_RATE = decay_rate
self._SECRATION = hormone_secretion
sensor_th = np.linspace(0, 2*np.pi, self.SENSOR_NUM, endpoint=False)
self._SENSOR_POSITION = self.AGENT_RADIUS * np.array([np.cos(sensor_th), np.sin(sensor_th)]).T
self.reset() # initialize all variables, position, velocity and field status
# setup display
self._canvas = SceneCanvas(size=(width, height), position=(0,0), keys='interactive', title="ALife book "+self.__class__.__name__)
self._canvas.events.mouse_double_click.connect(self._on_mouse_double_click)
self._view = self._canvas.central_widget.add_view()
self._view.camera = PanZoomCamera((0, 0, self._FIELD_WIDTH, self._FIELD_HEIGHT), aspect=1)
self._field_image = Image(self._field, interpolation='nearest', parent=self._view.scene, method='subdivide', clim=(0,1))
self._agent_polygon = []
for i in range(self._N):
p = AntSimulator._generate_agent_visual_polygon(self.AGENT_RADIUS)
p.parent = self._field_image
self._agent_polygon.append(p)
self._canvas.show()
def __init__(self, _model: AtlasSectionViewModel):
self._model = _model
self._model.register(self.update)
self._canvas = SceneCanvas()
self._viewbox = ViewBox(parent=self._canvas.scene)
self._canvas.central_widget.add_widget(self._viewbox)
self._viewbox.camera = TurntableCamera(
interactive=False,
fov=0, # Makes it an ortho camera.
azimuth=0,
elevation=90,
)
self._slice = Image(cmap='grays', parent=self._viewbox.scene)
self._slice.transform = MatrixTransform()
self._slice.set_data(self._model.atlas_section_image)
self._slice.clim = self._model.clim
self._viewbox.camera.center = self._model.camera_center
self._viewbox.camera.scale_factor = self._viewbox.camera.scale_factor
self._vertical_line = InfiniteLine(pos=0,
vertical=True,
parent=self._viewbox.scene)
self._horizontal_line = InfiniteLine(pos=0,
vertical=False,
parent=self._viewbox.scene)
self._canvas.events.mouse_press.connect(self.mouse_press)
self._canvas.events.mouse_move.connect(self.mouse_move)
self._vertical_line.set_data(color=self._model.vertical_line_color)
self._horizontal_line.set_data(color=self._model.horizontal_line_color)
def resetTwo(self):
""" Reset. """
# last key press (it should have a mutex, but visualization is not
# safety critical, so let's do things wrong)
self.action = "no" # no, next, back, quit are the possibilities
# new canvas prepared for visualizing data
self.canvas = SceneCanvas(keys='interactive', show=True)
# interface (n next, b back, q quit, very simple)
self.canvas.events.key_press.connect(self.key_press)
self.canvas.events.draw.connect(self.draw)
# grid
self.grid = self.canvas.central_widget.add_grid()
# laserscan part
self.scan_view = vispy.scene.widgets.ViewBox(border_color='white',
parent=self.canvas.scene)
self.grid.add_widget(self.scan_view, 0, 0)
self.scan_vis = visuals.Markers()
self.scan_view.camera = 'turntable'
self.scan_view.add(self.scan_vis)
visuals.XYZAxis(parent=self.scan_view.scene)
#if self.instances:
print("Using instances in visualizer")
self.inst_view = vispy.scene.widgets.ViewBox(border_color='white',
parent=self.canvas.scene)
self.grid.add_widget(self.inst_view, 0, 1)
self.inst_vis = visuals.Markers()
self.inst_view.camera = 'turntable'
self.inst_view.add(self.inst_vis)
visuals.XYZAxis(parent=self.inst_view.scene)
def reset(self):
""" Reset. """
# last key press (it should have a mutex, but visualization is not
# safety critical, so let's do things wrong)
self.action = "no" # no, next, back, quit are the possibilities
# new canvas prepared for visualizing data
self.canvas = SceneCanvas(keys='interactive', show=True)
# interface (n next, b back, q quit, very simple)
self.canvas.events.key_press.connect(self.key_press)
self.canvas.events.draw.connect(self.draw)
# grid
self.grid = self.canvas.central_widget.add_grid()
# laserscan part
self.scan_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.canvas.scene)
self.grid.add_widget(self.scan_view, 0, 0)
self.scan_vis = visuals.Markers()
self.scan_view.camera = 'turntable'
self.scan_view.add(self.scan_vis)
visuals.XYZAxis(parent=self.scan_view.scene)
# img canvas size
self.multiplier = 1
self.canvas_W = 1024
self.canvas_H = 64
# new canvas for img
self.img_canvas = SceneCanvas(keys='interactive', show=True,
size=(self.canvas_W, self.canvas_H * self.multiplier))
# grid
self.img_grid = self.img_canvas.central_widget.add_grid()
# interface (n next, b back, q quit, very simple)
self.img_canvas.events.key_press.connect(self.key_press)
self.img_canvas.events.draw.connect(self.draw)
# add a view for the depth
self.img_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.img_canvas.scene)
self.img_grid.add_widget(self.img_view, 0, 0)
self.img_vis = visuals.Image(cmap='viridis')
self.img_view.add(self.img_vis)
def __init__(self, viewer):
super().__init__()
QCoreApplication.setAttribute(
Qt.AA_UseStyleSheetPropagationInWidgetStyles, True)
self.setStyleSheet(self.themed_stylesheet)
self.viewer = viewer
self.viewer._qtviewer = self
self.canvas = SceneCanvas(keys=None, vsync=True)
self.canvas.native.setMinimumSize(QSize(100, 100))
self.canvas.connect(self.on_mouse_move)
self.canvas.connect(self.on_mouse_press)
self.canvas.connect(self.on_mouse_release)
self.canvas.connect(self.on_key_press)
self.canvas.connect(self.on_key_release)
self.view = self.canvas.central_widget.add_view()
# Set 2D camera (the camera will scale to the contents in the scene)
self.view.camera = PanZoomCamera(aspect=1)
# flip y-axis to have correct aligment
self.view.camera.flip = (0, 1, 0)
self.view.camera.set_range()
self.view.camera.viewbox_key_event = viewbox_key_event
center = QWidget()
layout = QVBoxLayout()
layout.setContentsMargins(15, 20, 15, 10)
layout.addWidget(self.canvas.native)
dimsview = QtDims(self.viewer.dims)
layout.addWidget(dimsview)
center.setLayout(layout)
# Add controls, center, and layerlist
self.control_panel = QtControls(viewer)
self.addWidget(self.control_panel)
self.addWidget(center)
self.addWidget(self.viewer.layers._qt)
self._cursors = {
'disabled':
QCursor(
QPixmap(':/icons/cursor/cursor_disabled.png').scaled(20, 20)),
'cross':
Qt.CrossCursor,
'forbidden':
Qt.ForbiddenCursor,
'pointing':
Qt.PointingHandCursor,
'standard':
QCursor()
}
def reset(self, sem_color_dict=None):
""" Reset. """
# new canvas prepared for visualizing data
self.map_color(sem_color_dict=sem_color_dict)
self.canvas = SceneCanvas(keys='interactive', show=True)
# grid
self.grid = self.canvas.central_widget.add_grid()
# laserscan part
self.scan_view = vispy.scene.widgets.ViewBox(border_color='white',
parent=self.canvas.scene)
self.grid.add_widget(self.scan_view, 0, 0)
self.scan_view.camera = 'turntable'
self.scan_vis = visuals.Markers()
self.scan_view.add(self.scan_vis)
if self.viz_joint:
self.joint_vis = visuals.Arrow(connect='segments',
arrow_size=18,
color='blue',
width=10,
arrow_type='angle_60')
self.arrow_length = 10
self.scan_view.add(self.joint_vis)
if self.viz_box:
vertices, faces, outline = create_box(width=1,
height=1,
depth=1,
width_segments=1,
height_segments=1,
depth_segments=1)
vertices['color'][:, 3] = 0.2
# breakpoint()
self.box = visuals.Box(vertex_colors=vertices['color'],
edge_color='b')
self.box.transform = STTransform(translate=[-2.5, 0, 0])
self.theta = 0
self.phi = 0
self.scan_view.add(self.box)
visuals.XYZAxis(parent=self.scan_view.scene)
# add nocs
if self.viz_label:
print("Using nocs in visualizer")
self.nocs_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.canvas.scene)
self.grid.add_widget(self.nocs_view, 0, 1)
self.label_vis = visuals.Markers()
self.nocs_view.camera = 'turntable'
self.nocs_view.add(self.label_vis)
visuals.XYZAxis(parent=self.nocs_view.scene)
self.nocs_view.camera.link(self.scan_view.camera)
def __init__(self, width=600, height=600):
self._canvas = SceneCanvas(size=(width, height),
position=(0, 0),
keys='interactive',
title="ALife book " +
self.__class__.__name__)
self._view = self._canvas.central_widget.add_view()
#self._view.camera = 'arcball'
self._view.camera = 'turntable'
self._axis = visuals.XYZAxis(parent=self._view.scene)
self._arrows = None
self._markers = None
self._canvas.show()
def plots(ids, line=True, subparts=None, mi=True, vc=True, sj=True, centering=True):
skel = get_skels(ids)
canvas = SceneCanvas(keys='interactive', show=True)
view = canvas.central_widget.add_view()
view.camera = 'turntable'
if centering:
center = skel.hull_coords.mean(0)
else:
center=np.asarray([0,0,0])
plots = plot_hull(skel, subparts, center)
if line:
plots.extend(plot_line(skel, center))
if mi or vc or sj:
plots.extend(plot_objects(skel, mi, vc, sj, center))
for obj in plots:
view.add(obj)
return view
def __init__(self, _model: VolumeViewModel):
self._model = _model
self._model.register(self.update)
self._canvas = SceneCanvas()
self._viewbox = ViewBox(parent=self._canvas.scene)
self._canvas.central_widget.add_widget(self._viewbox)
self._viewbox.camera = ArcballCamera(fov=0)
self._atlas_volume = Volume(self._model.atlas_volume, parent=self._viewbox.scene) # , interpolation='nearest')
self._atlas_volume.attach(filters.ColorFilter((1., .5, 0., 1.)))
self._atlas_volume.set_gl_state('additive', depth_test=False)
self._section_image = Image(parent=self._viewbox.scene, cmap='grays')
self._section_image.attach(filters.ColorFilter((0., .5, 1., 1.)))
self._section_image.set_gl_state('additive', depth_test=False)
self._canvas.events.key_press.connect(lambda event: self._model.press_key(event.key.name))
def __init__(self):
self._canvas = SceneCanvas()
self._viewbox = ViewBox(parent=self._canvas.scene)
self._canvas.central_widget.add_widget(self._viewbox)
self._viewbox.camera = ArcballCamera(fov=0)
self._atlas_volume = Volume(
array([[[1, 2]]]) * 1000,
parent=self._viewbox.scene) # , interpolation='nearest')
self._atlas_volume.attach(filters.ColorFilter((1., .5, 0., 1.)))
self._atlas_volume.set_gl_state('additive', depth_test=False)
self._section_image = Image(parent=self._viewbox.scene, cmap='grays')
self._section_image.attach(filters.ColorFilter((0., .5, 1., 1.)))
self._section_image.set_gl_state('additive', depth_test=False)
self._canvas.events.key_press.connect(
self._handle_vispy_key_press_events)
def __init__(self):
self.canvas = SceneCanvas(keys='interactive', show=True)
self.grid = self.canvas.central_widget.add_grid()
self.view = vispy.scene.widgets.ViewBox(border_color='white',
parent=self.canvas.scene)
self.grid.add_widget(self.view, 0, 0)
# Point Cloud Visualizer
self.sem_vis = visuals.Markers()
self.view.camera = vispy.scene.cameras.TurntableCamera(up='z',
azimuth=90)
self.view.add(self.sem_vis)
visuals.XYZAxis(parent=self.view.scene)
# Object Detection Visualizer
self.obj_vis = visuals.Line()
self.view.add(self.obj_vis)
self.connect = np.asarray([[0, 1], [0, 3], [0, 4], [2, 1], [2, 3],
[2, 6], [5, 1], [5, 4], [5, 6], [7, 3],
[7, 4], [7, 6]])
self.data = load_data(
'data/data.p') # Change to data.p for your final submission
def __init__(self, viewer):
super().__init__()
self.canvas = SceneCanvas(keys=None, vsync=True)
self.canvas.native.setMinimumSize(QSize(100, 100))
self.view = self.canvas.central_widget.add_view()
# Set 2D camera (the camera will scale to the contents in the scene)
self.view.camera = PanZoomCamera(aspect=1)
# flip y-axis to have correct aligment
self.view.camera.flip = (0, 1, 0)
self.view.camera.set_range()
center = QWidget()
layout = QVBoxLayout()
layout.addWidget(self.canvas.native)
layout.addWidget(viewer.dimensions._qt)
center.setLayout(layout)
# Add vertical sliders, center, and layerlist
self.addWidget(viewer.controlBars._qt)
self.addWidget(center)
self.addWidget(viewer.layers._qt)
viewer.dimensions._qt.setFixedHeight(0)
def __init__(self, viewer):
super().__init__()
self.viewer = viewer
self.sliders = []
self.canvas = SceneCanvas(keys=None, vsync=True)
layout = QGridLayout()
self.setLayout(layout)
layout.setContentsMargins(0, 0, 0, 0)
#layout.setColumnStretch(0, 4)
row = 0
layout.addWidget(self.canvas.native, row, 0)
#layout.setRowStretch(row, 1)
self.view = self.canvas.central_widget.add_view()
# Set 2D camera (the camera will scale to the contents in the scene)
self.view.camera = PanZoomCamera(aspect=1)
# flip y-axis to have correct aligment
self.view.camera.flip = (0, 1, 0)
self.view.camera.set_range()
timer = app.Timer()
timer.connect(update)
timer.start()
canvas_2 = SignalGridCanvas(3, 3, length=1000)
c2_0 = canvas_2.add_new_signal(1, 1)
canvas_2.set_signal_values(
c2_0, np.concatenate([np.random.rand(500),
np.repeat(1, 500)]))
base_widget.layout().addWidget(canvas_1.native)
base_widget.layout().addWidget(canvas_2.native)
from vispy.scene.widgets.console import Console
from vispy.scene import SceneCanvas
sc = SceneCanvas(keys='interactive')
horiz = QHBoxLayout()
base_widget.layout().addLayout(horiz)
horiz.addWidget(sc.native)
c = Console()
sc.central_widget.add_widget(c)
sc.central_widget.bgcolor = '#ffffff'
import random
def write(_):
c.write(f'hai {random.randint(0, 10)}')
c3.visuals[1].set_data(np.random.rand(4, 2) * 100)
c3.update()
t = app.Timer(interval=0.5, connect=write, start=True)
def reset(self):
""" Reset. """
# last key press (it should have a mutex, but visualization is not
# safety critical, so let's do things wrong)
self.action = "no" # no, next, back, quit are the possibilities
# 3D canvas
self.scan_canvas = SceneCanvas(keys='interactive',
show=True,
title='',
size=(1600, 600),
bgcolor='white')
self.scan_canvas.events.key_press.connect(self.key_press)
self.grid_view = self.scan_canvas.central_widget.add_grid()
# source laserscan 3D
self.scan_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.scan_canvas.scene)
self.scan_vis = visuals.Markers()
self.scan_view.camera = 'turntable'
self.scan_view.add(self.scan_vis)
visuals.XYZAxis(parent=self.scan_view.scene)
self.grid_view.add_widget(self.scan_view, 0, 0)
# target laserscan 3D
if self.show_target is True:
self.back_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.scan_canvas.scene)
self.back_vis = visuals.Markers()
self.back_view.camera = 'turntable'
self.back_view.camera.link(self.scan_view.camera)
self.back_view.add(self.back_vis)
visuals.XYZAxis(parent=self.back_view.scene)
self.grid_view.add_widget(self.back_view, 0, 1)
# self.grid_view.padding = 6
# Set height of images
h = 1
if self.show_range is True:
h += 1
if self.show_remissions is True:
h += 1
# source canvas 2D
source_canvas_title = 'Source ' + str(self.H[0]) + 'x' + str(self.W[0])
self.source_canvas = SceneCanvas(keys='interactive',
show=True,
title=source_canvas_title,
size=(self.W[0], h * self.H[0]))
self.source_canvas.events.key_press.connect(self.key_press)
self.source_view = self.source_canvas.central_widget.add_grid()
source_grid_idx = 0
# Add label image
if self.show_label:
self.img_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.source_canvas.scene)
self.img_vis = visuals.Image(cmap='viridis')
self.img_view.add(self.img_vis)
self.source_view.add_widget(self.img_view, source_grid_idx, 0)
source_grid_idx += 1
# target canvas 2D
if self.show_target:
target_canvas_title = 'Target ' + str(self.H[1]) + 'x' + str(
self.W[1])
self.target_canvas = SceneCanvas(keys='interactive',
show=True,
title=target_canvas_title,
size=(self.W[1], h * self.H[1]))
self.target_canvas.events.key_press.connect(self.key_press)
self.target_view = self.target_canvas.central_widget.add_grid()
target_grid_idx = 0
# Add label image
if self.show_label:
self.test_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.target_canvas.scene)
self.test_vis = visuals.Image(cmap='viridis')
self.test_view.add(self.test_vis)
self.target_view.add_widget(self.test_view, target_grid_idx, 0)
target_grid_idx += 1
if self.show_range:
# Add source range image
self.range_view_source = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.source_canvas.scene)
self.range_image_source = visuals.Image()
self.range_view_source.add(self.range_image_source)
self.source_view.add_widget(self.range_view_source,
source_grid_idx, 0)
source_grid_idx += 1
if self.show_target:
self.range_view_target = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.target_canvas.scene)
self.range_image_target = visuals.Image(cmap='viridis')
self.range_view_target.add(self.range_image_target)
self.target_view.add_widget(self.range_view_target,
target_grid_idx, 0)
target_grid_idx += 1
if self.show_remissions:
# Add source remissions image
self.remissions_view_source = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.source_canvas.scene)
self.remissions_image_source = visuals.Image()
self.remissions_view_source.add(self.remissions_image_source)
self.source_view.add_widget(self.remissions_view_source,
source_grid_idx, 0)
source_grid_idx += 1
# Add target remissions image
if self.show_target:
self.remissions_view_target = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.target_canvas.scene)
self.remissions_image_target = visuals.Image(cmap='viridis')
self.remissions_view_target.add(self.remissions_image_target)
self.target_view.add_widget(self.remissions_view_target,
target_grid_idx, 0)
target_grid_idx += 1
# 2D canvas for showing difference in range, labels and remissions
if self.show_diff:
self.diff_canvas = SceneCanvas(keys='interactive',
show=True,
title='Difference Range Image',
size=(self.W[1], self.H[1] * h))
self.diff_canvas.events.key_press.connect(self.key_press)
self.diff_view = self.diff_canvas.central_widget.add_grid()
grid_idx = 0
# Add label difference
if self.show_label:
self.diff_view_label = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.diff_canvas.scene)
self.diff_image_label = visuals.Image(cmap='viridis')
self.diff_view_label.add(self.diff_image_label)
self.diff_view.add_widget(self.diff_view_label, grid_idx, 0)
grid_idx += 1
# Add range difference
if self.show_range:
self.diff_view_depth = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.diff_canvas.scene)
self.diff_image_depth = visuals.Image()
self.diff_view_depth.add(self.diff_image_depth)
self.diff_view.add_widget(self.diff_view_depth, grid_idx, 0)
grid_idx += 1
# Add remissions difference
if self.show_remissions:
self.diff_view_remissions = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.diff_canvas.scene)
self.diff_image_remissions = visuals.Image()
self.diff_view_remissions.add(self.diff_image_remissions)
self.diff_view.add_widget(self.diff_view_remissions, grid_idx,
0)
grid_idx += 1
if self.show_mesh:
self.mesh_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.scan_canvas.scene)
self.mesh_vis = visuals.Mesh(shading=None)
self.mesh_view.camera = 'turntable'
self.mesh_view.camera.link(self.scan_view.camera)
self.mesh_view.add(self.mesh_vis)
visuals.XYZAxis(parent=self.mesh_view.scene)
self.grid_view.add_widget(self.mesh_view, 0, 2)
import os
import PySide2
from pathlib import Path
os.environ['QT_PLUGIN_PATH'] = str(
Path(PySide2.__file__).parent / 'Qt' / 'plugins')
from vispy.app import use_app
app = use_app('pyside2')
from vispy.scene import SceneCanvas
from vispy.scene.visuals import Polygon
canvas = SceneCanvas()
v = canvas.central_widget.add_view()
v.bgcolor = 'gray'
v.camera = 'panzoom'
cx, cy = (0.5, 0.5)
halfx, halfy = (0.1, 0.1)
poly_coords = [(cx - halfx, cy - halfy), (cx + halfx, cy - halfy),
(cx + halfx, cy + halfy), (cx - halfx, cy + halfy)]
poly = Polygon(poly_coords,
color=(1.0, 0.0, 0.0, 0.5),
border_color=(1.0, 1.0, 1.0, 0.2),
border_width=3,
parent=v.scene)
canvas.show()
app.run()
def reset(self):
""" Reset. """
# last key press (it should have a mutex, but visualization is not
# safety critical, so let's do things wrong)
self.action = "no" # no, next, back, quit are the possibilities
''' 3D points cloud or mesh SceneCanvas '''
# new canvas prepared for visualizing data
self.canvas = SceneCanvas(keys='interactive', show=True)
# interface (n next, b back, q quit, very simple)
self.canvas.events.key_press.connect(self.key_press)
self.canvas.events.draw.connect(self.draw)
# grid
self.grid = self.canvas.central_widget.add_grid()
# add point cloud views
self.scan_view = vispy.scene.widgets.ViewBox(border_color='white',
parent=self.canvas.scene)
self.grid.add_widget(self.scan_view, 0, 0)
# Camera location settings
self.scene_cam = vispy.scene.cameras.BaseCamera()
# self.scene_cam.center = (-10, -10, 10)
# self.scan_view.add(self.scene_cam)
# self.scene_cam.pre_transform.set_range()
canvas2 = vispy.app.Canvas()
w = QMainWindow()
widget = QWidget()
w.setCentralWidget(widget)
widget.setLayout(QVBoxLayout())
widget.layout().addWidget(canvas2.native)
widget.layout().addWidget(QPushButton())
w.show()
self.scan_vis = visuals.Mesh()
self.scan_vis_mean = visuals.Line()
self.scan_vis_cam = visuals.Line()
self.scan_bbox_3d = visuals.Line()
self.label_vis = visuals.Text()
self.scan_view.add(self.scan_vis)
self.scan_view.add(self.scan_vis_mean)
self.scan_view.add(self.scan_vis_cam)
self.scan_view.add(self.scan_bbox_3d)
self.scan_view.add(self.label_vis)
self.scan_view.camera = 'arcball'
self.tr = self.scan_vis.transforms.get_transform(map_from='visual',
map_to='canvas')
# self.scan_view.camera = self.scene_cam
# self.scan_view.camera = 'arcball' , 'turntable'
# self.scan_view.camera.transform.rotate(90, (0,1,0))
visuals.XYZAxis(parent=self.scan_view.scene)
''' 2D images SceneCanvas '''
# img canvas size
self.canvas_W = 320
self.canvas_H = 280
self.multiplier = 2
''' new canvas for RGB & Depth img '''
self.img_canvas = SceneCanvas(keys='interactive',
show=True,
size=(self.canvas_W,
self.canvas_H * self.multiplier))
self.img_grid = self.img_canvas.central_widget.add_grid()
# interface (n next, s start, p pause, q quit, )
self.img_canvas.events.key_press.connect(self.key_press)
self.img_canvas.events.draw.connect(self.draw)
# add rgb views
self.rgb_img_raw_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.img_canvas.scene)
self.img_grid.add_widget(self.rgb_img_raw_view, 0, 0)
self.rgb_img_raw_vis = visuals.Image(cmap='viridis')
self.rgb_img_raw_view.add(self.rgb_img_raw_vis)
# add a view for the depth
self.depth_img_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.img_canvas.scene)
self.img_grid.add_widget(self.depth_img_view, 1, 0)
self.depth_img_vis = visuals.Image(cmap='viridis')
self.depth_img_view.add(self.depth_img_vis)
''' new canvas for 3D scene graph img '''
self.scene_graph_canvas = SceneCanvas(keys='interactive',
show=True,
size=(640, 480))
self.scene_graph_grid = self.scene_graph_canvas.central_widget.add_grid(
)
self.scene_graph_canvas.events.key_press.connect(self.key_press)
self.scene_graph_canvas.events.draw.connect(self.draw)
# add a view for 3D scene graphs
self.scene_graph_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.scene_graph_canvas.scene)
self.scene_graph_grid.add_widget(self.scene_graph_view, 0, 0)
self.scene_graph_vis = visuals.Image(cmap='viridis')
self.scene_graph_view.add(self.scene_graph_vis)
def __init__(self, viewer):
super().__init__()
QCoreApplication.setAttribute(
Qt.AA_UseStyleSheetPropagationInWidgetStyles, True
)
self.viewer = viewer
self.canvas = SceneCanvas(keys=None, vsync=True)
self.canvas.native.setMinimumSize(QSize(100, 100))
self.canvas.connect(self.on_mouse_move)
self.canvas.connect(self.on_mouse_press)
self.canvas.connect(self.on_mouse_release)
self.canvas.connect(self.on_key_press)
self.canvas.connect(self.on_key_release)
self.canvas.connect(self.on_draw)
self.view = self.canvas.central_widget.add_view()
# Set 2D camera (the camera will scale to the contents in the scene)
self.view.camera = PanZoomCamera(aspect=1)
# flip y-axis to have correct aligment
self.view.camera.flip = (0, 1, 0)
self.view.camera.set_range()
self.view.camera.viewbox_key_event = viewbox_key_event
# TO DO: Remove
self.viewer._view = self.view
center = QWidget()
center_layout = QVBoxLayout()
center_layout.setContentsMargins(15, 20, 15, 10)
center_layout.addWidget(self.canvas.native)
self.dims = QtDims(self.viewer.dims)
center_layout.addWidget(self.dims)
center.setLayout(center_layout)
# Add controls, center, and layerlist
self.control_panel = QtControls(viewer)
self.addWidget(self.control_panel)
self.addWidget(center)
right = QWidget()
right_layout = QVBoxLayout()
self.layers = QtLayerList(self.viewer.layers)
right_layout.addWidget(self.layers)
self.buttons = QtLayersButtons(viewer)
right_layout.addWidget(self.buttons)
right.setLayout(right_layout)
right.setMinimumSize(QSize(308, 250))
self.addWidget(right)
self._last_visited_dir = str(Path.home())
self._cursors = {
'disabled': QCursor(
QPixmap(':/icons/cursor/cursor_disabled.png').scaled(20, 20)
),
'cross': Qt.CrossCursor,
'forbidden': Qt.ForbiddenCursor,
'pointing': Qt.PointingHandCursor,
'standard': QCursor(),
}
self._update_palette(viewer.palette)
self._key_release_generators = {}
self.viewer.events.interactive.connect(self._on_interactive)
self.viewer.events.cursor.connect(self._on_cursor)
self.viewer.events.reset_view.connect(self._on_reset_view)
self.viewer.events.palette.connect(
lambda event: self._update_palette(event.palette)
)
self.viewer.layers.events.reordered.connect(self._update_canvas)
self.setAcceptDrops(True)
def __init__(self, viewer):
super().__init__()
QCoreApplication.setAttribute(
Qt.AA_UseStyleSheetPropagationInWidgetStyles, True
)
self.viewer = viewer
self.dims = QtDims(self.viewer.dims)
self.controls = QtControls(self.viewer)
self.layers = QtLayerList(self.viewer.layers)
self.buttons = QtLayersButtons(self.viewer)
self.console = QtConsole({'viewer': self.viewer})
if self.console.shell is not None:
self.console.style().unpolish(self.console)
self.console.style().polish(self.console)
self.console.hide()
self.buttons.consoleButton.clicked.connect(
lambda: self._toggle_console()
)
else:
self.buttons.consoleButton.setEnabled(False)
self.canvas = SceneCanvas(keys=None, vsync=True)
self.canvas.native.setMinimumSize(QSize(200, 200))
self.canvas.connect(self.on_mouse_move)
self.canvas.connect(self.on_mouse_press)
self.canvas.connect(self.on_mouse_release)
self.canvas.connect(self.on_key_press)
self.canvas.connect(self.on_key_release)
self.canvas.connect(self.on_draw)
self.view = self.canvas.central_widget.add_view()
self._update_camera()
center = QWidget()
center_layout = QVBoxLayout()
center_layout.setContentsMargins(15, 20, 15, 10)
center_layout.addWidget(self.canvas.native)
center_layout.addWidget(self.dims)
center.setLayout(center_layout)
right = QWidget()
right_layout = QVBoxLayout()
right_layout.addWidget(self.layers)
right_layout.addWidget(self.buttons)
right.setLayout(right_layout)
right.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
left = self.controls
top = QWidget()
top_layout = QHBoxLayout()
top_layout.addWidget(left)
top_layout.addWidget(center)
top_layout.addWidget(right)
top.setLayout(top_layout)
self.setOrientation(Qt.Vertical)
self.addWidget(top)
if self.console.shell is not None:
self.addWidget(self.console)
self._last_visited_dir = str(Path.home())
self._cursors = {
'disabled': QCursor(
QPixmap(':/icons/cursor/cursor_disabled.png').scaled(20, 20)
),
'cross': Qt.CrossCursor,
'forbidden': Qt.ForbiddenCursor,
'pointing': Qt.PointingHandCursor,
'standard': QCursor(),
}
self._update_palette(viewer.palette)
self._key_release_generators = {}
self.viewer.events.interactive.connect(self._on_interactive)
self.viewer.events.cursor.connect(self._on_cursor)
self.viewer.events.reset_view.connect(self._on_reset_view)
self.viewer.events.palette.connect(
lambda event: self._update_palette(event.palette)
)
self.viewer.layers.events.reordered.connect(self._update_canvas)
self.viewer.dims.events.display.connect(
lambda event: self._update_camera()
)
self.setAcceptDrops(True)
glsl_map = """
vec4 translucent_grays(float t) {
return vec4(t, t, t, t*0.05);
}
"""
cap = cv2.VideoCapture(0)
_, frame = cap.read()
vol1 = np.load(io.load_data_file('volume/stent.npz'))['arr_0']
vol2 = np.load(io.load_data_file('brain/mri.npz'))['data']
vol2 = np.flipud(np.rollaxis(vol2, 1))
canvas = SceneCanvas("nirterface",
keys='interactive',
size=(800, 600),
show=True)
canvas.measure_fps()
view = canvas.central_widget.add_view()
# view = canvas.central_widget.add_view()
#view = ViewBox(parent=canvas.scene, name='vb1',
# margin=2, border_color='red')
#view.size = canvas.size
backgroundView = ViewBox(parent=view.scene,
name="vb2",
margin=2,
border_color='green')
backgroundView.size = view.size
backgroundView.camera = 'panzoom'
def __init__(self, viewer):
super().__init__()
self.pool = QThreadPool()
QCoreApplication.setAttribute(
Qt.AA_UseStyleSheetPropagationInWidgetStyles, True)
self.viewer = viewer
self.dims = QtDims(self.viewer.dims)
self.controls = QtControls(self.viewer)
self.layers = QtLayerList(self.viewer.layers)
self.layerButtons = QtLayerButtons(self.viewer)
self.viewerButtons = QtViewerButtons(self.viewer)
self.console = QtConsole({'viewer': self.viewer})
# This dictionary holds the corresponding vispy visual for each layer
self.layer_to_visual = {}
if self.console.shell is not None:
self.console.style().unpolish(self.console)
self.console.style().polish(self.console)
self.console.hide()
self.viewerButtons.consoleButton.clicked.connect(
lambda: self._toggle_console())
else:
self.viewerButtons.consoleButton.setEnabled(False)
self.canvas = SceneCanvas(keys=None, vsync=True)
self.canvas.events.ignore_callback_errors = False
self.canvas.events.draw.connect(self.dims.enable_play)
self.canvas.native.setMinimumSize(QSize(200, 200))
self.canvas.context.set_depth_func('lequal')
self.canvas.connect(self.on_mouse_move)
self.canvas.connect(self.on_mouse_press)
self.canvas.connect(self.on_mouse_release)
self.canvas.connect(self.on_key_press)
self.canvas.connect(self.on_key_release)
self.canvas.connect(self.on_draw)
self.view = self.canvas.central_widget.add_view()
self._update_camera()
main_widget = QWidget()
main_layout = QGridLayout()
main_layout.setContentsMargins(15, 20, 15, 10)
main_layout.addWidget(self.canvas.native, 0, 1, 3, 1)
main_layout.addWidget(self.dims, 3, 1)
main_layout.addWidget(self.controls, 0, 0)
main_layout.addWidget(self.layerButtons, 1, 0)
main_layout.addWidget(self.layers, 2, 0)
main_layout.addWidget(self.viewerButtons, 3, 0)
main_layout.setColumnStretch(1, 1)
main_layout.setSpacing(10)
main_widget.setLayout(main_layout)
self.setOrientation(Qt.Vertical)
self.addWidget(main_widget)
if self.console.shell is not None:
self.addWidget(self.console)
self._last_visited_dir = str(Path.home())
self._cursors = {
'disabled':
QCursor(
QPixmap(':/icons/cursor/cursor_disabled.png').scaled(20, 20)),
'cross':
Qt.CrossCursor,
'forbidden':
Qt.ForbiddenCursor,
'pointing':
Qt.PointingHandCursor,
'standard':
QCursor(),
}
self._update_palette(viewer.palette)
self._key_release_generators = {}
self.viewer.events.interactive.connect(self._on_interactive)
self.viewer.events.cursor.connect(self._on_cursor)
self.viewer.events.reset_view.connect(self._on_reset_view)
self.viewer.events.palette.connect(
lambda event: self._update_palette(event.palette))
self.viewer.layers.events.reordered.connect(self._reorder_layers)
self.viewer.layers.events.added.connect(self._add_layer)
self.viewer.layers.events.removed.connect(self._remove_layer)
self.viewer.dims.events.camera.connect(
lambda event: self._update_camera())
# stop any animations whenever the layers change
self.viewer.events.layers_change.connect(lambda x: self.dims.stop())
self.setAcceptDrops(True)
def __init__(self, viewer):
super().__init__()
self.setAttribute(Qt.WA_DeleteOnClose)
self.pool = QThreadPool()
QCoreApplication.setAttribute(
Qt.AA_UseStyleSheetPropagationInWidgetStyles, True)
self.viewer = viewer
self.dims = QtDims(self.viewer.dims)
self.controls = QtControls(self.viewer)
self.layers = QtLayerList(self.viewer.layers)
self.layerButtons = QtLayerButtons(self.viewer)
self.viewerButtons = QtViewerButtons(self.viewer)
self.console = QtConsole({'viewer': self.viewer})
layerList = QWidget()
layerList.setObjectName('layerList')
layerListLayout = QVBoxLayout()
layerListLayout.addWidget(self.layerButtons)
layerListLayout.addWidget(self.layers)
layerListLayout.addWidget(self.viewerButtons)
layerListLayout.setContentsMargins(8, 4, 8, 6)
layerList.setLayout(layerListLayout)
self.dockLayerList = QtViewerDockWidget(
self,
layerList,
name='layer list',
area='left',
allowed_areas=['left', 'right'],
)
self.dockLayerControls = QtViewerDockWidget(
self,
self.controls,
name='layer controls',
area='left',
allowed_areas=['left', 'right'],
)
self.dockConsole = QtViewerDockWidget(
self,
self.console,
name='console',
area='bottom',
allowed_areas=['top', 'bottom'],
shortcut='Ctrl+Shift+C',
)
self.dockConsole.setVisible(False)
self.dockLayerControls.visibilityChanged.connect(self._constrain_width)
self.dockLayerList.setMaximumWidth(258)
self.dockLayerList.setMinimumWidth(258)
# This dictionary holds the corresponding vispy visual for each layer
self.layer_to_visual = {}
if self.console.shell is not None:
self.viewerButtons.consoleButton.clicked.connect(
lambda: self.toggle_console())
else:
self.viewerButtons.consoleButton.setEnabled(False)
self.canvas = SceneCanvas(keys=None, vsync=True, parent=self)
self.canvas.events.ignore_callback_errors = False
self.canvas.events.draw.connect(self.dims.enable_play)
self.canvas.native.setMinimumSize(QSize(200, 200))
self.canvas.context.set_depth_func('lequal')
self.canvas.connect(self.on_mouse_move)
self.canvas.connect(self.on_mouse_press)
self.canvas.connect(self.on_mouse_release)
self.canvas.connect(self.on_key_press)
self.canvas.connect(self.on_key_release)
self.canvas.connect(self.on_draw)
self.view = self.canvas.central_widget.add_view()
self._update_camera()
main_widget = QWidget()
main_layout = QVBoxLayout()
main_layout.setContentsMargins(10, 22, 10, 2)
main_layout.addWidget(self.canvas.native)
main_layout.addWidget(self.dims)
main_layout.setSpacing(10)
main_widget.setLayout(main_layout)
self.setOrientation(Qt.Vertical)
self.addWidget(main_widget)
self._last_visited_dir = str(Path.home())
self._cursors = {
'disabled':
QCursor(
QPixmap(':/icons/cursor/cursor_disabled.png').scaled(20, 20)),
'cross':
Qt.CrossCursor,
'forbidden':
Qt.ForbiddenCursor,
'pointing':
Qt.PointingHandCursor,
'standard':
QCursor(),
}
self._update_palette(viewer.palette)
self._key_release_generators = {}
self.viewer.events.interactive.connect(self._on_interactive)
self.viewer.events.cursor.connect(self._on_cursor)
self.viewer.events.reset_view.connect(self._on_reset_view)
self.viewer.events.palette.connect(
lambda event: self._update_palette(event.palette))
self.viewer.layers.events.reordered.connect(self._reorder_layers)
self.viewer.layers.events.added.connect(self._add_layer)
self.viewer.layers.events.removed.connect(self._remove_layer)
self.viewer.dims.events.camera.connect(
lambda event: self._update_camera())
# stop any animations whenever the layers change
self.viewer.events.layers_change.connect(lambda x: self.dims.stop())
self.setAcceptDrops(True)
and RegularPolygon
"""
from vispy import app
import sys
from vispy.scene import SceneCanvas
from vispy.scene.visuals import Polygon, Ellipse, Rectangle, RegularPolygon
from vispy.color import Color
white = Color("#ecf0f1")
gray = Color("#121212")
red = Color("#e74c3c")
blue = Color("#2980b9")
orange = Color("#e88834")
canvas = SceneCanvas(keys='interactive', title='Polygon Example', show=True)
v = canvas.central_widget.add_view()
v.bgcolor = gray
v.camera = 'panzoom'
cx, cy = (0.2, 0.2)
halfx, halfy = (0.1, 0.1)
poly_coords = [(cx - halfx, cy - halfy), (cx + halfx, cy - halfy),
(cx + halfx, cy + halfy), (cx - halfx, cy + halfy)]
poly = Polygon(poly_coords,
color=red,
border_color=white,
border_width=3,
parent=v.scene)
# -*- coding: utf-8 -*-
# vispy: gallery 30
# -----------------------------------------------------------------------------
# Copyright (c) Vispy Development Team. All Rights Reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
# -----------------------------------------------------------------------------
"""
Demonstration of borders and background colors.
"""
from vispy.scene import SceneCanvas
canvas = SceneCanvas(keys='interactive', bgcolor='w', show=True)
grid = canvas.central_widget.add_grid(spacing=0,
bgcolor='gray',
border_color='k')
view1 = grid.add_view(row=0,
col=0,
margin=10,
bgcolor=(1, 0, 0, 0.5),
border_color=(1, 0, 0))
view2 = grid.add_view(row=0,
col=1,
margin=10,
bgcolor=(0, 1, 0, 0.5),
border_color=(0, 1, 0))
if __name__ == '__main__':
canvas.app.run()
v.draw()
def on_resize(event):
# Set canvas viewport and reconfigure visual transforms to match.
vp = (0, 0, canvas.physical_size[0], canvas.physical_size[1])
canvas.context.set_viewport(*vp)
for v in order:
v.transforms.configure(canvas=canvas, viewport=vp)
canvas.events.resize.connect(on_resize)
on_resize(None)
Line = create_visual_node(LineVisual)
canvas2 = SceneCanvas(keys='interactive', title='Scene Canvas', show=True)
v = canvas2.central_widget.add_view(margin=10)
v.border_color = (1, 1, 1, 1)
v.bgcolor = (0.3, 0.3, 0.3, 1)
v.camera = 'panzoom'
line2 = Line(pos, parent=v.scene)
def mouse(ev):
print(ev)
v.events.mouse_press.connect(mouse)
if __name__ == '__main__':
if sys.flags.interactive != 1:
def reset(self):
""" Reset. """
# last key press (it should have a mutex, but visualization is not
# safety critical, so let's do things wrong)
self.action = "no" # no, next, back, quit are the possibilities
# new canvas prepared for visualizing data
self.canvas = SceneCanvas(keys="interactive", show=True)
# interface (n next, b back, q quit, very simple)
self.canvas.events.key_press.connect(self.key_press)
self.canvas.events.draw.connect(self.draw)
# grid
self.grid = self.canvas.central_widget.add_grid()
# laserscan part
self.scan_view = vispy.scene.widgets.ViewBox(
border_color="white", parent=self.canvas.scene
)
self.grid.add_widget(self.scan_view, 0, 0)
self.scan_vis = visuals.Markers()
self.scan_view.camera = "turntable"
self.scan_view.add(self.scan_vis)
visuals.XYZAxis(parent=self.scan_view.scene)
# add semantics
if self.semantics:
print("Using semantics in visualizer")
self.sem_view = vispy.scene.widgets.ViewBox(
border_color="white", parent=self.canvas.scene
)
self.grid.add_widget(self.sem_view, 0, 1)
self.sem_vis = visuals.Markers()
self.sem_view.camera = "turntable"
self.sem_view.add(self.sem_vis)
visuals.XYZAxis(parent=self.sem_view.scene)
self.sem_view.camera.link(self.scan_view.camera)
if self.instances:
print("Using instances in visualizer")
self.inst_view = vispy.scene.widgets.ViewBox(
border_color="white", parent=self.canvas.scene
)
self.grid.add_widget(self.inst_view, 0, 2)
self.inst_vis = visuals.Markers()
self.inst_view.camera = "turntable"
self.inst_view.add(self.inst_vis)
visuals.XYZAxis(parent=self.inst_view.scene)
# self.inst_view.camera.link(self.scan_view.camera)
# img canvas size
self.multiplier = 1
self.canvas_W = 1024
self.canvas_H = 64
if self.semantics:
self.multiplier += 1
if self.instances:
self.multiplier += 1
# new canvas for img
self.img_canvas = SceneCanvas(
keys="interactive",
show=True,
size=(self.canvas_W, self.canvas_H * self.multiplier),
)
# grid
self.img_grid = self.img_canvas.central_widget.add_grid()
# interface (n next, b back, q quit, very simple)
self.img_canvas.events.key_press.connect(self.key_press)
self.img_canvas.events.draw.connect(self.draw)
# add a view for the depth
self.img_view = vispy.scene.widgets.ViewBox(
border_color="white", parent=self.img_canvas.scene
)
self.img_grid.add_widget(self.img_view, 0, 0)
self.img_vis = visuals.Image(cmap="viridis")
self.img_view.add(self.img_vis)
# add semantics
if self.semantics:
self.sem_img_view = vispy.scene.widgets.ViewBox(
border_color="white", parent=self.img_canvas.scene
)
self.img_grid.add_widget(self.sem_img_view, 1, 0)
self.sem_img_vis = visuals.Image(cmap="viridis")
self.sem_img_view.add(self.sem_img_vis)
# add instances
if self.instances:
self.inst_img_view = vispy.scene.widgets.ViewBox(
border_color="white", parent=self.img_canvas.scene
)
self.img_grid.add_widget(self.inst_img_view, 2, 0)
self.inst_img_vis = visuals.Image(cmap="viridis")
self.inst_img_view.add(self.inst_img_vis)
