Esempio n. 1
0
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)
Esempio n. 2
0
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)
Esempio n. 3
0
 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
Esempio n. 4
0
 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
Esempio n. 5
0
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': ''}
Esempio n. 6
0
    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)
Esempio n. 7
0
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': ''
    }
Esempio n. 8
0
    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)
Esempio n. 9
0
    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"))
Esempio n. 12
0
    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)
Esempio n. 14
0
 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 )
Esempio n. 15
0
    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)
Esempio n. 17
0
    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)