def get_metric_matrix(self, datatype_group, selected_metric=None):
self.model = PseIsoModel.from_db(datatype_group.fk_operation_group)
if selected_metric is None:
selected_metric = list(self.model.metrics)[0]
data_matrix = self.model.apriori_data[selected_metric]
data_matrix = numpy.rot90(data_matrix)
data_matrix = numpy.flipud(data_matrix)
matrix_data = ABCDisplayer.dump_with_precision(data_matrix.flat)
matrix_guids = self.model.datatypes_gids
matrix_guids = numpy.rot90(matrix_guids)
matrix_shape = json.dumps(data_matrix.squeeze().shape)
x_min = self.model.apriori_x[0]
x_max = self.model.apriori_x[self.model.apriori_x.size - 1]
y_min = self.model.apriori_y[0]
y_max = self.model.apriori_y[self.model.apriori_y.size - 1]
vmin = data_matrix.min()
vmax = data_matrix.max()
return dict(matrix_data=matrix_data,
matrix_guids=json.dumps(matrix_guids.flatten().tolist()),
matrix_shape=matrix_shape,
color_metric=selected_metric,
x_min=x_min,
x_max=x_max,
y_min=y_min,
y_max=y_max,
vmin=vmin,
vmax=vmax)
def launch(self, view_model):
# type: (TopographicViewerModel) -> dict
connectivities_idx = []
measures_ht = []
for measure in [view_model.data_0, view_model.data_1, view_model.data_2]:
if measure is not None:
measure_index = self.load_entity_by_gid(measure)
measures_ht.append(h5.load_from_index(measure_index))
conn_index = self.load_entity_by_gid(measure_index.fk_connectivity_gid)
connectivities_idx.append(conn_index)
with h5.h5_file_for_index(connectivities_idx[0]) as conn_h5:
centres = conn_h5.centres.load()
sensor_locations = TopographyCalculations.normalize_sensors(centres)
sensor_number = len(sensor_locations)
arrays = []
titles = []
min_vals = []
max_vals = []
data_array = []
data_arrays = []
for i, measure in enumerate(measures_ht):
if connectivities_idx[i].number_of_regions != sensor_number:
raise Exception("Use the same connectivity!!!")
arrays.append(measure.array_data.tolist())
titles.append(measure.title)
min_vals.append(measure.array_data.min())
max_vals.append(measure.array_data.max())
color_bar_min = min(min_vals)
color_bar_max = max(max_vals)
for i, array_data in enumerate(arrays):
try:
data_array = TopographyCalculations.compute_topography_data(array_data, sensor_locations)
# We always access the first element because only one connectivity can be used at one time
first_label = h5.load_from_index(connectivities_idx[0]).hemispheres[0]
if first_label:
data_array = numpy.rot90(data_array, k=1, axes=(0, 1))
else:
data_array = numpy.rot90(data_array, k=-1, axes=(0, 1))
if numpy.any(numpy.isnan(array_data)):
titles[i] = titles[i] + " - Topography contains nan"
if not numpy.any(array_data):
titles[i] = titles[i] + " - Topography data is all zeros"
data_arrays.append(ABCDisplayer.dump_with_precision(data_array.flat))
except KeyError as err:
self.log.exception(err)
raise LaunchException("The measure points location is not compatible with this viewer ", err)
params = dict(matrix_datas=data_arrays,
matrix_shape=json.dumps(data_array.squeeze().shape),
titles=titles,
vmin=color_bar_min,
vmax=color_bar_max)
return self.build_display_result("topographic/view", params,
pages={"controlPage": "topographic/controls"})
def get_metric_matrix(self, datatype_group, selected_metric=None):
self.model = PseIsoModel.from_db(datatype_group.fk_operation_group)
if selected_metric is None:
selected_metric = self.model.metrics.keys()[0]
data_matrix = self.model.apriori_data[selected_metric]
data_matrix = numpy.rot90(data_matrix)
data_matrix = numpy.flipud(data_matrix)
matrix_data = ABCDisplayer.dump_with_precision(data_matrix.flat)
matrix_guids = self.model.datatypes_gids
matrix_guids = numpy.rot90(matrix_guids)
matrix_shape = json.dumps(data_matrix.squeeze().shape)
x_min = self.model.apriori_x[0]
x_max = self.model.apriori_x[self.model.apriori_x.size - 1]
y_min = self.model.apriori_y[0]
y_max = self.model.apriori_y[self.model.apriori_y.size - 1]
vmin = data_matrix.min()
vmax = data_matrix.max()
return dict(matrix_data=matrix_data,
matrix_guids=json.dumps(matrix_guids.flatten().tolist()),
matrix_shape=matrix_shape,
color_metric=selected_metric,
x_min=x_min,
x_max=x_max,
y_min=y_min,
y_max=y_max,
vmin=vmin,
vmax=vmax)
def get_metric_matrix(self, datatype_group_gid, selected_metric=None):
pse_iso = PSEIsoGroupModel(datatype_group_gid)
if selected_metric is None:
selected_metric = list(pse_iso.get_available_metric_keys())[0]
data_matrix = pse_iso.apriori_data[selected_metric]
data_matrix = numpy.rot90(data_matrix)
data_matrix = numpy.flipud(data_matrix)
vmin = numpy.nanmin(data_matrix)
vmax = numpy.nanmax(data_matrix)
# TODO: We replace NaN values here. To be addressed by task TVB-2660.
data_matrix[numpy.isnan(data_matrix)] = vmin - 1
matrix_data = ABCDisplayer.dump_with_precision(data_matrix.flat)
matrix_guids = pse_iso.datatypes_gids
matrix_guids = numpy.rot90(matrix_guids)
matrix_shape = json.dumps(data_matrix.squeeze().shape)
x_min = pse_iso.apriori_x[0]
x_max = pse_iso.apriori_x[-1]
y_min = pse_iso.apriori_y[0]
y_max = pse_iso.apriori_y[-1]
return dict(matrix_data=matrix_data,
matrix_guids=json.dumps(matrix_guids.flatten().tolist()),
matrix_shape=matrix_shape,
color_metric=selected_metric,
xAxisName=pse_iso.get_range1_key(),
yAxisName=pse_iso.get_range2_key(),
available_metrics=pse_iso.get_available_metric_keys(),
x_min=x_min,
x_max=x_max,
y_min=y_min,
y_max=y_max,
vmin=vmin,
vmax=vmax)
def compute_raw_matrix_params(matrix):
"""
Serializes matrix data, shape and stride metadata to json
"""
matrix_data = ABCDisplayer.dump_with_precision(matrix.flat)
matrix_shape = json.dumps(matrix.shape)
return dict(matrix_data=matrix_data, matrix_shape=matrix_shape)
def compute_raw_matrix_params(matrix):
"""
Serializes matrix data, shape and stride metadata to json
"""
matrix_data = ABCDisplayer.dump_with_precision(matrix.flat)
matrix_shape = json.dumps(matrix.shape)
return dict(matrix_data=matrix_data,
matrix_shape=matrix_shape)
def launch(self, datatype):
"""Construct data for visualization and launch it."""
# get data from coher datatype, convert to json
frequency = ABCDisplayer.dump_with_precision(datatype.get_data('frequency').flat)
array_data = datatype.get_data('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 launch(self, view_model):
# type: (WaveletSpectrogramVisualizerModel) -> dict
input_index = self.load_entity_by_gid(view_model.input_data.hex)
with h5.h5_file_for_index(input_index) as input_h5:
shape = input_h5.array_data.shape
input_sample_period = input_h5.sample_period.load()
input_frequencies = input_h5.frequencies.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)
ts_index = self.load_entity_by_gid(input_index.fk_source_gid)
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 launch(self, datatype):
"""Construct data for visualization and launch it."""
# get data from coher datatype, convert to json
frequency = ABCDisplayer.dump_with_precision(
datatype.get_data('frequency').flat)
array_data = datatype.get_data('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 launch(self, datatype):
"""Construct data for visualization and launch it."""
datatype_h5_class, datatype_h5_path = self._load_h5_of_gid(datatype.gid)
with datatype_h5_class(datatype_h5_path) as datatype_h5:
# get data from coher 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 launch(self, data_0, data_1=None, data_2=None):
connectivity = data_0.connectivity
sensor_locations = TopographyCalculations.normalize_sensors(
connectivity.centres)
sensor_number = len(sensor_locations)
arrays = []
titles = []
min_vals = []
max_vals = []
data_array = []
data_arrays = []
for measure in [data_0, data_1, data_2]:
if measure is not None:
if len(measure.connectivity.centres) != sensor_number:
raise Exception("Use the same connectivity!!!")
arrays.append(measure.array_data.tolist())
titles.append(measure.title)
min_vals.append(measure.array_data.min())
max_vals.append(measure.array_data.max())
color_bar_min = min(min_vals)
color_bar_max = max(max_vals)
for i, array_data in enumerate(arrays):
try:
data_array = TopographyCalculations.compute_topography_data(
array_data, sensor_locations)
if numpy.any(numpy.isnan(array_data)):
titles[i] = titles[i] + " - Topography contains nan"
if not numpy.any(array_data):
titles[i] = titles[i] + " - Topography data is all zeros"
data_arrays.append(
ABCDisplayer.dump_with_precision(data_array.flat))
except KeyError as err:
self.log.exception(err)
raise LaunchException(
"The measure points location is not compatible with this viewer ",
err)
params = dict(matrix_datas=data_arrays,
matrix_shape=json.dumps(data_array.squeeze().shape),
titles=titles,
vmin=color_bar_min,
vmax=color_bar_max)
return self.build_display_result(
"topographic/view",
params,
pages={"controlPage": "topographic/controls"})
def launch(self, view_model):
# type: (CrossCoherenceVisualizerModel) -> dict
"""Construct data for visualization and launch it."""
coherence_gid = view_model.datatype
coherence_index = self.load_entity_by_gid(coherence_gid)
with h5.h5_file_for_index(coherence_index) 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 launch(self, input_data, **kwarg):
shape = input_data.read_data_shape()
start_time = input_data.source.start_time
wavelet_sample_period = input_data.source.sample_period * \
max((1, int(input_data.sample_period / input_data.source.sample_period)))
end_time = input_data.source.start_time + (wavelet_sample_period *
shape[1])
if len(input_data.frequencies):
freq_lo = input_data.frequencies[0]
freq_hi = input_data.frequencies[-1]
else:
freq_lo = 0
freq_hi = 1
slices = (slice(shape[0]), slice(shape[1]), slice(0, 1, None),
slice(0, shape[3], None), slice(0, 1, None))
data_matrix = input_data.get_data('power', slices)
data_matrix = data_matrix.sum(axis=3)
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: " + input_data.source.type,
xAxisName="Time (%s)" % str(input_data.source.sample_period_unit),
yAxisName="Frequency (%s)" % str("kHz"),
title=self._ui_name,
matrix_data=matrix_data,
matrix_shape=matrix_shape,
start_time=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 launch(self, data_0, data_1=None, data_2=None):
connectivity = data_0.connectivity
sensor_locations = TopographyCalculations.normalize_sensors(connectivity.centres)
sensor_number = len(sensor_locations)
arrays = []
titles = []
min_vals = []
max_vals = []
data_array = []
data_arrays = []
for measure in [data_0, data_1, data_2]:
if measure is not None:
if len(measure.connectivity.centres) != sensor_number:
raise Exception("Use the same connectivity!!!")
arrays.append(measure.array_data.tolist())
titles.append(measure.title)
min_vals.append(measure.array_data.min())
max_vals.append(measure.array_data.max())
color_bar_min = min(min_vals)
color_bar_max = max(max_vals)
for i, array_data in enumerate(arrays):
try:
data_array = TopographyCalculations.compute_topography_data(array_data, sensor_locations)
if numpy.any(numpy.isnan(array_data)):
titles[i] = titles[i] + " - Topography contains nan"
if not numpy.any(array_data):
titles[i] = titles[i] + " - Topography data is all zeros"
data_arrays.append(ABCDisplayer.dump_with_precision(data_array.flat))
except KeyError as err:
self.log.exception(err)
raise LaunchException("The measure points location is not compatible with this viewer ", err)
params = dict(matrix_datas=data_arrays,
matrix_shape=json.dumps(data_array.squeeze().shape),
titles=titles,
vmin=color_bar_min,
vmax=color_bar_max)
return self.build_display_result("topographic/view", params,
pages={"controlPage": "topographic/controls"})
def launch(self, input_data, **kwarg):
shape = input_data.read_data_shape()
start_time = input_data.source.start_time
wavelet_sample_period = input_data.source.sample_period * \
max((1, int(input_data.sample_period / input_data.source.sample_period)))
end_time = input_data.source.start_time + (wavelet_sample_period * shape[1])
if len(input_data.frequencies):
freq_lo = input_data.frequencies[0]
freq_hi = input_data.frequencies[-1]
else:
freq_lo = 0
freq_hi = 1
slices = (slice(shape[0]),
slice(shape[1]),
slice(0, 1, None),
slice(0, shape[3], None),
slice(0, 1, None))
data_matrix = input_data.get_data('power', slices)
data_matrix = data_matrix.sum(axis=3)
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: " + input_data.source.type,
xAxisName="Time (%s)" % str(input_data.source.sample_period_unit),
yAxisName="Frequency (%s)" % str("kHz"),
title=self._ui_name,
matrix_data=matrix_data,
matrix_shape=matrix_shape,
start_time=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"})
