def prepare_mapped_sensors_as_measure_points_params(project_id, sensors, eeg_cap=None): """ Compute sensors positions by mapping them to the ``eeg_cap`` surface If ``eeg_cap`` is not specified the mapping will use a default EEGCal DataType in current project. If no default EEGCap is found, return sensors as they are (not projected) :returns: dictionary to be used in Viewers for rendering measure_points :rtype: dict """ if eeg_cap is None: eeg_cap = dao.try_load_last_entity_of_type(project_id, EEGCap) if eeg_cap: datatype_kwargs = json.dumps({'surface_to_map': eeg_cap.gid}) sensor_locations = ABCDisplayer.paths2url(sensors, 'sensors_to_surface') + '/' + datatype_kwargs sensor_no = sensors.number_of_sensors sensor_labels = ABCDisplayer.paths2url(sensors, 'labels') return {'urlMeasurePoints': sensor_locations, 'urlMeasurePointsLabels': sensor_labels, 'noOfMeasurePoints': sensor_no, 'minMeasure': 0, 'maxMeasure': sensor_no, 'urlMeasure': ''} return prepare_sensors_as_measure_points_params(sensors)
def prepare_mapped_sensors_as_measure_points_params(project_id, sensors, eeg_cap=None): """ Compute sensors positions by mapping them to the ``eeg_cap`` surface If ``eeg_cap`` is not specified the mapping will use a default EEGCal DataType in current project. If no default EEGCap is found, return sensors as they are (not projected) :returns: dictionary to be used in Viewers for rendering measure_points :rtype: dict """ if eeg_cap is None: eeg_cap = dao.try_load_last_entity_of_type(project_id, EEGCap) if eeg_cap: datatype_kwargs = json.dumps({'surface_to_map': eeg_cap.gid}) sensor_locations = ABCDisplayer.paths2url( sensors, 'sensors_to_surface') + '/' + datatype_kwargs sensor_no = sensors.number_of_sensors sensor_labels = ABCDisplayer.paths2url(sensors, 'labels') return { 'urlMeasurePoints': sensor_locations, 'urlMeasurePointsLabels': sensor_labels, 'noOfMeasurePoints': sensor_no, 'minMeasure': 0, 'maxMeasure': sensor_no, 'urlMeasure': '' } return prepare_sensors_as_measure_points_params(sensors)
def get_sensor_measure_points(sensors): """ Returns urls from where to fetch the measure points and their labels """ measure_points = ABCDisplayer.paths2url(sensors, 'locations') measure_points_no = sensors.number_of_sensors measure_points_labels = ABCDisplayer.paths2url(sensors, 'labels') return measure_points, measure_points_labels, measure_points_no
def retrieve_measure_points(self, time_series): """ To be overwritten method, for retrieving the measurement points (region centers, EEG sensors). """ if isinstance(time_series, TimeSeriesSurface): return [], [], 0 measure_points = ABCDisplayer.paths2url(time_series.connectivity, 'centres') measure_points_labels = ABCDisplayer.paths2url(time_series.connectivity, 'region_labels') measure_points_no = time_series.connectivity.number_of_regions return measure_points, measure_points_labels, measure_points_no
def prepare_sensors_as_measure_points_params(sensors): """ Returns urls from where to fetch the measure points and their labels """ sensor_locations = ABCDisplayer.paths2url(sensors, 'locations') sensor_no = sensors.number_of_sensors sensor_labels = ABCDisplayer.paths2url(sensors, 'labels') return {'urlMeasurePoints': sensor_locations, 'urlMeasurePointsLabels': sensor_labels, 'noOfMeasurePoints': sensor_no, 'minMeasure': 0, 'maxMeasure': sensor_no, 'urlMeasure': ''}
def launch(self, datatype): """Construct data for visualization and launch it.""" matrix_shape = datatype.array_data.shape[0:2] parent_ts = datatype.source parent_ts = self.load_entity_by_gid(parent_ts.gid) labels = parent_ts.get_space_labels() state_list = parent_ts.labels_dimensions.get( parent_ts.labels_ordering[1], []) mode_list = range(parent_ts._length_4d) 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=ABCDisplayer.paths2url(datatype, "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 prepare_sensors_as_measure_points_params(sensors): """ Returns urls from where to fetch the measure points and their labels """ sensor_locations = ABCDisplayer.paths2url(sensors, 'locations') sensor_no = sensors.number_of_sensors sensor_labels = ABCDisplayer.paths2url(sensors, 'labels') return { 'urlMeasurePoints': sensor_locations, 'urlMeasurePointsLabels': sensor_labels, 'noOfMeasurePoints': sensor_no, 'minMeasure': 0, 'maxMeasure': sensor_no, 'urlMeasure': '' }
def launch(self, **kwargs): self.log.debug("Plot started...") input_data = kwargs['input_data'] shape = list(input_data.read_data_shape()) state_list = input_data.source.labels_dimensions.get(input_data.source.labels_ordering[1], []) mode_list = range(shape[3]) available_scales = ["Linear", "Logarithmic"] params = dict(matrix_shape=json.dumps([shape[0], shape[2]]), plotName=input_data.source.type, url_base=ABCDisplayer.paths2url(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(input_data.frequency[slice(shape[0])].tolist()), xmin=input_data.freq_step, xmax=input_data.max_freq) return self.build_display_result("fourier_spectrum/view", params)
def compute_params(self, region_mapping_volume=None, measure=None, data_slice='', background=None): region_mapping_volume = self._ensure_region_mapping(region_mapping_volume) volume = region_mapping_volume.volume volume_shape = region_mapping_volume.read_data_shape() volume_shape = (1, ) + volume_shape if measure is None: params = self._compute_region_volume_map_params(region_mapping_volume) else: params = self._compute_measure_params(region_mapping_volume, measure, data_slice) url_voxel_region = ABCDisplayer.paths2url(region_mapping_volume, "get_voxel_region", parameter="") params.update(volumeShape=json.dumps(volume_shape), volumeOrigin=json.dumps(volume.origin.tolist()), voxelUnit=volume.voxel_unit, voxelSize=json.dumps(volume.voxel_size.tolist()), urlVoxelRegion=url_voxel_region) if background is None: background = dao.try_load_last_entity_of_type(self.current_project_id, StructuralMRI) params.update(self._compute_background(background)) return params
def compute_params(self, region_mapping_volume=None, measure=None, data_slice=''): region_mapping_volume = self._ensure_region_mapping( region_mapping_volume) volume = region_mapping_volume.volume volume_shape = region_mapping_volume.read_data_shape() volume_shape = (1, ) + volume_shape if measure is None: params = self._compute_region_volume_map_params( region_mapping_volume) else: params = self._compute_measure_params(region_mapping_volume, measure, data_slice) url_voxel_region = ABCDisplayer.paths2url(region_mapping_volume, "get_voxel_region", parameter="") params.update(volumeShape=json.dumps(volume_shape), volumeOrigin=json.dumps(volume.origin.tolist()), voxelUnit=volume.voxel_unit, voxelSize=json.dumps(volume.voxel_size.tolist()), urlVoxelRegion=url_voxel_region) return params
def launch(self, background=None): volume = background.volume volume_shape = background.read_data_shape() volume_shape = (1, ) + volume_shape min_value, max_value = background.get_min_max_values() url_volume_data = ABCDisplayer.paths2url(background, 'get_volume_view', parameter='') params = dict(title="MRI Volume visualizer", minValue=min_value, maxValue=max_value, urlVolumeData=url_volume_data, volumeShape=json.dumps(volume_shape), volumeOrigin=json.dumps(volume.origin.tolist()), voxelUnit=volume.voxel_unit, voxelSize=json.dumps(volume.voxel_size.tolist()), urlVoxelRegion='', minBackgroundValue=min_value, maxBackgroundValue=max_value, urlBackgroundVolumeData='') return self.build_display_result( "time_series_volume/staticView", params, pages=dict(controlPage="time_series_volume/controls"))
def retrieve_measure_points_prams(self, time_series): """ To be overwritten method, for retrieving the measurement points (region centers, EEG sensors). """ if self.connectivity is None: self.measure_points_no = 0 return {'urlMeasurePoints': [], 'urlMeasurePointsLabels': [], 'noOfMeasurePoints': 0} measure_points = ABCDisplayer.paths2url(self.connectivity, 'centres') measure_points_labels = ABCDisplayer.paths2url(self.connectivity, 'region_labels') self.measure_points_no = self.connectivity.number_of_regions return {'urlMeasurePoints': measure_points, 'urlMeasurePointsLabels': measure_points_labels, 'noOfMeasurePoints': self.measure_points_no}
def launch(self, connectivity): """Construct data for visualization and launch it.""" pars = {"labels": json.dumps(connectivity.region_labels.tolist()), "url_base": ABCDisplayer.paths2url(connectivity, attribute_name="weights", flatten="True") } return self.build_display_result("connectivity_edge_bundle/view", pars)
def _compute_background(background): if background is not None: min_value, max_value = background.get_min_max_values() url_volume_data = ABCDisplayer.paths2url(background, 'get_volume_view', parameter='') else: min_value, max_value = 0, 0 url_volume_data = None return dict( minBackgroundValue=min_value, maxBackgroundValue=max_value, urlBackgroundVolumeData = url_volume_data )
def compute_sensor_surfacemapped_measure_points(project_id, sensors, eeg_cap=None): """ Compute sensors positions by mapping them to the ``eeg_cap`` surface If ``eeg_cap`` is not specified the mapping will use a default. It returns a url from where to fetch the positions If no default is available it returns None :returns: measure points, measure points labels, measure points number :rtype: tuple """ if eeg_cap is None: eeg_cap = dao.get_values_of_datatype(project_id, EEGCap)[0] if eeg_cap: eeg_cap = ABCDisplayer.load_entity_by_gid(eeg_cap[-1][2]) if eeg_cap: datatype_kwargs = json.dumps({'surface_to_map': eeg_cap.gid}) measure_points = ABCDisplayer.paths2url(sensors, 'sensors_to_surface') + '/' + datatype_kwargs measure_points_no = sensors.number_of_sensors measure_points_labels = ABCDisplayer.paths2url(sensors, 'labels') return measure_points, measure_points_labels, measure_points_no
def launch(self, connectivity): """Construct data for visualization and launch it.""" pars = { "labels": json.dumps(connectivity.region_labels.tolist()), "url_base": ABCDisplayer.paths2url(connectivity, attribute_name="weights", flatten="True") } return self.build_display_result("connectivity_edge_bundle/view", pars)
def _compute_measure_params(self, region_mapping_volume, measure, data_slice): # prepare the url that will project the measure onto the region volume map metadata = measure.get_metadata('array_data') min_value, max_value = metadata[measure.METADATA_ARRAY_MIN], metadata[measure.METADATA_ARRAY_MAX] measure_shape = measure.get_data_shape('array_data') if not data_slice: data_slice = self.get_default_slice(measure_shape, region_mapping_volume.connectivity.number_of_regions) data_slice = slice_str(data_slice) datatype_kwargs = json.dumps({'mapped_array': measure.gid}) url_volume_data = ABCDisplayer.paths2url(region_mapping_volume, "get_mapped_array_volume_view") url_volume_data += '/' + datatype_kwargs + '?mapped_array_slice=' + data_slice + ';' return dict( minValue=min_value, maxValue=max_value, urlVolumeData=url_volume_data, measureShape=slice_str(measure_shape), measureSlice=data_slice)
def launch(self, input_data, **kwargs): """ Draw interactive display. """ self.log.debug("Plot started...") params = dict(plotName=input_data.source.type, xAxisName="Frequency [kHz]", yAxisName="CohSpec", available_xScale=["Linear", "Logarithmic"], available_spectrum=json.dumps(input_data.spectrum_types), spectrum_list=input_data.spectrum_types, xscale="Linear", spectrum=input_data.spectrum_types[0], url_base=ABCDisplayer.paths2url(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 compute_params(self, region_mapping_volume=None, measure=None, data_slice=''): region_mapping_volume = self._ensure_region_mapping(region_mapping_volume) volume = region_mapping_volume.volume volume_shape = region_mapping_volume.read_data_shape() volume_shape = (1, ) + volume_shape if measure is None: params = self._compute_region_volume_map_params(region_mapping_volume) else: params = self._compute_measure_params(region_mapping_volume, measure, data_slice) url_voxel_region = ABCDisplayer.paths2url(region_mapping_volume, "get_voxel_region", parameter="") params.update(volumeShape=json.dumps(volume_shape), volumeOrigin=json.dumps(volume.origin.tolist()), voxelUnit=volume.voxel_unit, voxelSize=json.dumps(volume.voxel_size.tolist()), urlVoxelRegion=url_voxel_region) return params
def launch(self, background=None): volume = background.volume volume_shape = background.read_data_shape() volume_shape = (1,) + volume_shape min_value, max_value = background.get_min_max_values() url_volume_data = ABCDisplayer.paths2url(background, 'get_volume_view', parameter='') params = dict(title="MRI Volume visualizer", minValue=min_value, maxValue=max_value, urlVolumeData=url_volume_data, volumeShape=json.dumps(volume_shape), volumeOrigin=json.dumps(volume.origin.tolist()), voxelUnit=volume.voxel_unit, voxelSize=json.dumps(volume.voxel_size.tolist()), urlVoxelRegion='', minBackgroundValue=min_value, maxBackgroundValue=max_value, urlBackgroundVolumeData='') return self.build_display_result("time_series_volume/staticView", params, pages=dict(controlPage="time_series_volume/controls"))
def launch(self, input_data, **kwargs): """ Draw interactive display. """ self.log.debug("Plot started...") params = dict( plotName=input_data.source.type, xAxisName="Frequency [kHz]", yAxisName="CohSpec", available_xScale=["Linear", "Logarithmic"], available_spectrum=json.dumps(input_data.spectrum_types), spectrum_list=input_data.spectrum_types, xscale="Linear", spectrum=input_data.spectrum_types[0], url_base=ABCDisplayer.paths2url(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)