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 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"})