def get_mapped_array_volume_view(self, entity_gid, mapped_array_gid, x_plane, y_plane, z_plane,
mapped_array_slice=None, **kwargs):
with h5.h5_file_for_gid(entity_gid) as entity_h5:
data_shape = entity_h5.array_data.shape
x_plane, y_plane, z_plane = preprocess_space_parameters(x_plane, y_plane, z_plane, data_shape[0],
data_shape[1], data_shape[2])
slice_x, slice_y, slice_z = entity_h5.get_volume_slice(x_plane, y_plane, z_plane)
connectivity_gid = entity_h5.connectivity.load()
with h5.h5_file_for_gid(mapped_array_gid) as mapped_array_h5:
if mapped_array_slice:
matrix_slice = parse_slice(mapped_array_slice)
measure = mapped_array_h5.array_data[matrix_slice]
else:
measure = mapped_array_h5.array_data[:]
connectivity_index = self.load_entity_by_gid(connectivity_gid)
if measure.shape != (connectivity_index.number_of_regions,):
raise ValueError('cannot project measure on the space')
result_x = measure[slice_x]
result_y = measure[slice_y]
result_z = measure[slice_z]
# Voxels outside the brain are -1. The indexing above is incorrect for those voxels as it
# associates the values of the last region measure[-1] to them.
# Here we replace those values with an out of scale value.
result_x[slice_x == -1] = measure.min() - 1
result_y[slice_y == -1] = measure.min() - 1
result_z[slice_z == -1] = measure.min() - 1
return [[result_x.tolist()],
[result_y.tolist()],
[result_z.tolist()]]
def compute_data_for_gradient_view(self, local_connectivity_gid,
selected_triangle):
"""
When the user loads an existent local connectivity and he picks a vertex from the used surface, this
method computes the data needed for drawing a gradient view corresponding to that vertex.
Returns a json which contains the data needed for drawing a gradient view for the selected vertex.
"""
triangle_index = int(selected_triangle)
lconn_h5 = h5.h5_file_for_gid(local_connectivity_gid)
surface_h5 = h5.h5_file_for_gid(lconn_h5.surface.load())
assert isinstance(surface_h5, SurfaceH5)
vertex_index = int(surface_h5.triangles[triangle_index][0])
assert isinstance(lconn_h5, LocalConnectivityH5)
lconn_matrix = lconn_h5.matrix.load()
picked_data = list(lconn_matrix[vertex_index].toarray().squeeze())
lconn_h5.close()
result = []
number_of_split_slices = surface_h5.number_of_split_slices.load()
if number_of_split_slices <= 1:
result.append(picked_data)
else:
for slice_number in range(number_of_split_slices):
start_idx, end_idx = surface_h5.get_slice_vertex_boundaries(
slice_number)
result.append(picked_data[start_idx:end_idx])
surface_h5.close()
result = {'data': json.dumps(result)}
return result
def read_data_page_split(self,
time_series_gid,
from_idx,
to_idx,
step=None,
specific_slices=None):
with h5.h5_file_for_gid(time_series_gid) as time_series_h5:
assert isinstance(time_series_h5, TimeSeriesH5)
basic_result = time_series_h5.read_data_page(
from_idx, to_idx, step, specific_slices)
if not isinstance(time_series_h5, TimeSeriesSurfaceH5):
return basic_result.tolist()
surface_gid = time_series_h5.surface.load()
result = []
with h5.h5_file_for_gid(surface_gid) as surface_h5:
assert isinstance(surface_h5, SurfaceH5)
number_of_split_slices = surface_h5.number_of_split_slices.load()
if number_of_split_slices <= 1:
result.append(basic_result.tolist())
else:
for slice_number in range(surface_h5.number_of_split_slices):
start_idx, end_idx = surface_h5.get_slice_vertex_boundaries(
slice_number)
result.append(basic_result[:, start_idx:end_idx].tolist())
return result
def generate_region_boundaries(self, surface_gid, region_mapping_gid):
"""
Return the full region boundaries, including: vertices, normals and lines indices.
"""
boundary_vertices = []
boundary_lines = []
boundary_normals = []
with h5.h5_file_for_gid(region_mapping_gid) as rm_h5:
array_data = rm_h5.array_data[:]
with h5.h5_file_for_gid(surface_gid) as surface_h5:
for slice_idx in range(surface_h5.get_number_of_split_slices()):
# Generate the boundaries sliced for the off case where we might overflow the buffer capacity
slice_triangles = surface_h5.get_triangles_slice(slice_idx)
slice_vertices = surface_h5.get_vertices_slice(slice_idx)
slice_normals = surface_h5.get_vertex_normals_slice(slice_idx)
first_index_in_slice = surface_h5.split_slices.load()[str(
slice_idx)][KEY_VERTICES][KEY_START]
# These will keep track of the vertices / triangles / normals for this slice that have
# been processed and were found as a part of the boundary
processed_vertices = []
processed_triangles = []
processed_normals = []
for triangle in slice_triangles:
triangle += first_index_in_slice
# Check if there are two points from a triangles that are in separate regions
# then send this to further processing that will generate the corresponding
# region separation lines depending on the 3rd point from the triangle
rt0, rt1, rt2 = array_data[triangle]
if rt0 - rt1:
reg_idx1, reg_idx2, dangling_idx = 0, 1, 2
elif rt1 - rt2:
reg_idx1, reg_idx2, dangling_idx = 1, 2, 0
elif rt2 - rt0:
reg_idx1, reg_idx2, dangling_idx = 2, 0, 1
else:
continue
lines_vert, lines_ind, lines_norm = self._process_triangle(
triangle, reg_idx1, reg_idx2, dangling_idx,
first_index_in_slice, array_data, slice_vertices,
slice_normals)
ind_offset = len(processed_vertices) / 3
processed_vertices.extend(lines_vert)
processed_normals.extend(lines_norm)
processed_triangles.extend(
[ind + ind_offset for ind in lines_ind])
boundary_vertices.append(processed_vertices)
boundary_lines.append(processed_triangles)
boundary_normals.append(processed_normals)
return numpy.array(
[boundary_vertices, boundary_lines,
boundary_normals]).tolist()
def extract_source_labels(self, datatype_matrix):
# type: (DataTypeMatrix) -> list
if hasattr(datatype_matrix, "fk_connectivity_gid"):
with h5.h5_file_for_gid(datatype_matrix.fk_connectivity_gid) as conn_h5:
labels = list(conn_h5.region_labels.load())
return labels
if hasattr(datatype_matrix, "fk_source_gid"):
with h5.h5_file_for_gid(datatype_matrix.fk_source_gid) as source_h5:
labels = self.get_space_labels(source_h5)
return labels
return None
def launch(self, view_model):
# type: (PCAModel) -> dict
"""Construct data for visualization and launch it."""
with h5.h5_file_for_gid(view_model.pca) as ts_h5:
source_gid = ts_h5.source.load()
with h5.h5_file_for_gid(source_gid) as source_h5:
labels_data = self.get_space_labels(source_h5)
fractions_update_url = URLGenerator.build_h5_url(view_model.pca, 'read_fractions_data')
weights_update_url = URLGenerator.build_h5_url(view_model.pca, 'read_weights_data')
return self.build_display_result("pca/view", dict(labels_data=json.dumps(labels_data),
fractions_update_url=fractions_update_url,
weights_update_url=weights_update_url))
def launch(self, view_model):
# type: (ConnectivityViewerModel) -> dict
"""
Given the input connectivity data and the surface data,
build the HTML response to be displayed.
"""
connectivity, colors, rays = self._load_input_data(view_model)
global_params, global_pages = self._compute_connectivity_global_params(connectivity)
if view_model.surface_data is not None:
with h5.h5_file_for_gid(view_model.surface_data) as surface_h5:
url_vertices, url_normals, _, url_triangles, _ = SurfaceURLGenerator.get_urls_for_rendering(surface_h5)
else:
url_vertices, url_normals, url_triangles = [], [], []
global_params["urlVertices"] = json.dumps(url_vertices)
global_params["urlTriangles"] = json.dumps(url_triangles)
global_params["urlNormals"] = json.dumps(url_normals)
global_params['isSingleMode'] = False
result_params, result_pages = Connectivity2DViewer().compute_parameters(connectivity, colors, rays,
view_model.step)
result_params.update(global_params)
result_pages.update(global_pages)
_params, _pages = Connectivity3DViewer().compute_parameters(connectivity, colors, rays)
result_params.update(_params)
result_pages.update(_pages)
return self.build_display_result("connectivity/main_connectivity", result_params, result_pages)
def launch(self, view_model):
# type: (PearsonCorrelationCoefficientVisualizerModel) -> dict
"""Construct data for visualization and launch it."""
with h5.h5_file_for_gid(view_model.datatype) as datatype_h5:
matrix_shape = datatype_h5.array_data.shape[0:2]
ts_gid = datatype_h5.source.load()
ts_index = self.load_entity_by_gid(ts_gid)
state_list = ts_index.get_labels_for_dimension(1)
mode_list = list(range(ts_index.data_length_4d))
with h5.h5_file_for_index(ts_index) as ts_h5:
labels = self.get_space_labels(ts_h5)
if not labels:
labels = None
pars = dict(matrix_labels=json.dumps(labels),
matrix_shape=json.dumps(matrix_shape),
viewer_title='Pearson Edge Bundle',
url_base=URLGenerator.build_h5_url(view_model.datatype.hex, 'get_correlation_data', flatten="True",
parameter=''),
state_variable=0,
mode=mode_list[0],
state_list=state_list,
mode_list=mode_list,
pearson_min=CorrelationCoefficients.PEARSON_MIN,
pearson_max=CorrelationCoefficients.PEARSON_MAX,
thresh=0.5
)
return self.build_display_result("pearson_edge_bundle/view", pars)
def display_surface(surface_gid, region_mapping_gid=None):
"""
Generates the HTML for displaying the surface with the given ID.
"""
surface_h5 = h5.h5_file_for_gid(surface_gid)
if surface_h5 is None:
raise MissingDataException(
SpatioTemporalController.MSG_MISSING_SURFACE + "!!")
common.add2session(PARAM_SURFACE, surface_gid)
url_vertices_pick, url_normals_pick, url_triangles_pick = SurfaceURLGenerator.get_urls_for_pick_rendering(
surface_h5)
url_vertices, url_normals, _, url_triangles, _ = SurfaceURLGenerator.get_urls_for_rendering(
surface_h5, region_mapping_gid)
surface_h5.close()
return {
'urlVerticesPick': json.dumps(url_vertices_pick),
'urlTrianglesPick': json.dumps(url_triangles_pick),
'urlNormalsPick': json.dumps(url_normals_pick),
'urlVertices': json.dumps(url_vertices),
'urlTriangles': json.dumps(url_triangles),
'urlNormals': json.dumps(url_normals),
'brainCenter': json.dumps(surface_h5.center())
}
def get_view_region(self,
ts_h5,
volume_rm_h5,
from_idx,
to_idx,
x,
y,
z,
var=0,
mode=0):
idx_slices = slice(x, x + 1), slice(y, y + 1), slice(z, z + 1)
idx = int(volume_rm_h5.array_data[idx_slices])
time_length = ts_h5.data.shape[0]
var, mode = int(var), int(mode)
voxel_slices = prepare_time_slice(time_length), slice(
var, var + 1), slice(idx, idx + 1), slice(mode, mode + 1)
connectivity_gid = volume_rm_h5.connectivity.load()
with h5.h5_file_for_gid(connectivity_gid) as connectivity_h5:
label = connectivity_h5.region_labels.load()[idx]
background, back_min, back_max = None, None, None
if idx < 0:
back_min, back_max = ts_h5.get_min_max_values()
background = numpy.ones(
(time_length, 1)) * ts_h5.out_of_range(back_min)
label = 'background'
result = postprocess_voxel_ts(ts_h5, voxel_slices, background,
back_min, back_max, label)
return result
def get_volume_view(self, entity_gid, **kwargs):
with h5.h5_file_for_gid(entity_gid) as ts_region_h5:
if isinstance(ts_region_h5, TimeSeriesRegionH5):
return self.prepare_view_region(ts_region_h5, **kwargs)
volume_view = ts_region_h5.get_volume_view(**kwargs)
return volume_view
def prepare_view_region(self,
ts_h5,
x_plane,
y_plane,
z_plane,
from_idx=None,
to_idx=None,
var=0,
mode=0):
region_mapping_volume_gid = ts_h5.region_mapping_volume.load()
if region_mapping_volume_gid is None:
raise Exception(
"Invalid method called for TS without Volume Mapping!")
with h5.h5_file_for_gid(region_mapping_volume_gid) as volume_rm_h5:
volume_rm_shape = volume_rm_h5.array_data.shape
# Work with space inside Volume:
x_plane, y_plane, z_plane = preprocess_space_parameters(
x_plane, y_plane, z_plane, volume_rm_shape[0],
volume_rm_shape[1], volume_rm_shape[2])
region = self.get_view_region(ts_h5, volume_rm_h5, from_idx,
to_idx, x_plane, y_plane, z_plane,
var, mode)
return region
def launch(self, view_model):
# type: (ImaginaryCoherenceDisplayModel) -> dict
"""
Draw interactive display.
"""
self.log.debug("Plot started...")
with h5.h5_file_for_gid(view_model.input_data) as input_data_h5:
source_gid = input_data_h5.source.load()
source_index = self.load_entity_by_gid(source_gid)
params = dict(
plotName=source_index.type,
xAxisName="Frequency [kHz]",
yAxisName="CohSpec",
available_xScale=["Linear", "Logarithmic"],
available_spectrum=json.dumps(input_data_h5.spectrum_types),
spectrum_list=input_data_h5.spectrum_types,
xscale="Linear",
spectrum=input_data_h5.spectrum_types[0],
url_base=URLGenerator.build_h5_url(view_model.input_data,
'get_spectrum_data',
parameter=""),
# TODO investigate the static xmin and xmax values
xmin=0.02,
xmax=0.8)
return self.build_display_result("complex_coherence/view", params)
def get_required_memory_size(self, view_model):
# type: (ImaginaryCoherenceDisplayModel) -> numpy.ndarray
"""
Return the required memory to run this algorithm.
"""
with h5.h5_file_for_gid(view_model.input_data) as input_data_h5:
required_memory = numpy.prod(input_data_h5.read_data_shape()) * 8
return required_memory
def get_space_labels(self, ts_h5):
"""
:return: An array of strings with the connectivity node labels.
"""
if type(ts_h5) is TimeSeriesRegionH5:
connectivity_gid = ts_h5.connectivity.load()
if connectivity_gid is None:
return []
with h5.h5_file_for_gid(connectivity_gid) as conn_h5:
return list(conn_h5.region_labels.load())
if isinstance(ts_h5, TimeSeriesSensorsH5):
sensors_gid = ts_h5.sensors.load()
if sensors_gid is None:
return []
with h5.h5_file_for_gid(sensors_gid) as sensors_h5:
return list(sensors_h5.labels.load())
return ts_h5.get_space_labels()
def launch(self, view_model):
params = dict(title="Local Connectivity Visualizer",
extended_view=False,
isOneToOneMapping=False,
hasRegionMap=False)
local_conn_h5 = h5.h5_file_for_gid(view_model.local_conn)
with local_conn_h5:
surface_gid = local_conn_h5.surface.load()
min_value, max_value = local_conn_h5.get_min_max_values()
with h5.h5_file_for_gid(surface_gid) as surface_h5:
params.update(self._compute_surface_params(surface_h5))
params['local_connectivity_gid'] = view_model.local_conn.hex
params['minValue'] = min_value
params['maxValue'] = max_value
return self.build_display_result(
"local_connectivity/view",
params,
pages={"controlPage": "local_connectivity/controls"})
def launch(self, view_model):
# type: (WaveletSpectrogramVisualizerModel) -> dict
with h5.h5_file_for_gid(view_model.input_data) as input_h5:
shape = input_h5.array_data.shape
input_sample_period = input_h5.sample_period.load()
input_frequencies = input_h5.frequencies.load()
ts_index = self.load_entity_by_gid(input_h5.source.load())
slices = (slice(shape[0]), slice(shape[1]), slice(0, 1, None),
slice(0, shape[3], None), slice(0, 1, None))
data_matrix = input_h5.power[slices]
data_matrix = data_matrix.sum(axis=3)
assert isinstance(ts_index, TimeSeriesIndex)
wavelet_sample_period = ts_index.sample_period * max(
(1, int(input_sample_period / ts_index.sample_period)))
end_time = ts_index.start_time + (wavelet_sample_period * shape[1])
if len(input_frequencies):
freq_lo = input_frequencies[0]
freq_hi = input_frequencies[-1]
else:
freq_lo = 0
freq_hi = 1
scale_range_start = max(1, int(0.25 * shape[1]))
scale_range_end = max(1, int(0.75 * shape[1]))
scale_min = data_matrix[:, scale_range_start:scale_range_end, :].min()
scale_max = data_matrix[:, scale_range_start:scale_range_end, :].max()
matrix_data = ABCDisplayer.dump_with_precision(data_matrix.flat)
matrix_shape = json.dumps(data_matrix.squeeze().shape)
params = dict(canvasName="Wavelet Spectrogram for: " + ts_index.title,
xAxisName="Time (%s)" % str(ts_index.sample_period_unit),
yAxisName="Frequency (%s)" % str("kHz"),
title=self._ui_name,
matrix_data=matrix_data,
matrix_shape=matrix_shape,
start_time=ts_index.start_time,
end_time=end_time,
freq_lo=freq_lo,
freq_hi=freq_hi,
vmin=scale_min,
vmax=scale_max)
return self.build_display_result(
"wavelet/wavelet_view",
params,
pages={"controlPage": "wavelet/controls"})
def get_voxel_region(self, region_mapping_volume_gid, x_plane, y_plane, z_plane):
with h5.h5_file_for_gid(region_mapping_volume_gid) as entity_h5:
data_shape = entity_h5.array_data.shape
x_plane, y_plane, z_plane = preprocess_space_parameters(x_plane, y_plane, z_plane, data_shape[0],
data_shape[1], data_shape[2])
slices = slice(x_plane, x_plane + 1), slice(y_plane, y_plane + 1), slice(z_plane, z_plane + 1)
voxel = entity_h5.array_data[slices][0, 0, 0]
connectivity_gid = entity_h5.connectivity.load()
if voxel != -1:
conn = self.load_traited_by_gid(connectivity_gid)
return conn.region_labels[int(voxel)]
else:
return 'background'
def _base_before_launch(self, data_file, region_volume_gid):
if data_file is None:
raise LaunchException("Please select a file to import!")
if region_volume_gid is not None:
rvm_h5 = h5.h5_file_for_gid(region_volume_gid)
self._attempt_to_cache_regionmap(rvm_h5)
self.region_volume_shape = rvm_h5.read_data_shape()
self.region_volume_h5 = rvm_h5
datatype = Tracts()
dummy_rvm = RegionVolumeMapping()
dummy_rvm.gid = region_volume_gid
datatype.region_volume_map = dummy_rvm
return datatype
def launch(self, view_model):
# type: (CrossCoherenceVisualizerModel) -> dict
"""Construct data for visualization and launch it."""
with h5.h5_file_for_gid(view_model.datatype) as datatype_h5:
# get data from coherence datatype h5, convert to json
frequency = ABCDisplayer.dump_with_precision(
datatype_h5.frequency.load().flat)
array_data = datatype_h5.array_data[:]
params = self.compute_raw_matrix_params(array_data)
params.update(frequency=frequency)
params.update(matrix_strides=json.dumps(
[x / array_data.itemsize for x in array_data.strides]))
return self.build_display_result("cross_coherence/view", params)
def _read_from_h5(self, entity_gid, method_name, datatype_kwargs='null', **kwargs):
self.logger.debug("Starting to read HDF5: " + entity_gid + "/" + method_name + "/" + str(kwargs))
datatype_kwargs = json.loads(datatype_kwargs)
if datatype_kwargs:
for key, value in six.iteritems(datatype_kwargs):
kwargs[key] = load_entity_by_gid(value)
with h5.h5_file_for_gid(entity_gid) as entity_h5:
result = getattr(entity_h5, method_name)
if kwargs:
result = result(**kwargs)
else:
result = result()
return result
def get_voxel_time_series(self, entity_gid, **kwargs):
"""
Retrieve for a given voxel (x,y,z) the entire timeline.
:param x: int coordinate
:param y: int coordinate
:param z: int coordinate
:return: A complex dictionary with information about current voxel.
The main part will be a vector with all the values over time from the x,y,z coordinates.
"""
with h5.h5_file_for_gid(entity_gid) as ts_h5:
if isinstance(ts_h5, TimeSeriesRegionH5):
return self.prepare_view_region(ts_h5, **kwargs)
data = ts_h5.get_voxel_time_series(**kwargs)
return data
def launch(self, view_model):
# type: (FourierSpectrumModel) -> dict
self.log.debug("Plot started...")
# these partial loads are dangerous for TS and FS instances, but efficient
fourier_spectrum = FourierSpectrum()
with h5.h5_file_for_gid(view_model.input_data) as input_h5:
shape = list(input_h5.array_data.shape)
fourier_spectrum.segment_length = input_h5.segment_length.load()
fourier_spectrum.windowing_function = input_h5.windowing_function.load(
)
ts_index = self.load_entity_by_gid(input_h5.source.load())
state_list = ts_index.get_labels_for_dimension(1)
if len(state_list) == 0:
state_list = list(range(shape[1]))
fourier_spectrum.source = TimeSeries(
sample_period=ts_index.sample_period)
mode_list = list(range(shape[3]))
available_scales = ["Linear", "Logarithmic"]
params = dict(matrix_shape=json.dumps([shape[0], shape[2]]),
plotName=ts_index.title,
url_base=URLGenerator.build_h5_url(view_model.input_data,
"get_fourier_data",
parameter=""),
xAxisName="Frequency [kHz]",
yAxisName="Power",
available_scales=available_scales,
state_list=state_list,
mode_list=mode_list,
normalize_list=["no", "yes"],
normalize="no",
state_variable=state_list[0],
mode=mode_list[0],
xscale=available_scales[0],
yscale=available_scales[0],
x_values=json.dumps(fourier_spectrum.frequency[slice(
shape[0])].tolist()),
xmin=fourier_spectrum.freq_step,
xmax=fourier_spectrum.max_freq)
return self.build_display_result("fourier_spectrum/view", params)
def get_grouped_space_labels(self, ts_h5):
"""
:return: A structure of this form [('left', [(idx, lh_label)...]), ('right': [(idx, rh_label) ...])]
"""
if isinstance(ts_h5, TimeSeriesSensorsH5):
sensors_gid = ts_h5.sensors.load()
with h5.h5_file_for_gid(sensors_gid) as sensors_h5:
labels = sensors_h5.labels.load()
# TODO uncomment this when the UI component will be able to scale for many groups
# if isinstance(ts_h5, TimeSeriesSEEGH5):
# return SensorsInternal.group_sensors_to_electrodes(labels)
return [('', list(enumerate(labels)))]
if isinstance(ts_h5, TimeSeriesRegionH5):
connectivity_gid = ts_h5.connectivity.load()
conn = self.load_traited_by_gid(connectivity_gid)
assert isinstance(conn, Connectivity)
return conn.get_grouped_space_labels()
return ts_h5.get_grouped_space_labels()
def prepare_stimuli_surface_from_view_model(self,
view_model,
load_full_surface=False):
# type: (SurfaceStimulusCreatorModel, bool) -> StimuliSurface
stimuli_surface = StimuliSurface()
stimuli_surface.focal_points_triangles = view_model.focal_points_triangles
stimuli_surface.spatial = view_model.spatial
stimuli_surface.temporal = view_model.temporal
if load_full_surface:
stimuli_surface.surface = self.load_traited_by_gid(
view_model.surface)
else:
stimuli_surface.surface = CorticalSurface()
stimuli_surface.gid = view_model.surface
# We need to load surface triangles on stimuli because focal_points_surface property needs to acces them
with h5.h5_file_for_gid(view_model.surface) as surface_h5:
stimuli_surface.surface.triangles = surface_h5.triangles.load()
return stimuli_surface
def _params_meg_sensors(self,
meg_sensors,
projection_surface=None,
shell_surface=None):
params = prepare_sensors_as_measure_points_params(meg_sensors)
shell_surface = ensure_shell_surface(self.current_project_id,
shell_surface)
params.update({
'shellObject':
self.prepare_shell_surface_params(shell_surface,
SurfaceURLGenerator),
'urlVertices':
'',
'urlTriangles':
'',
'urlLines':
'[]',
'urlNormals':
'',
'boundaryURL':
'',
'urlRegionMap':
''
})
if projection_surface is not None:
with h5.h5_file_for_gid(
projection_surface.gid) as projection_surface_h5:
params.update(
self._compute_surface_params(projection_surface_h5))
return self.build_display_result(
"sensors/sensors_eeg",
params,
pages={"controlPage": "sensors/sensors_controls"})
def _params_eeg_sensors(self,
eeg_sensors,
eeg_cap=None,
shell_surface=None):
if eeg_cap is None:
eeg_cap = ensure_shell_surface(
self.current_project_id, eeg_cap,
SurfaceTypesEnum.EEG_CAP_SURFACE.value)
params = prepare_mapped_sensors_as_measure_points_params(
eeg_sensors, eeg_cap, self.stored_adapter.id)
shell_surface = ensure_shell_surface(self.current_project_id,
shell_surface)
params.update({
'shellObject':
self.prepare_shell_surface_params(shell_surface,
SurfaceURLGenerator),
'urlVertices':
'',
'urlTriangles':
'',
'urlLines':
'[]',
'urlNormals':
''
})
if eeg_cap is not None:
with h5.h5_file_for_gid(eeg_cap.gid) as eeg_cap_h5:
params.update(self._compute_surface_params(eeg_cap_h5))
return self.build_display_result(
"sensors/sensors_eeg",
params,
pages={"controlPage": "sensors/sensors_controls"})
def launch(self, view_model):
# type: (ConnectivityAnnotationsViewModel) -> dict
annotations_index = self.load_entity_by_gid(
view_model.annotations_index)
if view_model.connectivity_index is None:
connectivity_index = self.load_entity_by_gid(
annotations_index.fk_connectivity_gid)
else:
connectivity_index = self.load_entity_by_gid(
view_model.connectivity_index)
if view_model.region_mapping_index is None:
region_map = dao.get_generic_entity(RegionMappingIndex,
connectivity_index.gid,
'fk_connectivity_gid')
if len(region_map) < 1:
raise LaunchException(
"Can not launch this viewer unless we have at least a RegionMapping for the current Connectivity!"
)
region_mapping_index = region_map[0]
else:
region_mapping_index = self.load_entity_by_gid(
view_model.region_mapping_index)
boundary_url = SurfaceURLGenerator.get_url_for_region_boundaries(
region_mapping_index.fk_surface_gid, region_mapping_index.gid,
self.stored_adapter.id)
surface_h5 = h5.h5_file_for_gid(region_mapping_index.fk_surface_gid)
assert isinstance(surface_h5, SurfaceH5)
url_vertices_pick, url_normals_pick, url_triangles_pick = SurfaceURLGenerator.get_urls_for_pick_rendering(
surface_h5)
url_vertices, url_normals, _, url_triangles, url_region_map = SurfaceURLGenerator.get_urls_for_rendering(
surface_h5, region_mapping_index.gid)
params = dict(title="Connectivity Annotations Visualizer",
annotationsTreeUrl=URLGenerator.build_url(
self.stored_adapter.id, 'tree_json',
view_model.annotations_index),
urlTriangleToRegion=URLGenerator.build_url(
self.stored_adapter.id, "get_triangles_mapping",
region_mapping_index.gid),
urlActivationPatterns=URLGenerator.paths2url(
view_model.annotations_index,
"get_activation_patterns"),
minValue=0,
maxValue=connectivity_index.number_of_regions - 1,
urlColors=json.dumps(url_region_map),
urlVerticesPick=json.dumps(url_vertices_pick),
urlTrianglesPick=json.dumps(url_triangles_pick),
urlNormalsPick=json.dumps(url_normals_pick),
brainCenter=json.dumps(surface_h5.center()),
urlVertices=json.dumps(url_vertices),
urlTriangles=json.dumps(url_triangles),
urlNormals=json.dumps(url_normals),
urlRegionBoundaries=boundary_url)
return self.build_display_result(
"annotations/annotations_view",
params,
pages={"controlPage": "annotations/annotations_controls"})
