def create_local_connectivity(user, project, surface_gid): op = TestFactory.create_operation(test_user=user, test_project=project) wrapper_surf = CorticalSurface() wrapper_surf.gid = uuid.UUID(surface_gid) lc_ht = LocalConnectivity.from_file() lc_ht.surface = wrapper_surf lc_idx = h5.store_complete(lc_ht, op.id, project.name) lc_idx.fk_surface_gid = surface_gid lc_idx.fk_from_operation = op.id dao.store_entity(lc_idx) return TestFactory._assert_one_more_datatype(project, LocalConnectivityIndex)
def setUp(self): self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) zip_path = os.path.join(os.path.dirname(surface_dataset.__file__), 'face-surface.zip') TestFactory.import_surface_zip(self.test_user, self.test_project, zip_path, 'Face', 1) zip_path = os.path.join(os.path.dirname(surface_dataset.__file__), 'eeg_skin_surface.zip') TestFactory.import_surface_zip(self.test_user, self.test_project, zip_path, 'EEG Cap', 1) self.connectivity = TestFactory.get_entity(self.test_project, Connectivity()) self.assertTrue(self.connectivity is not None) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) self.face_surface = TestFactory.get_entity(self.test_project, FaceSurface()) self.assertTrue(self.face_surface is not None) self.assertTrue( TestFactory.get_entity(self.test_project, EEGCap()) is not None)
def setUp(self): """ Reset the database before each test. """ self.test_user = TestFactory.create_user("UserPM") self.test_project = TestFactory.create_project(self.test_user) zip_path = os.path.join(os.path.dirname(tvb_data.sensors.__file__), 'eeg_brainstorm_65.txt') TestFactory.import_sensors(self.test_user, self.test_project, zip_path, Sensors_Importer.EEG_SENSORS) zip_path = os.path.join(os.path.dirname(tvb_data.surfaceData.__file__), 'cortex_16384.zip') TestFactory.import_surface_zip(self.test_user, self.test_project, zip_path, CORTICAL, True) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) self.sensors = TestFactory.get_entity(self.test_project, SensorsEEG()) self.assertTrue(self.sensors is not None) self.importer = TestFactory.create_adapter( 'tvb.adapters.uploaders.projection_matrix_importer', 'ProjectionMatrixSurfaceEEGImporter')
def _importSurface(self, import_file_path=None): """ This method is used for importing data in GIFIT format :param import_file_path: absolute path of the file to be imported """ ### Retrieve Adapter instance group = dao.find_group('tvb.adapters.uploaders.gifti_surface_importer', 'GIFTISurfaceImporter') importer = ABCAdapter.build_adapter(group) args = { 'data_file': import_file_path, DataTypeMetaData.KEY_SUBJECT: "" } ### Launch import Operation FlowService().fire_operation(importer, self.test_user, self.test_project.id, **args) surface = CorticalSurface() data_types = FlowService().get_available_datatypes( self.test_project.id, surface.module + "." + surface.type)[0] self.assertEqual(1, len(data_types), "Project should contain only one data type.") surface = ABCAdapter.load_entity_by_gid(data_types[0][2]) self.assertTrue(surface is not None, "TimeSeries should not be none") return surface
def build(nr_vertices=10, valid_for_simulation=True, cortical=False): if cortical: return CorticalSurface( vertices=numpy.zeros((nr_vertices, 3)), triangles=numpy.zeros((3, 3), dtype=int), vertex_normals=numpy.zeros((nr_vertices, 3)), triangle_normals=numpy.zeros((3, 3)), number_of_vertices=nr_vertices, number_of_triangles=3, edge_mean_length=1.0, edge_min_length=0.0, edge_max_length=2.0, zero_based_triangles=False, bi_hemispheric=False, valid_for_simulations=True ) return Surface( vertices=numpy.zeros((nr_vertices, 3)), triangles=numpy.zeros((3, 3), dtype=int), vertex_normals=numpy.zeros((nr_vertices, 3)), triangle_normals=numpy.zeros((3, 3)), number_of_vertices=nr_vertices, number_of_triangles=3, edge_mean_length=1.0, edge_min_length=0.0, edge_max_length=2.0, zero_based_triangles=False, bi_hemispheric=False, surface_type=SurfaceTypesEnum.CORTICAL_SURFACE.value, valid_for_simulations=valid_for_simulation)
def test_projectionmatrix(self): dt = projections.ProjectionMatrix(projection_type=str(""), sources=CorticalSurface(), projection_data=numpy.array([])) assert dt.sources is not None assert dt.sensors is None assert dt.projection_data is not None
def setUp(self): """ Sets up the environment for running the tests; creates a test user, a test project, a connectivity, a cortical surface and a face surface; imports a CFF data-set """ self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) zip_path = os.path.join(os.path.dirname(surface_dataset.__file__), 'face-surface.zip') TestFactory.import_surface_zip(self.test_user, self.test_project, zip_path, 'Face', 1) zip_path = os.path.join(os.path.dirname(surface_dataset.__file__), 'eeg_skin_surface.zip') TestFactory.import_surface_zip(self.test_user, self.test_project, zip_path, 'EEG Cap', 1) self.connectivity = TestFactory.get_entity(self.test_project, Connectivity()) self.assertTrue(self.connectivity is not None) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) self.face_surface = TestFactory.get_entity(self.test_project, FaceSurface()) self.assertTrue(self.face_surface is not None) self.assertTrue( TestFactory.get_entity(self.test_project, EEGCap()) is not None)
def test_projection_surface_meg(self): dt = projections.ProjectionSurfaceMEG(sensors=SensorsMEG(), projection_data=numpy.array([]), sources=CorticalSurface()) assert dt.sources is not None assert dt.skin_air is None assert dt.skull_skin is None assert dt.sensors is not None assert dt.projection_data is not None
def setUp(self): self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) self.connectivity = self._get_entity(Connectivity()) self.surface = self._get_entity(CorticalSurface())
def setUp(self): """ Sets up the environment for running the tests; creates a test user, a test project, a connectivity and a surface; imports a CFF data-set """ self.test_user = TestFactory.create_user("UserRM") self.test_project = TestFactory.import_default_project(self.test_user) self.connectivity = self._get_entity(Connectivity()) self.surface = self._get_entity(CorticalSurface())
def test_surface_sim_with_projections(self): # Setup Simulator obj oscillator = models.Generic2dOscillator() white_matter = connectivity.Connectivity.from_file('connectivity_%d.zip' % (self.n_regions,)) white_matter.speed = numpy.array([self.speed]) white_matter_coupling = coupling.Difference(a=self.coupling_a) heunint = integrators.HeunStochastic( dt=2 ** -4, noise=noise.Additive(nsig=numpy.array([2 ** -10, ])) ) mons = ( monitors.EEG.from_file(period=self.period), monitors.MEG.from_file(period=self.period), # monitors.iEEG.from_file(period=self.period), # SEEG projection data is not part of tvb-data on Pypi, thus this can not work generic ) local_coupling_strength = numpy.array([2 ** -10]) region_mapping = RegionMapping.from_file('regionMapping_16k_%d.txt' % (self.n_regions,)) region_mapping.surface = CorticalSurface.from_file() default_cortex = Cortex.from_file() default_cortex.region_mapping_data = region_mapping default_cortex.coupling_strength = local_coupling_strength sim = simulator.Simulator(model=oscillator, connectivity=white_matter, coupling=white_matter_coupling, integrator=heunint, monitors=mons, surface=default_cortex) sim.configure() # check configured simulation connectivity attribute conn = sim.connectivity assert conn.number_of_regions == self.n_regions assert conn.speed == self.speed # test monitor properties lc_n_node = sim.surface.local_connectivity.matrix.shape[0] for mon in sim.monitors: assert mon.period == self.period n_sens, g_n_node = mon.gain.shape assert g_n_node == sim.number_of_nodes assert n_sens == mon.sensors.number_of_sensors assert lc_n_node == g_n_node # check output shape ys = {} mons = 'eeg meg seeg'.split() for key in mons: ys[key] = [] for data in sim(simulation_length=3.0): for key, dat in zip(mons, data): if dat: _, y = dat ys[key].append(y) for mon, key in zip(sim.monitors, mons): ys[key] = numpy.array(ys[key]) assert ys[key].shape[2] == mon.gain.shape[0]
def setUp(self): """ Reset the database before each test. """ self.test_user = TestFactory.create_user("UserPM") self.test_project = TestFactory.import_default_project(self.test_user) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) self.sensors = TestFactory.get_entity(self.test_project, SensorsEEG()) self.assertTrue(self.sensors is not None)
def deserialize_simulator(simulator_gid, storage_path): simulator_in_path = h5.path_for(storage_path, SimulatorH5, simulator_gid) simulator_in = Simulator() with SimulatorH5(simulator_in_path) as simulator_in_h5: simulator_in_h5.load_into(simulator_in) connectivity_gid = simulator_in_h5.connectivity.load() stimulus_gid = simulator_in_h5.stimulus.load() simulation_state_gid = simulator_in_h5.simulation_state.load() conn_index = dao.get_datatype_by_gid(connectivity_gid.hex) conn = h5.load_from_index(conn_index) simulator_in.connectivity = conn if simulator_in.surface: cortex_path = h5.path_for(storage_path, CortexH5, simulator_in.surface.gid) with CortexH5(cortex_path) as cortex_h5: local_conn_gid = cortex_h5.local_connectivity.load() region_mapping_gid = cortex_h5.region_mapping_data.load() region_mapping_index = dao.get_datatype_by_gid( region_mapping_gid.hex) region_mapping_path = h5.path_for_stored_index( region_mapping_index) region_mapping = RegionMapping() with RegionMappingH5(region_mapping_path) as region_mapping_h5: region_mapping_h5.load_into(region_mapping) region_mapping.gid = region_mapping_h5.gid.load() surf_gid = region_mapping_h5.surface.load() surf_index = dao.get_datatype_by_gid(surf_gid.hex) surf_h5 = h5.h5_file_for_index(surf_index) surf = CorticalSurface() surf_h5.load_into(surf) surf_h5.close() region_mapping.surface = surf simulator_in.surface.region_mapping_data = region_mapping if local_conn_gid: local_conn_index = dao.get_datatype_by_gid(local_conn_gid.hex) local_conn = h5.load_from_index(local_conn_index) simulator_in.surface.local_connectivity = local_conn if stimulus_gid: stimulus_index = dao.get_datatype_by_gid(stimulus_gid.hex) stimulus = h5.load_from_index(stimulus_index) simulator_in.stimulus = stimulus return simulator_in, simulation_state_gid
def setUp(self): self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) self.connectivity = TestFactory.get_entity(self.test_project, Connectivity()) self.assertTrue(self.connectivity is not None) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None)
def create_surface(self): """ Create a dummy surface entity. :return: (Algorithm Identifier, stored Surface entity) """ operation, algo_id, storage_path = self.__create_operation() surface = CorticalSurface(storage_path=storage_path) surface.vertices = numpy.array( [[-10, 0, 0], [0, 0, -10], [10, 0, 0], [0, 10, 0]], dtype=float) surface.triangles = numpy.array( [[0, 1, 2], [0, 1, 3], [1, 2, 3], [0, 2, 3]], dtype=int) surface.number_of_triangles = 4 surface.number_of_vertices = 4 surface.triangle_normals = numpy.ones((4, 3)) surface.vertex_normals = numpy.ones((4, 3)) surface.zero_based_triangles = True adapter_instance = StoreAdapter([surface]) OperationService().initiate_prelaunch(operation, adapter_instance, {}) return algo_id, surface
def setUp(self): """ Sets up the environment for running the tests; creates a test user, a test project, a connectivity and a surface; imports a CFF data-set """ self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) self.connectivity = self._get_entity(Connectivity()) self.surface = self._get_entity(CorticalSurface())
def get_data_for_model_param(self, param_name): """ Compute the equation configured for the current param_name. If no equation was set for param_name, return the default array. """ surface_dt = CorticalSurface() surface_h5 = h5.h5_file_for_index(self.surface_index) surface_h5.load_into(surface_dt) surface_h5.close() if param_name in self.applied_equations: temp = self.applied_equations[param_name] equation = temp[KEY_EQUATION] focal_points = temp[KEY_FOCAL_POINTS] # if focal points or the equation are missing do not update this model parameter if focal_points and equation: res = surface_dt.compute_equation(focal_points, equation) return res self.logger.warning( 'Focal points or Equation are missing for %s. Defaults will be used.', param_name) return self._get_default_value_for_model_param(param_name) else: return self._get_default_value_for_model_param(param_name)
def create_surface(self): """ Create a dummy surface entity. :returns: (Algorithm Identifier, stored Surface entity) """ operation, algo_id, storage_path = self.__create_operation() surface = CorticalSurface(storage_path=storage_path) surface.vertices = numpy.array([[-10, 0, 0], [0, 0, -10], [10, 0, 0], [0, 10, 0]], dtype=float) surface.triangles = numpy.array([[0, 1, 2], [0, 1, 3], [1, 2, 3], [0, 2, 3]], dtype=int) surface.number_of_triangles = 4 surface.number_of_vertices = 4 surface.triangle_normals = numpy.ones((4, 3)) surface.vertex_normals = numpy.ones((4, 3)) surface.zero_based_triangles = True surface.validate() adapter_instance = StoreAdapter([surface]) OperationService().initiate_prelaunch(operation, adapter_instance, {}) return algo_id, surface
def setUp(self): """ Sets up the environment for running the tests; creates a test user, a test project, a connectivity and a surface; imports a CFF data-set """ self.test_user = TestFactory.create_user() self.test_project = TestFactory.import_default_project(self.test_user) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) self.region_mapping = TestFactory.get_entity(self.test_project, RegionMapping()) self.assertTrue(self.region_mapping is not None)
def prepare_stimuli_surface_from_view_model(view_model, load_full_surface=False): # type: (SurfaceStimulusCreatorModel, bool) -> StimuliSurface stimuli_surface = StimuliSurface() stimuli_surface.focal_points_triangles = view_model.focal_points_triangles stimuli_surface.spatial = view_model.spatial stimuli_surface.temporal = view_model.temporal surface_index = SurfaceStimulusCreator.load_entity_by_gid(view_model.surface.hex) if load_full_surface: stimuli_surface.surface = h5.load_from_index(surface_index) else: stimuli_surface.surface = CorticalSurface() stimuli_surface.gid = view_model.surface surface_h5 = h5.h5_file_for_index(surface_index) # We need to load surface triangles on stimuli because focal_points_surface property needs to acces them stimuli_surface.surface.triangles = surface_h5.triangles.load() surface_h5.close() return stimuli_surface
def setUp(self): """ Reset the database before each test. """ self.test_user = TestFactory.create_user('CFF_User') self.test_project = TestFactory.create_project(self.test_user, "CFF_Project") TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) zip_path = os.path.join(os.path.dirname(sensors_dataset.__file__), 'EEG_unit_vectors_BrainProducts_62.txt.bz2') TestFactory.import_sensors(self.test_user, self.test_project, zip_path, 'EEG Sensors') self.connectivity = TestFactory.get_entity(self.test_project, Connectivity()) self.assertTrue(self.connectivity is not None) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) self.sensors = TestFactory.get_entity(self.test_project, SensorsEEG()) self.assertTrue(self.sensors is not None)
def prepare_stimuli_surface_from_view_model(self, view_model, load_full_surface=False): # type: (SurfaceStimulusCreatorModel, bool) -> StimuliSurface stimuli_surface = StimuliSurface() stimuli_surface.focal_points_triangles = view_model.focal_points_triangles stimuli_surface.spatial = view_model.spatial stimuli_surface.temporal = view_model.temporal if load_full_surface: stimuli_surface.surface = self.load_traited_by_gid( view_model.surface) else: stimuli_surface.surface = CorticalSurface() stimuli_surface.gid = view_model.surface # We need to load surface triangles on stimuli because focal_points_surface property needs to acces them with h5.h5_file_for_gid(view_model.surface) as surface_h5: stimuli_surface.surface.triangles = surface_h5.triangles.load() return stimuli_surface
def build(nr_vertices=10, valid_for_simulation=True, cortical=False): if cortical: return CorticalSurface( vertices=numpy.zeros((nr_vertices, 3)), triangles=numpy.zeros((3, 3), dtype=int), vertex_normals=numpy.zeros((nr_vertices, 3)), triangle_normals=numpy.zeros((3, 3)), number_of_vertices=nr_vertices, number_of_triangles=3, edge_mean_length=1.0, edge_min_length=0.0, edge_max_length=2.0, zero_based_triangles=False, split_triangles=numpy.arange(0), number_of_split_slices=1, split_slices=dict(), bi_hemispheric=False, # surface_type="surface", valid_for_simulations=True) return Surface(vertices=numpy.zeros((nr_vertices, 3)), triangles=numpy.zeros((3, 3), dtype=int), vertex_normals=numpy.zeros((nr_vertices, 3)), triangle_normals=numpy.zeros((3, 3)), number_of_vertices=nr_vertices, number_of_triangles=3, edge_mean_length=1.0, edge_min_length=0.0, edge_max_length=2.0, zero_based_triangles=False, split_triangles=numpy.arange(0), number_of_split_slices=1, split_slices=dict(), bi_hemispheric=False, surface_type="surface_cortical", valid_for_simulations=valid_for_simulation)
def configure(self, dt=2**-3, model=ModelsEnum.GENERIC_2D_OSCILLATOR.get_class(), speed=4.0, coupling_strength=0.00042, method=HeunDeterministic, surface_sim=False, default_connectivity=True, with_stimulus=False): """ Create an instance of the Simulator class, by default use the generic plane oscillator local dynamic model and the deterministic version of Heun's method for the numerical integration. """ self.method = method if default_connectivity: white_matter = Connectivity.from_file() region_mapping = RegionMapping.from_file( source_file="regionMapping_16k_76.txt") else: white_matter = Connectivity.from_file( source_file="connectivity_192.zip") region_mapping = RegionMapping.from_file( source_file="regionMapping_16k_192.txt") region_mapping.surface = CorticalSurface.from_file() white_matter_coupling = coupling.Linear( a=numpy.array([coupling_strength])) white_matter.speed = numpy.array( [speed]) # no longer allow scalars to numpy array promotion dynamics = model() if issubclass(method, IntegratorStochastic): hisss = noise.Additive(nsig=numpy.array([2**-11])) integrator = method(dt=dt, noise=hisss) else: integrator = method(dt=dt) if surface_sim: local_coupling_strength = numpy.array([2**-10]) default_cortex = Cortex.from_file() default_cortex.region_mapping_data = region_mapping default_cortex.coupling_strength = local_coupling_strength if default_connectivity: default_cortex.local_connectivity = LocalConnectivity.from_file( ) else: default_cortex.local_connectivity = LocalConnectivity() default_cortex.local_connectivity.surface = default_cortex.region_mapping_data.surface # TODO stimulus else: default_cortex = None if with_stimulus: weights = StimuliRegion.get_default_weights( white_matter.weights.shape[0]) weights[self.stim_nodes] = 1. stimulus = StimuliRegion(temporal=Linear(parameters={ "a": 0.0, "b": self.stim_value }), connectivity=white_matter, weight=weights) # Order of monitors determines order of returned values. self.sim = simulator.Simulator() self.sim.surface = default_cortex self.sim.model = dynamics self.sim.integrator = integrator self.sim.connectivity = white_matter self.sim.coupling = white_matter_coupling self.sim.monitors = self.monitors if with_stimulus: self.sim.stimulus = stimulus self.sim.configure()
def from_tvb_file(self, filepath): self._tvb = TVBCorticalSurface.from_file(filepath, self._tvb) self.vox2ras = np.array([]) self.file_path = filepath return self
class GIFTIParser(): """ This class reads content of a GIFTI file and builds / returns a Surface instance filled with details. """ UNIQUE_ID_ATTR = "UniqueID" SUBJECT_ATTR = "SubjectID" ASP_ATTR = "AnatomicalStructurePrimary" DATE_ATTR = "Date" DESCRIPTION_ATTR = "Description" NAME_ATTR = "Name" TIME_STEP_ATTR = "TimeStep" def __init__(self, storage_path, operation_id): self.logger = get_logger(__name__) self.storage_path = storage_path self.operation_id = operation_id def parse(self, data_file): """ Parse NIFTI file and returns TimeSeries for it. """ self.logger.debug("Start to parse GIFTI file: %s"%data_file) if data_file is None: raise ParseException ("Please select GIFTI file which contains data to import") if not os.path.exists(data_file): raise ParseException ("Provided file %s does not exists"%data_file) try: gifti_image = giftiio.read(data_file) self.logger.debug("File parsed successfully") except Exception, excep: self.logger.exception(excep) msg = "File: %s does not have a valid GIFTI format." % data_file raise ParseException(msg) # Now try to determine what data is stored in GIFTI file data_arrays = gifti_image.darrays self.logger.debug("Determine data type stored in GIFTI file") # First check if it's a surface if (len(data_arrays) == 2 and intent_codes.code["NIFTI_INTENT_POINTSET"] == data_arrays[0].intent and data_type_codes.code["NIFTI_TYPE_FLOAT32"] == data_arrays[0].datatype and intent_codes.code["NIFTI_INTENT_TRIANGLE"] == data_arrays[1].intent and data_type_codes.code["NIFTI_TYPE_INT32"] == data_arrays[1].datatype): # Now try to determine what type of surface we have data_array_meta = data_arrays[0].meta surface = None gid = None subject = None title = None if (data_array_meta is not None and data_array_meta.data is not None and len(data_array_meta.data) > 0): anatomical_structure_primary = None for meta_pair in data_array_meta.data: if meta_pair.name == self.ASP_ATTR: anatomical_structure_primary = meta_pair.value elif meta_pair.name == self.UNIQUE_ID_ATTR: gid = meta_pair.value.replace("{", "").replace("}", "") elif meta_pair.name == self.SUBJECT_ATTR: subject = meta_pair.value elif meta_pair.name == self.NAME_ATTR: title = meta_pair.value # Based on info found in meta create correct surface type if anatomical_structure_primary == "Head": surface = SkinAir() elif anatomical_structure_primary.startswith("Cortex"): surface = CorticalSurface() if surface is None: raise ParseException("Could not determine type of the surface") # Now fill TVB data type with info if gid is not None: surface.gid = gid surface.storage_path = self.storage_path surface.set_operation_id(self.operation_id) surface.zero_based_triangles = True surface.vertices = data_arrays[0].data surface.triangles = data_arrays[1].data if subject is not None: surface.subject = subject if title is not None: surface.title = title return surface elif(len(data_arrays) > 1 and intent_codes.code["NIFTI_INTENT_TIME_SERIES"] == data_arrays[0].intent and data_type_codes.code["NIFTI_TYPE_FLOAT32"] == data_arrays[0].datatype): # Create TVB time series to be filled time_series = TimeSeriesSurface() time_series.storage_path = self.storage_path time_series.set_operation_id(self.operation_id) time_series.start_time = 0.0 time_series.sample_period = 1.0 # First process first data_array and extract important data from it's metadata data_array_meta = data_arrays[0].meta if (data_array_meta is not None and data_array_meta.data is not None and len(data_array_meta.data) > 0): for meta_pair in data_array_meta.data: if meta_pair.name == self.UNIQUE_ID_ATTR: gid = meta_pair.value.replace("{", "").replace("}", "") if gid is not None and len(gid) > 0: time_series.gid = gid elif meta_pair.name == self.SUBJECT_ATTR: time_series.subject = meta_pair.value elif meta_pair.name == self.NAME_ATTR: time_series.title = meta_pair.value elif meta_pair.name == self.TIME_STEP_ATTR: time_series.sample_period = float(meta_pair.value) # Now read time series data for data_array in data_arrays: time_series.write_data_slice([data_array.data]) # Close file after writing data time_series.close_file() return time_series else: raise ParseException("Could not map data from GIFTI file to a TVB data type")
def test_localconnectivity_empty(self): dt = LocalConnectivity(surface=CorticalSurface()) assert dt.surface is not None
def configure(self, dt=2**-3, model=models.Generic2dOscillator, speed=4.0, coupling_strength=0.00042, method=HeunDeterministic, surface_sim=False, default_connectivity=True): """ Create an instance of the Simulator class, by default use the generic plane oscillator local dynamic model and the deterministic version of Heun's method for the numerical integration. """ self.method = method if default_connectivity: white_matter = Connectivity.from_file() region_mapping = RegionMapping.from_file( source_file="regionMapping_16k_76.txt") else: white_matter = Connectivity.from_file( source_file="connectivity_192.zip") region_mapping = RegionMapping.from_file( source_file="regionMapping_16k_192.txt") region_mapping.surface = CorticalSurface.from_file() white_matter_coupling = coupling.Linear( a=numpy.array([coupling_strength])) white_matter.speed = numpy.array( [speed]) # no longer allow scalars to numpy array promotion dynamics = model() if issubclass(method, IntegratorStochastic): hisss = noise.Additive(nsig=numpy.array([2**-11])) integrator = method(dt=dt, noise=hisss) else: integrator = method(dt=dt) if surface_sim: local_coupling_strength = numpy.array([2**-10]) default_cortex = Cortex.from_file() default_cortex.region_mapping_data = region_mapping default_cortex.coupling_strength = local_coupling_strength if default_connectivity: default_cortex.local_connectivity = LocalConnectivity.from_file( ) else: default_cortex.local_connectivity = LocalConnectivity() default_cortex.local_connectivity.surface = default_cortex.region_mapping_data.surface else: default_cortex = None # Order of monitors determines order of returned values. self.sim = simulator.Simulator() self.sim.surface = default_cortex self.sim.model = dynamics self.sim.integrator = integrator self.sim.connectivity = white_matter self.sim.coupling = white_matter_coupling self.sim.monitors = self.monitors self.sim.configure()
def launch(self, uploaded, surface_type, zero_based_triangles = False): """ Execute import operations: unpack ZIP and build Surface object as result. """ if uploaded is None: raise LaunchException ("Please select ZIP file which contains data to import") self.logger.debug("Start to import surface: '%s' from file: %s"%(surface_type, uploaded)) try: files = FilesHelper().unpack_zip(uploaded, self.storage_path) except IOError: exception_str = "Did not find the specified ZIP at %s" % uploaded raise LaunchException(exception_str) vertices = [] normals = [] triangles = [] for file_name in files: if file_name.lower().find(self.VERTICES_TOKEN) >= 0: vertices.append(file_name) continue if file_name.lower().find(self.NORMALS_TOKEN) >= 0: normals.append(file_name) continue if file_name.lower().find(self.TRIANGLES_TOKEN) >= 0: triangles.append(file_name) # Now detect and instantiate correct surface type self.logger.debug("Create surface instance") if surface_type == CORTICAL: surface = CorticalSurface() elif surface_type == INNER_SKULL: surface = BrainSkull() elif surface_type == OUTER_SKULL: surface = SkullSkin() elif surface_type == OUTER_SKIN: surface = SkinAir() elif surface_type == EEG_CAP: surface = EEGCap() elif surface_type == FACE: surface = FaceSurface() else: exception_str = "Could not determine surface type (selected option %s)" % surface_type raise LaunchException(exception_str) surface.storage_path = self.storage_path all_vertices, all_normals, all_triangles = self._process_files(vertices, normals, triangles) FilesHelper.remove_files(files, True) surface.zero_based_triangles = zero_based_triangles surface.vertices = all_vertices surface.vertex_normals = all_normals if zero_based_triangles: surface.triangles = all_triangles else : surface.triangles = all_triangles - 1 surface.triangle_normals = None # Now check if the triangles of the surface are valid triangles_min_vertex = numpy.amin(surface.triangles) if triangles_min_vertex < 0: if triangles_min_vertex == -1 and not zero_based_triangles: raise RuntimeError("Triangles contain a negative vertex index. Maybe you have a ZERO based surface.") else: raise RuntimeError("Your triangles contain a negative vertex index: %d" %triangles_min_vertex) no_of_vertices = len(surface.vertices) triangles_max_vertex = numpy.amax(surface.triangles) if triangles_max_vertex >= no_of_vertices: if triangles_max_vertex == no_of_vertices and zero_based_triangles: raise RuntimeError("Your triangles contain an invalid vertex index: %d. \ Maybe your surface is NOT ZERO Based."%triangles_max_vertex) else: raise RuntimeError("Your triangles contain an invalid vertex index: %d." %triangles_max_vertex) self.logger.debug("Surface ready to be stored") return surface
surface_type="surface", valid_for_simulations=True) region_mapping = RegionMapping(array_data=numpy.arange(5), connectivity=connectivity, surface=surface) cortical_surface = CorticalSurface( vertices=numpy.zeros((5, 3)), triangles=numpy.zeros((3, 3), dtype=int), vertex_normals=numpy.zeros((5, 3)), triangle_normals=numpy.zeros((3, 3)), number_of_vertices=5, number_of_triangles=3, edge_mean_length=1.0, edge_min_length=0.0, edge_max_length=2.0, zero_based_triangles=False, split_triangles=numpy.arange(0), number_of_split_slices=1, split_slices=dict(), bi_hemispheric=False, # surface_type="surface", valid_for_simulations=True) sensors = Sensors(sensors_type="SEEG", labels=numpy.array(["s1", "s2", "s3"]), locations=numpy.zeros((3, 3)), number_of_sensors=3, has_orientation=True, orientations=numpy.zeros((3, 3)),