def compute_params(self, region_mapping_volume=None, measure=None, data_slice='', background=None): # type: (RegionVolumeMappingIndex, DataTypeMatrix, str, StructuralMRIIndex) -> dict region_mapping_volume = self._ensure_region_mapping_index(region_mapping_volume, measure) url_voxel_region = URLGenerator.build_url(self.stored_adapter.id, 'get_voxel_region', region_mapping_volume.gid, parameter='') 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) volume_gid = region_mapping_volume.fk_volume_gid volume_index = self.load_entity_by_gid(volume_gid) assert isinstance(volume_index, VolumeIndex) volume_shape = region_mapping_volume.parsed_shape volume_shape = (1,) + volume_shape params.update(volumeShape=json.dumps(volume_shape), volumeOrigin=volume_index.origin, voxelUnit=volume_index.voxel_unit, voxelSize=volume_index.voxel_size, urlVoxelRegion=url_voxel_region) if background is None: background = dao.try_load_last_entity_of_type(self.current_project_id, StructuralMRIIndex) if background is None: # still params.update(self.compute_background_params()) else: url_volume_data = URLGenerator.build_url(self.stored_adapter.id, 'get_volume_view', background.gid, '') params.update(self.compute_background_params(background.array_data_min, background.array_data_max, url_volume_data)) return params
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.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, '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.surface_gid, region_mapping_index.gid, self.stored_adapter.id) surface_index = self.load_entity_by_gid(region_mapping_index.surface_gid) surface_h5 = h5.h5_file_for_index(surface_index) 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", baseUrl=TvbProfile.current.web.BASE_URL, 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"})
def launch(self, view_model): # type: (TimeSeriesVolumeVisualiserModel) -> dict url_volume_data = URLGenerator.build_url(self.stored_adapter.id, 'get_volume_view', view_model.time_series, '') url_timeseries_data = URLGenerator.build_url(self.stored_adapter.id, 'get_voxel_time_series', view_model.time_series, '') ts_h5_class, ts_h5_path = self._load_h5_of_gid(view_model.time_series.hex) ts_h5 = ts_h5_class(ts_h5_path) min_value, max_value = ts_h5.get_min_max_values() ts_index = self.load_entity_by_gid(view_model.time_series) if isinstance(ts_h5, TimeSeriesVolumeH5): volume_h5_class, volume_h5_path = self._load_h5_of_gid(ts_h5.volume.load()) volume_h5 = volume_h5_class(volume_h5_path) volume_shape = ts_h5.data.shape else: rmv_index = self.load_entity_by_gid(ts_h5.region_mapping_volume.load()) rmv_h5_class, rmv_h5_path = self._load_h5_of_gid(rmv_index.gid) rmv_h5 = rmv_h5_class(rmv_h5_path) volume_index = self.load_entity_by_gid(rmv_h5.volume.load()) volume_h5_class, volume_h5_path = self._load_h5_of_gid(volume_index.gid) volume_h5 = volume_h5_class(volume_h5_path) volume_shape = [ts_h5.data.shape[0]] volume_shape.extend(rmv_h5.array_data.shape) rmv_h5.close() background_index = None if view_model.background: background_index = self.load_entity_by_gid(view_model.background) params = dict(title="Volumetric Time Series", ts_title=ts_h5.title.load(), labelsStateVar=ts_index.get_labels_for_dimension(1), labelsModes=list(range(ts_index.data_length_4d)), minValue=min_value, maxValue=max_value, urlVolumeData=url_volume_data, urlTimeSeriesData=url_timeseries_data, samplePeriod=ts_h5.sample_period.load(), samplePeriodUnit=ts_h5.sample_period_unit.load(), volumeShape=json.dumps(volume_shape), volumeOrigin=json.dumps(volume_h5.origin.load().tolist()), voxelUnit=volume_h5.voxel_unit.load(), voxelSize=json.dumps(volume_h5.voxel_size.load().tolist())) params.update(self.ensure_background(background_index)) volume_h5.close() ts_h5.close() return self.build_display_result("time_series_volume/view", params, pages=dict(controlPage="time_series_volume/controls"))
def launch(self, view_model): # type: (BaseVolumeVisualizerModel) -> dict structural_mri = self.load_entity_by_gid(view_model.background) assert isinstance(structural_mri, StructuralMRIIndex) volume_shape = structural_mri.parsed_shape volume_shape = (1, ) + volume_shape url_volume_data = URLGenerator.build_url(self.stored_adapter.id, 'get_volume_view', view_model.background, '') volume_gid = structural_mri.fk_volume_gid volume_index = self.load_entity_by_gid(volume_gid) assert isinstance(volume_index, VolumeIndex) params = dict(title="MRI Volume visualizer", minValue=structural_mri.array_data_min, maxValue=structural_mri.array_data_max, urlVolumeData=url_volume_data, volumeShape=json.dumps(volume_shape), volumeOrigin=volume_index.origin, voxelUnit=volume_index.voxel_unit, voxelSize=volume_index.voxel_size, urlVoxelRegion='', urlBackgroundVolumeData='', minBackgroundValue=structural_mri.array_data_min, maxBackgroundValue=structural_mri.array_data_max) return self.build_display_result( "time_series_volume/staticView", params, pages=dict(controlPage="time_series_volume/controls"))
def get_url_for_region_boundaries(surface_gid, region_mapping_gid, adapter_id): return URLGenerator.build_url(adapter_id, 'generate_region_boundaries', surface_gid, parameter='region_mapping_gid=' + region_mapping_gid)
def prepare_mapped_sensors_as_measure_points_params(sensors, eeg_cap=None, adapter_id=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: sensor_locations = URLGenerator.build_url( adapter_id, 'sensors_to_surface', sensors.gid, parameter='surface_to_map_gid=' + eeg_cap.gid) sensor_no = sensors.number_of_sensors sensor_labels = URLGenerator.build_h5_url(sensors.gid, 'get_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 _compute_measure_params(self, region_mapping_volume, measure, data_slice): # prepare the url that will project the measure onto the region volume map measure_h5_class, measure_h5_path = self._load_h5_of_gid(measure.gid) measure_h5 = measure_h5_class(measure_h5_path) min_value, max_value = measure_h5.get_min_max_values() measure_shape = measure_h5.array_data.shape if not data_slice: conn_index = dao.get_datatype_by_gid( region_mapping_volume.connectivity.load().hex) data_slice = self.get_default_slice(measure_shape, conn_index.number_of_regions) data_slice = slice_str(data_slice) url_volume_data = URLGenerator.build_url( self.stored_adapter.id, 'get_mapped_array_volume_view', region_mapping_volume.gid.load(), parameter='') url_volume_data += 'mapped_array_gid=' + measure.gid + ';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 get_url_for_region_boundaries(surface_h5, region_mapping_gid, adapter_id): surface_gid = surface_h5.gid.load().hex return URLGenerator.build_url(surface_gid, 'generate_region_boundaries', adapter_id=adapter_id, parameter='region_mapping_gid=' + region_mapping_gid)
def _compute_region_volume_map_params(self, region_mapping_volume): # type: (RegionVolumeMappingIndex) -> dict # prepare the url that will display the region volume map conn_index = dao.get_datatype_by_gid(region_mapping_volume.fk_connectivity_gid) min_value, max_value = [0, conn_index.number_of_regions] url_volume_data = URLGenerator.build_url(self.stored_adapter.id, 'get_volume_view', region_mapping_volume.gid, '') return dict(minValue=min_value, maxValue=max_value, urlVolumeData=url_volume_data)
def _prepare_data_slices(self, time_series_index): """ Prepare data URL for retrieval with slices of timeSeries activity and Time-Line. :returns: [activity_urls], [timeline_urls] Currently timeline_urls has just one value, as on client is loaded entirely anyway. """ time_series_gid = time_series_index.gid activity_base_url = URLGenerator.build_url(self.stored_adapter.id, 'read_data_page_split', time_series_gid, "") time_urls = [SurfaceURLGenerator.build_h5_url(time_series_gid, 'read_time_page', parameter="current_page=0;page_size=" + str(time_series_index.data_length_1d))] return activity_base_url, time_urls
def ensure_background(self, background_index): if background_index is None: background_index = dao.try_load_last_entity_of_type(self.current_project_id, StructuralMRIIndex) if background_index is None: return _MappedArrayVolumeBase.compute_background_params() with h5.h5_file_for_index(background_index) as background_h5: min_value, max_value = background_h5.get_min_max_values() url_volume_data = URLGenerator.build_url(self.stored_adapter.id, 'get_volume_view', background_index.gid, '') return _MappedArrayVolumeBase.compute_background_params(min_value, max_value, url_volume_data)
def _compute_measure_params(self, rvm_index, measure, data_slice): # type: (RegionVolumeMappingIndex, DataTypeMatrix, str) -> dict # prepare the url that will project the measure onto the region volume map measure_shape = measure.parsed_shape if not data_slice: conn_index = dao.get_datatype_by_gid(rvm_index.fk_connectivity_gid) data_slice = self.get_default_slice(measure_shape, conn_index.number_of_regions) data_slice = slice_str(data_slice) url_volume_data = URLGenerator.build_url(self.stored_adapter.id, 'get_mapped_array_volume_view', rvm_index.gid, parameter='') url_volume_data += 'mapped_array_gid=' + measure.gid + ';mapped_array_slice=' + data_slice + ';' return dict(minValue=measure.array_data_min, maxValue=measure.array_data_max, urlVolumeData=url_volume_data, measureShape=measure.shape, measureSlice=data_slice)
def _compute_background(self, background): if background is None: return self.compute_background_params() background_class, background_path = self._load_h5_of_gid( background.gid) background_h5 = background_class(background_path) min_value, max_value = background_h5.get_min_max_values() background_h5.close() url_volume_data = URLGenerator.build_url(self.stored_adapter.id, 'get_volume_view', background.gid, '') return self.compute_background_params(min_value, max_value, url_volume_data)
def launch(self, view_model): # type: (VolumeVisualizerModel) -> dict background_class, background_path = self._load_h5_of_gid( view_model.background.hex) background_h5 = background_class(background_path) volume_shape = background_h5.array_data.shape volume_shape = (1, ) + volume_shape min_value, max_value = background_h5.get_min_max_values() url_volume_data = URLGenerator.build_url(self.stored_adapter.id, 'get_volume_view', view_model.background, '') volume_gid = background_h5.volume.load() volume_class, volume_path = self._load_h5_of_gid(volume_gid.hex) volume_h5 = volume_class(volume_path) 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_h5.origin.load().tolist()), voxelUnit=volume_h5.voxel_unit.load(), voxelSize=json.dumps(volume_h5.voxel_size.load().tolist()), urlVoxelRegion='', minBackgroundValue=min_value, maxBackgroundValue=max_value, urlBackgroundVolumeData='') background_h5.close() volume_h5.close() return self.build_display_result( "time_series_volume/staticView", params, pages=dict(controlPage="time_series_volume/controls"))