# Here the mesh has a single boundary
open_mesh_boundary = stop.mesh_boundary(open_mesh)
print(open_mesh_boundary)
###############################################################################
# show the result
# WARNING : BrainObj should be added first before
visb_sc = splt.visbrain_plot(mesh=open_mesh, caption='open mesh')
# create points with vispy
for bound in open_mesh_boundary:
points = open_mesh.vertices[bound]
s_rad = SourceObj('rad', points, color='red', symbol='square',
radius_min=10)
visb_sc.add_to_subplot(s_rad)
lines = Line(pos=open_mesh.vertices[bound], width=10, color='b')
# wrap the vispy object using visbrain
l_obj = VispyObj('line', lines)
visb_sc.add_to_subplot(l_obj)
visb_sc.preview()
###############################################################################
# here is how to get the vertices that define the boundary of
# a texture on a mesh
# Let us first load example data
mesh = sio.load_mesh('../examples/data/example_mesh.gii')
# rotate the mesh for better visualization
transfo_flip = np.array([[-1, 0, 0, 0],[0, 1, 0, 0],[0, 0, -1, 0], [0, 0, 0, 1]])
mesh.apply_transform(transfo_flip)
# Load the example texture and compute its boundary
def __init__(self, parent):
super(SignalWidget, self).__init__(parent)
# Useful trnascripts
self.plugin = self.parent()
self.sd = self.plugin.sd
self.CONF_SECTION = self.parent().CONF_SECTION
# Variables
self.measurement_mode = False
self.curr_pc = None
self.sig_start = None
self.sig_stop = None
self.spect_type = 'spectrum' # spectrum, spectrogram
# General variables
self.low_lim = None
self.high_lim = None
# Sepctrum variables
self.mean_filter = None
# Setup camera
self.signal_camera = SignalCamera()
self.spectrum_camera = SignalCamera()
self.canvas = scene.SceneCanvas(show=True,
keys='interactive',
parent=self,
bgcolor=CONF.get(
self.CONF_SECTION, 'bgcolor'))
self.view_grid = self.canvas.central_widget.add_grid(margin=10)
# Signal
self.signal_view = self.view_grid.add_view(row=0,
col=1,
row_span=2,
camera=self.signal_camera)
axis_color = CONF.get(self.CONF_SECTION, 'axis_color')
self.signal_yaxis = AxisWidget(orientation='left',
axis_label='Amplitude',
axis_font_size=12,
tick_label_margin=5,
axis_color=axis_color,
tick_color=axis_color,
text_color=axis_color)
self.signal_yaxis.width_max = 60
self.view_grid.add_widget(self.signal_yaxis, row=0, col=0, row_span=2)
self.signal_xaxis = scene.AxisWidget(orientation='bottom',
axis_label='Time [s]',
axis_font_size=12,
tick_label_margin=5,
axis_color=axis_color,
tick_color=axis_color,
text_color=axis_color)
self.signal_xaxis.height_max = 55
self.view_grid.add_widget(self.signal_xaxis, row=2, col=1)
self.signal_yaxis.link_view(self.signal_view)
self.signal_xaxis.link_view(self.signal_view)
# Spectrum
self.spectrum_view = self.view_grid.add_view(
row=3, col=1, row_span=2, camera=self.spectrum_camera)
self.spectrum_yaxis = AxisWidget(orientation='left',
axis_label='Amplitude',
axis_font_size=12,
tick_label_margin=5,
axis_color=axis_color,
tick_color=axis_color,
text_color=axis_color)
self.spectrum_yaxis.width_max = 60
self.view_grid.add_widget(self.spectrum_yaxis,
row=3,
col=0,
row_span=2)
self.spectrum_xaxis = scene.AxisWidget(orientation='bottom',
axis_label='Frequency [Hz]',
axis_font_size=12,
axis_color=axis_color,
tick_color=axis_color,
text_color=axis_color)
self.spectrum_xaxis.height_max = 55
self.view_grid.add_widget(self.spectrum_xaxis, row=5, col=1)
self.spectrum_yaxis.link_view(self.spectrum_view)
self.spectrum_xaxis.link_view(self.spectrum_view)
self.signal_line = Line(parent=self.signal_view.scene, width=1)
self.spectrum_line = Line(parent=self.spectrum_view.scene, width=1)
self.spectrogram = Spectrogram([0], parent=self.spectrum_view.scene)
# ----- Set layout -----
# Widget layout
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.canvas.native)
# Set the whole layout
self.setLayout(layout)
###############################################################################
# Generation of an open mesh
K = [-1, -1]
open_mesh = sps.generate_quadric(K, nstep=[5, 5])
open_mesh_boundary = stop.mesh_boundary(open_mesh)
# Visualization
visb_sc = splt.visbrain_plot(mesh=open_mesh, caption='open mesh')
for bound in open_mesh_boundary:
points = open_mesh.vertices[bound]
s_rad = SourceObj('rad',
points,
color='red',
symbol='square',
radius_min=10)
visb_sc.add_to_subplot(s_rad)
lines = Line(pos=open_mesh.vertices[bound], width=10, color='b')
# wrap the vispy object using visbrain
l_obj = VispyObj('line', lines)
visb_sc.add_to_subplot(l_obj)
visb_sc.preview()
###############################################################################
# Mapping onto a planar disk
disk_mesh = smap.disk_conformal_mapping(open_mesh)
# Visualization
visb_sc2 = splt.visbrain_plot(mesh=disk_mesh, caption='disk mesh')
for bound in open_mesh_boundary:
points = disk_mesh.vertices[bound]
s_rad = SourceObj('rad',
points,
color='red',
def __init__(self, parent):
super(SignalDisplay, self).__init__(parent)
# Covenience transcripts
self.main = self.parent()
# Widget behavior
self.setAcceptDrops(True)
# Plot variables
self.sample_map = []
self.plot_containers = []
# TODO: Selected signal plot used for data shifting, colors, etc
self.master_pc = None
self.master_plot = None # TODO - to be deleted
self.curr_pc = None
self.rect_rel_w_pos = None
self.rect_rel_h_pos = None
self.resize_flag = False
self.highlight_mode = False
self.measurement_mode = False
self.autoscale = False
self.disconts_processed = False
self.data_map = DataMap()
self.data_source = sm.ODS
self.data_array = None
# Widget layout
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
# These variables are assigned in channels plugin
self.hidden_channels = None
self.visible_channels = None
# Setup camera
self.camera = SignalCamera()
# Autoslide
self.slide_worker_stopped = True
# TODO: this should be i config
self.slide_worker = TimerWorker(1)
self.slide_worker_thread = QThread()
self.slide_worker.moveToThread(self.slide_worker_thread)
self.start_slide_worker.connect(self.slide_worker.run)
self.stop_slide_worker.connect(self.slide_worker.interupt)
self.slide_worker.time_passed.connect(self.autoslide)
self.slide_worker_thread.start()
# Vispy canvas
self.canvas = scene.SceneCanvas(show=True, keys='interactive',
parent=self,
bgcolor=CONF.get(self.CONF_SECTION,
'bgcolor'))
self.canvas.connect(self.on_key_press)
self.canvas.connect(self.on_key_release)
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_mouse_wheel)
self.canvas.connect(self.on_resize)
# Timer to let the scene redraw if key is hit
self.event_time = time()
self.plot_update_done = False
# ??? Create two viewboxes - for labels and signals
self.signal_view = self.canvas.central_widget.add_view(
camera=self.camera)
self.cong_discontinuities = None
self.color_coding_mode = 0
self.color_palette = CONF.get(self.CONF_SECTION, 'color_palette')
self.update_cam_state()
# ----- Initial visuals operations-----
# TODO - Add crosshair color to CONF
# Measurements
ch_color = CONF.get(self.CONF_SECTION, 'init_crosshair_color')
self.crosshair = Crosshair(parent=self.signal_view.scene,
color=hex2rgba(ch_color))
m_color = CONF.get(self.CONF_SECTION, 'init_marker_color')
# TODO marker color
self.marker = Markers(parent=self.signal_view.scene)
self.xaxis = Axis(parent=self.signal_view.scene,
tick_direction=(0., 1.),
axis_width=1, tick_width=1,
anchors=('center', 'top'),
axis_color=m_color,
tick_color=m_color,
text_color=m_color)
self.x_tick_spacing = 1000
self.yaxis = Axis(parent=self.signal_view.scene,
tick_direction=(1., 0.),
axis_width=1, tick_width=1,
anchors=('left', 'center'),
axis_color=m_color,
tick_color=m_color,
text_color=m_color)
self.y_tick_spacing = 100
self.measure_line = Line(parent=self.signal_view.scene,
width=3, color=m_color)
# TODO - textbox
self.describe_text = Text(anchor_x='left',
anchor_y='bottom',
parent=self.signal_view.scene,
color=m_color)
# Signal highlighting
self.highlight_rec = Mesh(parent=self.signal_view.scene,
color=np.array([0., 0., 0., 0.]),
mode='triangle_fan')
# Grid
self.grid = None
# Discontinuity
self.disc_marker = LinearRegion(np.array([0, 0]),
np.array([[0., 0., 0., 0.],
[0., 0., 0., 0.]]),
parent=self.signal_view.scene)
self.signal_label_dict = {}
# Main signal visal with labels
w = CONF.get(self.CONF_SECTION, 'init_line_width')
self.signal_visual = Multiline(width=w,
parent=self.signal_view.scene)
self.label_visual = Text(anchor_x='left',
anchor_y='top',
parent=self.signal_view.scene)
# TODO - one set of x and y axes for measurements
# ----- Tool bar -----
btn_layout = QHBoxLayout()
for btn in self.setup_buttons():
if btn is None:
continue
btn.setAutoRaise(True)
btn.setIconSize(QSize(20, 20))
btn_layout.addWidget(btn)
# if options_button:
# btn_layout.addStretch()
# btn_layout.addWidget(options_button, Qt.AlignRight)
# TODO - this is temporary - solve the rendering in different thread
select_mode = QComboBox(self)
select_mode.insertItems(0, ['Browse', 'Research'])
antialias = CONF.get(self.CONF_SECTION, 'antialiasing')
if antialias == 'filter':
select_mode.setCurrentIndex(0)
elif antialias == 'min_max':
select_mode.setCurrentIndex(1)
select_mode.currentIndexChanged.connect(self.switch_display_mode)
btn_layout.addWidget(select_mode)
# Color coding
color_code = QComboBox(self)
color_code.insertItems(0, ['None', 'Channel', 'Group', 'Amplitude'])
color_code.currentIndexChanged.connect(self.switch_cc_mode)
btn_layout.addWidget(color_code)
# Metadata reload button
btn_layout.setAlignment(Qt.AlignLeft)
layout = create_plugin_layout(btn_layout)
# ----- Set layout -----
layout.addWidget(self.canvas.native)
# Set the whole layout
self.setLayout(layout)
# Connect signals
self.main.sig_file_opened.connect(self.initialize_data_map)
self.main.metadata_reloaded.connect(self.create_conglomerate_disconts)
self.plots_changed.connect(self.set_plot_update)
self.plots_changed.connect(self.subsample)
self.plots_changed.connect(self.rescale_grid)
self.input_recieved.connect(self.set_highlight_mode)
self.input_recieved.connect(self.show_measure_line)
self.canvas_resized.connect(self.update_subsample)
def __init__(self, viewer):
super(LassoSelectionMode, self).__init__(viewer)
self.line = Line(color='purple',
width=2,
method='agg',
parent=self._vispy_widget.canvas.scene)
print(open_mesh_boundary)
print('Here the mesh has a single boundary')
# WARNING : BrainObj should be added first before
visb_sc = splt.visbrain_plot(mesh=open_mesh, caption='open mesh')
# create points with vispy
for bound in open_mesh_boundary:
points = open_mesh.vertices[bound]
s_rad = SourceObj('rad',
points,
color='red',
symbol='square',
radius_min=10)
visb_sc.add_to_subplot(s_rad)
lines = Line(pos=open_mesh.vertices[bound], width=10, color='b')
# wrap the vispy object using visbrain
l_obj = VispyObj('line', lines)
visb_sc.add_to_subplot(l_obj)
visb_sc.preview()
# # here is how to get the vertices that define the boundary of
# # a texture on a mesh
mesh = sio.load_mesh('data/example_mesh.gii')
tex_parcel = sio.load_texture('data/example_texture_parcel.gii')
# bound_verts = stop.texture_boundary_vertices(tex_parcel.darray[0], 20, mesh.vertex_neighbors)
boundaries = list()
for val in np.unique(tex_parcel.darray[0]):
boundary = stop.texture_boundary(mesh, tex_parcel.darray[0], val)
boundaries.append(boundary)