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 sensors_to_surface(self, sensors_gid, surface_to_map_gid): """ Map EEG sensors onto the head surface (skin-air). EEG sensor locations are typically only given on a unit sphere, that is, they are effectively only identified by their orientation with respect to a coordinate system. This method is used to map these unit vector sensor "locations" to a specific location on the surface of the skin. Assumes coordinate systems are aligned, i.e. common x,y,z and origin. """ # Normalize sensor and vertex locations to unit vectors sensors_h5_class, sensors_h5_path = self._load_h5_of_gid(sensors_gid) sensors_dt = Sensors() with sensors_h5_class(sensors_h5_path) as sensors_h5: sensors_h5.load_into(sensors_dt) surface_h5_class, surface_h5_path = self._load_h5_of_gid( surface_to_map_gid) surface_dt = Surface() with surface_h5_class(surface_h5_path) as surface_h5: surface_h5.load_into(surface_dt) return sensors_dt.sensors_to_surface(surface_dt).tolist()
def test_store_load_complete_region_mapping(tmph5factory, connectivity_factory, surface_factory, region_mapping_factory): connectivity = connectivity_factory(2) surface = surface_factory(5) region_mapping = region_mapping_factory(surface, connectivity) with ConnectivityH5(tmph5factory('Connectivity_{}.h5'.format(connectivity.gid))) as conn_h5: conn_h5.store(connectivity) conn_stored = Connectivity() conn_h5.load_into(conn_stored) with SurfaceH5(tmph5factory('Surface_{}.h5'.format(surface.gid))) as surf_h5: surf_h5.store(surface) surf_stored = Surface() surf_h5.load_into(surf_stored) with RegionMappingH5(tmph5factory('RegionMapping_{}.h5'.format(region_mapping.gid))) as rm_h5: rm_h5.store(region_mapping) rm_stored = RegionMapping() rm_h5.load_into(rm_stored) # load_into will not load dependent datatypes. connectivity and surface are undefined with pytest.raises(TraitAttributeError): rm_stored.connectivity with pytest.raises(TraitAttributeError): rm_stored.surface rm_stored.connectivity = conn_stored rm_stored.surface = surf_stored assert rm_stored.connectivity is not None assert rm_stored.surface is not None
def test_store_load_surface(tmph5factory, surface_factory): surface = surface_factory(5) surf_h5 = SurfaceH5(tmph5factory()) surf_h5.store(surface) surf_h5.close() surf_stored = Surface() with pytest.raises(AttributeError): surf_stored.vertices surf_h5.load_into(surf_stored) assert surf_stored.vertices.shape[0] == 5
def test_store_load_configured_surf(tmph5factory, surface_factory): surface = surface_factory(5) # surface.configure() assert surface.number_of_vertices == 5 assert surface.edge_max_length == 2.0 tmp_path = tmph5factory() with SurfaceH5(tmp_path) as f: f.store(surface) surf_stored = Surface() with SurfaceH5(tmp_path) as f: f.load_into(surf_stored) assert f.get_number_of_split_slices() == 1 assert f.get_slice_vertex_boundaries(0) == (0, 5) assert surf_stored.number_of_vertices == 5 assert surf_stored.number_of_triangles == 3 assert surf_stored.edge_max_length == 2.0
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)
hemispheres=numpy.array([True, True, True, True]), orientations=numpy.zeros((2, 2)), areas=numpy.zeros((4, )), number_of_regions=2, number_of_connections=4, # parent_connectivity="" saved_selection=["a", "b", "C"]) surface = Surface(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) 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),
def get_lines_slice(self, slice_number=0): """ Read the gl lines values for the current slice number. """ return Surface._triangles_to_lines(self.get_triangles_slice(slice_number))