Beispiel #1
0
 def test_generate_preview(self):
     """
     Check that all required keys are present in preview generate by BrainViewer.
     """
     time_series = self.datatypeFactory.create_timeseries(self.connectivity)
     viewer = BrainViewer()
     result = viewer.generate_preview(time_series, figure_size=(500, 200))
     for key in TestBrainViewer.EXPECTED_KEYS:
         assert key in result and result[key] is not None, key
 def test_generate_preview(self):
     """
     Check that all required keys are present in preview generate by BrainViewer.
     """
     time_series = self.datatypeFactory.create_timeseries(self.connectivity)
     viewer = BrainViewer()
     result = viewer.generate_preview(time_series, figure_size=(500, 200))
     for key in TestBrainViewer.EXPECTED_KEYS:
         assert key in result and result[key] is not None, key
 def test_generate_preview(self):
     """
     Check that all required keys are present in preview generate by BrainViewer.
     """
     time_series = self.datatypeFactory.create_timeseries(self.connectivity)
     viewer = BrainViewer()
     result = viewer.generate_preview(time_series, (500, 200))
     expected_keys = ['urlVertices', 'urlNormals', 'urlTriangles', 'minActivity', 'maxActivity',
                      'isOneToOneMapping', 'isAdapter', 'base_activity_url', 'alphas_indices']
     for key in expected_keys:
         self.assertTrue(key in result and result[key] is not None)
Beispiel #4
0
 def test_get_required_memory(self, time_series_region_index_factory):
     """
     Brainviewer should know required memory so expect positive number and not -1.
     """
     time_series_index = time_series_region_index_factory(self.connectivity, self.region_mapping,
                                                          self.test_user, self.test_project)
     viewer = BrainViewer()
     viewer.current_project_id = self.test_project.id
     view_model = viewer.get_view_model_class()()
     view_model.time_series = UUID(time_series_index.gid)
     assert viewer.get_required_memory_size(view_model) > 0
Beispiel #5
0
    def test_launch(self):
        """
        Check that all required keys are present in output from BrainViewer launch.
        """
        time_series = self.datatypeFactory.create_timeseries(self.connectivity)
        viewer = BrainViewer()
        viewer.current_project_id = self.test_project.id
        result = viewer.launch(time_series=time_series)

        for key in TestBrainViewer.EXPECTED_KEYS + TestBrainViewer.EXPECTED_EXTRA_KEYS:
            assert key in result and result[key] is not None
        assert not result['extended_view']
    def test_launch(self):
        """
        Check that all required keys are present in output from BrainViewer launch.
        """
        time_series = self.datatypeFactory.create_timeseries(self.connectivity)
        viewer = BrainViewer()
        viewer.current_project_id = self.test_project.id
        result = viewer.launch(time_series=time_series)

        for key in TestBrainViewer.EXPECTED_KEYS + TestBrainViewer.EXPECTED_EXTRA_KEYS:
            assert key in result and result[key] is not None
        assert not result['extended_view']
Beispiel #7
0
 def test_generate_preview(self, time_series_region_index_factory):
     """
     Check that all required keys are present in preview generate by BrainViewer.
     """
     time_series_index = time_series_region_index_factory(self.connectivity, self.region_mapping,
                                                          self.test_user, self.test_project)
     viewer = BrainViewer()
     viewer.current_project_id = self.test_project.id
     view_model = viewer.get_view_model_class()()
     view_model.time_series = UUID(time_series_index.gid)
     result = viewer.generate_preview(view_model, figure_size=(500, 200))
     for key in TestBrainViewer.EXPECTED_KEYS:
         assert key in result and result[key] is not None, key
 def test_launch(self):
     """
     Check that all required keys are present in output from BrainViewer launch.
     """
     time_series = self.datatypeFactory.create_timeseries(self.connectivity)
     viewer = BrainViewer()
     viewer.current_project_id = self.test_project.id
     result = viewer.launch(time_series=time_series)
     expected_keys = ['urlVertices', 'urlNormals', 'urlTriangles', 'urlMeasurePointsLabels', 'title', 
                      'time_series', 'shelfObject', 'pageSize', 'labelsStateVar', 'labelsModes',
                      'minActivityLabels', 'minActivity', 'measure_points', 'maxActivity', 'isOneToOneMapping',
                      'isAdapter', 'extended_view', 'base_activity_url', 'alphas_indices']
     for key in expected_keys:
         self.assertTrue(key in result and result[key] is not None)
     self.assertFalse(result['extended_view'])
 def test_generate_preview(self):
     """
     Check that all required keys are present in preview generate by BrainViewer.
     """
     time_series = self.datatypeFactory.create_timeseries(self.connectivity)
     viewer = BrainViewer()
     result = viewer.generate_preview(time_series, (500, 200))
     expected_keys = [
         'urlVertices', 'urlNormals', 'urlTriangles', 'pageSize',
         'nrOfPages', 'minActivityLabels', 'minActivity', 'maxActivity',
         'isOneToOneMapping', 'isAdapter', 'base_activity_url',
         'alphas_indices'
     ]
     for key in expected_keys:
         self.assertTrue(key in result and result[key] is not None)
Beispiel #10
0
 def test_get_required_memory(self):
     """
     Brainviewer should know required memory so expect positive number and not -1.
     """
     time_series = self.datatypeFactory.create_timeseries(self.connectivity)
     self.assertTrue(
         BrainViewer().get_required_memory_size(time_series) > 0)
Beispiel #11
0
    def test_launch(self, time_series_region_index_factory):
        """
        Check that all required keys are present in output from BrainViewer launch.
        """
        time_series_index = time_series_region_index_factory(self.connectivity, self.region_mapping,
                                                             self.test_user, self.test_project)
        viewer = BrainViewer()
        viewer.current_project_id = self.test_project.id
        view_model = viewer.get_view_model_class()()
        view_model.time_series = UUID(time_series_index.gid)
        view_model.shell_surface = UUID(self.face_surface.gid)
        result = viewer.launch(view_model)

        for key in TestBrainViewer.EXPECTED_KEYS + TestBrainViewer.EXPECTED_EXTRA_KEYS:
            assert key in result and result[key] is not None
        assert not result['extended_view']
Beispiel #12
0
    def launch(self, sensors, eeg_cap=None, shell_surface=None):
        measure_points_info = BrainEEG.compute_sensor_surfacemapped_measure_points(self.current_project_id,
                                                                                   sensors, eeg_cap)
        if measure_points_info is None:
            measure_points_info = BrainEEG.get_sensor_measure_points(sensors)

        measure_points_nr = measure_points_info[2]
        params = {
            'shelfObject': BrainViewer.get_shell_surface_urls(shell_surface, self.current_project_id),
            'urlVertices': '', 'urlTriangles': '',
            'urlLines': '[]', 'urlNormals': '',
            'boundaryURL': '', 'urlAlphas': '', 'urlAlphasIndices': '',
            'urlMeasurePoints': measure_points_info[0],
            'urlMeasurePointsLabels': measure_points_info[1],
            'noOfMeasurePoints': measure_points_nr,
            'minMeasure': 0,
            'maxMeasure': measure_points_nr,
            'urlMeasure': ''
        }

        if eeg_cap is not None:
            params.update(self._compute_surface_params(eeg_cap))

        return self.build_display_result("sensors/sensors_eeg", params,
                                         pages={"controlPage": "sensors/sensors_controls"})
 def test_launch(self):
     """
     Check that all required keys are present in output from BrainViewer launch.
     """
     time_series = self.datatypeFactory.create_timeseries(self.connectivity)
     viewer = BrainViewer()
     result = viewer.launch(time_series=time_series)
     expected_keys = [
         'urlVertices', 'urlNormals', 'urlTriangles',
         'urlMeasurePointsLabels', 'title', 'time_series', 'shelfObject',
         'pageSize', 'labelsStateVar', 'nrOfPages', 'labelsModes',
         'minActivityLabels', 'minActivity', 'measure_points',
         'maxActivity', 'isOneToOneMapping', 'isAdapter', 'extended_view',
         'base_activity_url', 'alphas_indices'
     ]
     for key in expected_keys:
         self.assertTrue(key in result and result[key] is not None)
     self.assertFalse(result['extended_view'])
Beispiel #14
0
    def launch(self, surface, region_map=None, connectivity_measure=None, shell_surface=None):
        params = dict(title="Surface Visualizer", extended_view=False,
                      isOneToOneMapping=False, hasRegionMap=region_map is not None)

        params.update(self._compute_surface_params(surface, region_map))
        params.update(self._compute_measure_points_param(surface, region_map))
        params.update(self._compute_measure_param(connectivity_measure, params['noOfMeasurePoints']))

        try:
            params['shelfObject'] = BrainViewer.get_shell_surface_urls(shell_surface, self.current_project_id)
        except Exception:
            params['shelfObject'] = None

        return self.build_display_result("surface/surface_view", params,
                                         pages={"controlPage": "surface/surface_viewer_controls"})
Beispiel #15
0
    def launch(self, sensors, shell_surface=None):
        """
        SensorsInternal have full 3D positions to display
        """
        measure_points_info = BrainEEG.get_sensor_measure_points(sensors)
        measure_points_nr = measure_points_info[2]

        params = {
            'shelfObject': BrainViewer.get_shell_surface_urls(shell_surface, self.current_project_id),
            'urlMeasurePoints': measure_points_info[0],
            'urlMeasurePointsLabels': measure_points_info[1],
            'noOfMeasurePoints': measure_points_info[2],
            'minMeasure': 0,
            'maxMeasure': measure_points_nr,
            'urlMeasure': ''
        }

        return self.build_display_result('sensors/sensors_internal', params,
                                         pages={'controlPage': 'sensors/sensors_controls'})