def test_happy_flow_import(self):
"""
Test that importing a CFF generates at least one DataType in DB.
"""
dt_count_before = TestFactory.get_entity_count(self.test_project,
Connectivity())
group = dao.find_group(
'tvb.adapters.uploaders.zip_connectivity_importer',
'ZIPConnectivityImporter')
importer = ABCAdapter.build_adapter(group)
importer.meta_data = {
DataTypeMetaData.KEY_SUBJECT: DataTypeMetaData.DEFAULT_SUBJECT,
DataTypeMetaData.KEY_STATE: "RAW"
}
zip_path = os.path.join(
os.path.abspath(os.path.dirname(dataset.__file__)),
'connectivity_regions_96.zip')
args = {'uploaded': zip_path}
### Launch Operation
FlowService().fire_operation(importer, self.test_user,
self.test_project.id, **args)
dt_count_after = TestFactory.get_entity_count(self.test_project,
Connectivity())
self.assertTrue(dt_count_after == dt_count_before + 1)
def _burst_create_connectivity(self):
"""
Create a connectivity that will be used in "non-dummy" burst launches (with the actual simulator).
TODO: This is duplicate code from burstservice_test. Should go into the 'generic' DataType factory
once that is done.
"""
meta = {
DataTypeMetaData.KEY_SUBJECT: "John Doe",
DataTypeMetaData.KEY_STATE: "RAW_DATA"
}
algorithm, algo_group = FlowService(
).get_algorithm_by_module_and_class(SIMULATOR_MODULE, SIMULATOR_CLASS)
self.operation = model.Operation(self.test_user.id,
self.test_project.id,
algo_group.id,
json.dumps(''),
meta=json.dumps(meta),
status=model.STATUS_STARTED)
self.operation = dao.store_entity(self.operation)
storage_path = FilesHelper().get_project_folder(
self.test_project, str(self.operation.id))
connectivity = Connectivity(storage_path=storage_path)
connectivity.weights = numpy.ones((74, 74))
connectivity.centres = numpy.ones((74, 3))
adapter_instance = StoreAdapter([connectivity])
OperationService().initiate_prelaunch(self.operation, adapter_instance,
{})
return connectivity
def test_happy_flow_import(self):
"""
Test that importing a CFF generates at least one DataType in DB.
"""
TestConnectivityZip.import_test_connectivity96(self.test_user,
self.test_project,
subject=TEST_SUBJECT_A)
field = FilterChain.datatype + '.subject'
filters = FilterChain('', [field], [TEST_SUBJECT_A], ['=='])
reference_connectivity = TestFactory.get_entity(self.test_project, Connectivity(), filters)
dt_count_before = TestFactory.get_entity_count(self.test_project, Connectivity())
self._import_csv_test_connectivity(reference_connectivity.gid, TEST_SUBJECT_B)
dt_count_after = TestFactory.get_entity_count(self.test_project, Connectivity())
assert dt_count_before + 1 == dt_count_after
filters = FilterChain('', [field], [TEST_SUBJECT_B], ['like'])
imported_connectivity = TestFactory.get_entity(self.test_project, Connectivity(), filters)
# check relationship between the imported connectivity and the reference
assert (reference_connectivity.centres == imported_connectivity.centres).all()
assert (reference_connectivity.orientations == imported_connectivity.orientations).all()
assert reference_connectivity.number_of_regions == imported_connectivity.number_of_regions
assert (reference_connectivity.region_labels == imported_connectivity.region_labels).all()
assert not (reference_connectivity.weights == imported_connectivity.weights).all()
assert not (reference_connectivity.tract_lengths == imported_connectivity.tract_lengths).all()
def _burst_create_connectivity(self):
"""
Create a connectivity that will be used in "non-dummy" burst launches (with the actual simulator).
"""
meta = {
DataTypeMetaData.KEY_SUBJECT: "John Doe",
DataTypeMetaData.KEY_STATE: "RAW_DATA"
}
self.operation = model.Operation(self.test_user.id,
self.test_project.id,
self.sim_algorithm.id,
json.dumps(''),
meta=json.dumps(meta),
status=model.STATUS_STARTED)
self.operation = dao.store_entity(self.operation)
storage_path = FilesHelper().get_project_folder(
self.test_project, str(self.operation.id))
connectivity = Connectivity(storage_path=storage_path)
connectivity.weights = numpy.ones((74, 74))
connectivity.centres = numpy.ones((74, 3))
adapter_instance = StoreAdapter([connectivity])
self.operation_service.initiate_prelaunch(self.operation,
adapter_instance, {})
return connectivity
def launch(self, weights, weights_delimiter, tracts, tracts_delimiter, input_data):
"""
Execute import operations: process the weights and tracts csv files, then use
the reference connectivity passed as input_data for the rest of the attributes.
:param weights: csv file containing the weights measures
:param tracts: csv file containing the tracts measures
:param input_data: a reference connectivity with the additional attributes
:raises LaunchException: when the number of nodes in CSV files doesn't match the one in the connectivity
"""
weights_matrix = self._read_csv_file(weights, weights_delimiter)
tract_matrix = self._read_csv_file(tracts, tracts_delimiter)
FilesHelper.remove_files([weights, tracts])
if weights_matrix.shape[0] != input_data.number_of_regions:
raise LaunchException("The csv files define %s nodes but the connectivity you selected as reference "
"has only %s nodes." % (weights_matrix.shape[0], input_data.number_of_regions))
result = Connectivity()
result.storage_path = self.storage_path
result.centres = input_data.centres
result.region_labels = input_data.region_labels
result.weights = weights_matrix
result.tract_lengths = tract_matrix
result.orientations = input_data.orientations
result.areas = input_data.areas
result.cortical = input_data.cortical
result.hemispheres = input_data.hemispheres
return result
def parse(self, network):
"""
Populate Connectivity DataType from NetworkX object.
Tested with results from Connectome Mapper Toolkit.
:param network: NetworkX graph
:return: Connectivity object
"""
graph_size = len(network.nodes())
weights_matrix = numpy.zeros((graph_size, graph_size))
tract_matrix = numpy.zeros((graph_size, graph_size))
labels_vector, positions, cortical, hemisphere = [], [], [], []
try:
for node in range(1, graph_size + 1):
node_data = network.nodes[node]
pos = self._find_value(node_data, self.KEY_NODE_COORDINATES)
positions.append(list(pos))
label = self._find_value(node_data, self.KEY_NODE_LABEL)
labels_vector.append(str(label))
if self.REGION_CORTICAL == self._find_value(
node_data, self.KEY_NODE_REGION):
cortical.append(True)
else:
cortical.append(False)
if self.HEMISPHERE_RIGHT == self._find_value(
node_data, self.KEY_NODE_HEMISPHERE):
hemisphere.append(True)
else:
hemisphere.append(False)
# Iterate over edges:
for start, end in network.edges():
weights_matrix[start - 1][end - 1] = self._find_value(
network.adj[start][end], self.KEY_EDGE_WEIGHT)
tract_matrix[start - 1][end - 1] = self._find_value(
network.adj[start][end], self.KEY_EDGE_TRACT)
result = Connectivity()
result.region_labels = numpy.array(labels_vector)
result.centres = numpy.array(positions)
# result.set_metadata({'description': 'Array Columns: labels, X, Y, Z'}, 'centres')
result.hemispheres = numpy.array(hemisphere)
result.cortical = numpy.array(cortical)
result.weights = weights_matrix
result.tract_lengths = tract_matrix
result.configure()
return result
except KeyError as err:
self.logger.exception("Could not parse Connectivity")
raise ParseException(err)
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(load_default=True)
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")
white_matter_coupling = coupling.Linear(a=coupling_strength)
white_matter.speed = speed
dynamics = model()
if method[-10:] == "Stochastic":
hisss = noise.Additive(nsig=numpy.array([2**-11]))
integrator = eval("integrators." + method + "(dt=dt, noise=hisss)")
else:
integrator = eval("integrators." + method + "(dt=dt)")
if surface_sim:
local_coupling_strength = numpy.array([2**-10])
default_cortex = Cortex(load_default=True,
region_mapping_data=region_mapping)
default_cortex.coupling_strength = local_coupling_strength
default_cortex.local_connectivity = LocalConnectivity(
load_default=default_connectivity, surface=default_cortex)
else:
default_cortex = None
# Order of monitors determines order of returned values.
self.sim = simulator.Simulator(model=dynamics,
connectivity=white_matter,
coupling=white_matter_coupling,
integrator=integrator,
monitors=self.monitors,
surface=default_cortex)
self.sim.configure()
def create_connectivity(self):
"""
Create a connectivity that will be used in "non-dummy" burst launches (with the actual simulator).
"""
operation, algo_id, storage_path = self.__create_operation()
connectivity = Connectivity(storage_path=storage_path)
connectivity.weights = numpy.ones((74, 74))
connectivity.centres = numpy.ones((74, 3))
adapter_instance = StoreAdapter([connectivity])
OperationService().initiate_prelaunch(operation, adapter_instance, {})
return algo_id, connectivity
def create_connectivity(self, nodes=74):
"""
Create a connectivity that will be used in "non-dummy" burst launches (with the actual simulator).
"""
operation, algo_id, storage_path = self.__create_operation()
connectivity = Connectivity(storage_path=storage_path)
connectivity.weights = numpy.ones((nodes, nodes))
connectivity.centres = numpy.ones((nodes, 3))
adapter_instance = StoreAdapter([connectivity])
OperationService().initiate_prelaunch(operation, adapter_instance, {})
return algo_id, connectivity
def parse(self, network):
"""
Populate Connectivity DataType from NetworkX object.
Tested with results from Connectome Mapper Toolkit.
:param network: NetworkX graph
:return: Connectivity object
"""
graph_size = len(network.nodes())
weights_matrix = numpy.zeros((graph_size, graph_size))
tract_matrix = numpy.zeros((graph_size, graph_size))
labels_vector, positions, cortical, hemisphere = [], [], [], []
try:
for node in network.nodes():
node_data = network.node[node]
pos = self._find_value(node_data, self.KEY_NODE_COORDINATES)
positions.append(list(pos))
label = self._find_value(node_data, self.KEY_NODE_LABEL)
labels_vector.append(str(label))
if self.REGION_CORTICAL == self._find_value(node_data, self.KEY_NODE_REGION):
cortical.append(1)
else:
cortical.append(0)
if self.HEMISPHERE_RIGHT == self._find_value(node_data, self.KEY_NODE_HEMISPHERE):
hemisphere.append(True)
else:
hemisphere.append(False)
# Iterate over edges:
for start, end in network.edges():
weights_matrix[start - 1][end - 1] = self._find_value(network.adj[start][end], self.KEY_EDGE_WEIGHT)
tract_matrix[start - 1][end - 1] = self._find_value(network.adj[start][end], self.KEY_EDGE_TRACT)
result = Connectivity()
result.storage_path = self.storage_path
result.region_labels = labels_vector
result.centres = positions
result.set_metadata({'description': 'Array Columns: labels, X, Y, Z'}, 'centres')
result.hemispheres = hemisphere
result.cortical = cortical
result.weights = weights_matrix
result.tract_lengths = tract_matrix
return result
except KeyError, err:
self.logger.exception("Could not parse Connectivity")
raise ParseException(err)
def _create_connectivity(self, nodes_number):
"""
Create a connectivity entity and return its GID
"""
storage_path = FilesHelper().get_project_folder(self.test_project, str(self.operation.id))
connectivity = Connectivity(storage_path=storage_path)
connectivity.weights = numpy.ones((nodes_number, nodes_number))
connectivity.centres = numpy.ones((nodes_number, 3))
adapter_instance = StoreAdapter([connectivity])
OperationService().initiate_prelaunch(self.operation, adapter_instance, {})
return dao.get_datatype_by_id(connectivity.id).gid
def _create_connectivity(self, nodes_number):
"""
Create a connectivity entity and return its GID
"""
storage_path = FilesHelper().get_project_folder(self.test_project, str(self.operation.id))
connectivity = Connectivity(storage_path=storage_path)
connectivity.weights = numpy.ones((nodes_number, nodes_number))
connectivity.centres = numpy.ones((nodes_number, 3))
adapter_instance = StoreAdapter([connectivity])
OperationService().initiate_prelaunch(self.operation, adapter_instance, {})
return dao.get_datatype_by_id(connectivity.id).gid
def test_happy_flow_import(self):
"""
Test that importing a CFF generates at least one DataType in DB.
"""
dt_count_before = TestFactory.get_entity_count(self.test_project,
Connectivity())
ConnectivityZipTest.import_test_connectivity96(self.test_user,
self.test_project)
dt_count_after = TestFactory.get_entity_count(self.test_project,
Connectivity())
self.assertEqual(dt_count_before + 1, dt_count_after)
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):
"""
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 build_simulator(self, n=4):
self.conn = numpy.zeros((n, n)) # , numpy.int32)
for i in range(self.conn.shape[0] - 1):
self.conn[i, i + 1] = 1
self.dist = numpy.r_[:n * n].reshape((n, n))
self.dist = numpy.array(self.dist, dtype=float)
self.sim = Simulator(
conduction_speed=1.0,
coupling=IdCoupling(),
surface=None,
stimulus=None,
integrator=Identity(dt=1.0),
initial_conditions=numpy.ones((n * n, 1, n, 1)),
simulation_length=10.0,
connectivity=Connectivity(region_labels=numpy.array(['']),
weights=self.conn,
tract_lengths=self.dist,
speed=numpy.array([1.0]),
centres=numpy.array([0.0])),
model=Sum(),
monitors=(Raw(), ),
)
self.sim.configure()
def _burst_create_connectivity(self):
"""
Create a connectivity that will be used in "non-dummy" burst launches (with the actual simulator).
"""
meta = {DataTypeMetaData.KEY_SUBJECT: "John Doe", DataTypeMetaData.KEY_STATE: "RAW_DATA"}
self.operation = model.Operation(self.test_user.id, self.test_project.id, self.sim_algorithm.id,
json.dumps(''), meta=json.dumps(meta), status=model.STATUS_STARTED)
self.operation = dao.store_entity(self.operation)
storage_path = FilesHelper().get_project_folder(self.test_project, str(self.operation.id))
connectivity = Connectivity(storage_path=storage_path)
connectivity.weights = numpy.ones((74, 74))
connectivity.centres = numpy.ones((74, 3))
adapter_instance = StoreAdapter([connectivity])
self.operation_service.initiate_prelaunch(self.operation, adapter_instance, {})
return connectivity
def _create_sim(self, integrator=None, inhom_mmpr=False, delays=False,
run_sim=True):
mpr = MontbrioPazoRoxin()
conn = Connectivity.from_file()
if inhom_mmpr:
dispersion = 1 + np.random.randn(conn.weights.shape[0])*0.1
mpr = MontbrioPazoRoxin(eta=mpr.eta*dispersion)
conn.speed = np.r_[3.0 if delays else np.inf]
if integrator is None:
dt = 0.01
integrator = EulerDeterministic(dt=dt)
else:
dt = integrator.dt
sim = Simulator(connectivity=conn, model=mpr, integrator=integrator,
monitors=[Raw()],
simulation_length=0.1) # 10 steps
sim.configure()
if not delays:
self.assertTrue((conn.idelays == 0).all())
buf = sim.history.buffer[...,0]
# kernel has history in reverse order except 1st element 🤕
rbuf = np.concatenate((buf[0:1], buf[1:][::-1]), axis=0)
state = np.transpose(rbuf, (1, 0, 2)).astype('f')
self.assertEqual(state.shape[0], 2)
self.assertEqual(state.shape[2], conn.weights.shape[0])
if isinstance(sim.integrator, IntegratorStochastic):
sim.integrator.noise.reset_random_stream()
if run_sim:
(t,y), = sim.run()
return sim, state, t, y
else:
return sim
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 from_file(filepath, **kwargs):
result = TVBConnectivity.from_file(filepath)
if isinstance(result, TVBConnectivity):
raise NotImplementedError
# return Connectivity.from_tvb_instance(result, **kwargs)
else:
result.centres = result.centers
return Connectivity.from_instance(result, **kwargs)
def from_tvb_file(self, filepath):
self._tvb = TVBConnectivity.from_file(filepath, self._tvb)
if len(self.normalized_weights) == 0:
self.normalized_weights = normalize_weights(self._tvb.weights,
remove_diagonal=True,
ceil=1.0)
self.file_path = filepath
return self
def test_bad_reference(self):
TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project)
field = FilterChain.datatype + '.subject'
filters = FilterChain('', [field], [TEST_SUBJECT_A], ['!='])
bad_reference_connectivity = TestFactory.get_entity(self.test_project, Connectivity(), filters)
with pytest.raises(OperationException):
self._import_csv_test_connectivity(bad_reference_connectivity.gid, TEST_SUBJECT_A)
def _burst_create_connectivity(self):
"""
Create a connectivity that will be used in "non-dummy" burst launches (with the actual simulator).
TODO: This is duplicate code from burstservice_test. Should go into the 'generic' DataType factory
once that is done.
"""
meta = {DataTypeMetaData.KEY_SUBJECT: "John Doe", DataTypeMetaData.KEY_STATE: "RAW_DATA"}
algorithm = FlowService().get_algorithm_by_module_and_class(SIMULATOR_MODULE, SIMULATOR_CLASS)
self.operation = model.Operation(self.test_user.id, self.test_project.id, algorithm.id,
json.dumps(''), meta=json.dumps(meta), status=model.STATUS_STARTED)
self.operation = dao.store_entity(self.operation)
storage_path = FilesHelper().get_project_folder(self.test_project, str(self.operation.id))
connectivity = Connectivity(storage_path=storage_path)
connectivity.weights = numpy.ones((74, 74))
connectivity.centres = numpy.ones((74, 3))
adapter_instance = StoreAdapter([connectivity])
OperationService().initiate_prelaunch(self.operation, adapter_instance, {})
return connectivity
def _import_connectivity(self):
importer = TestFactory.create_adapter('tvb.adapters.uploaders.zip_connectivity_importer',
'ZIPConnectivityImporter')
### Launch Operation
FlowService().fire_operation(importer, self.test_user, self.test_project.id,
uploaded=self.connectivity_path, Data_Subject='QL')
self.connectivity = TestFactory.get_entity(self.test_project, Connectivity())
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 transactional_setup_method(self):
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'connectivity_66.zip')
self.test_user = TestFactory.create_user('Test_User')
self.test_project = TestFactory.create_project(self.test_user,
"Test_Project")
TestFactory.import_zip_connectivity(self.test_user, self.test_project,
"John", zip_path)
self.connectivity = TestFactory.get_entity(self.test_project,
Connectivity())
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_store_load_connectivity(tmph5factory, connectivity_factory):
connectivity = connectivity_factory(2)
conn_h5 = ConnectivityH5(tmph5factory())
conn_h5.store(connectivity)
conn_h5.close()
conn_stored = Connectivity()
with pytest.raises(TraitAttributeError):
conn_stored.region_labels
conn_h5.load_into(conn_stored)
assert conn_stored.region_labels.shape[0] == 2
def test_cortexdata(self):
dt = Cortex.from_file(
local_connectivity_file="local_connectivity_16384.mat")
dt.region_mapping_data.connectivity = Connectivity.from_file()
assert isinstance(dt, Cortex)
assert dt.region_mapping is not None
dt.configure()
assert dt.vertices.shape == (16384, 3)
assert dt.vertex_normals.shape == (16384, 3)
assert dt.triangles.shape == (32760, 3)
def test_cortex_reg_map_without_subcorticals(self):
dt = Cortex.from_file()
dt.region_mapping_data.connectivity = Connectivity.from_file()
self.add_subcorticals_to_conn(dt.region_mapping_data.connectivity)
dt.region_mapping_data.connectivity.configure()
assert isinstance(dt, Cortex)
assert dt.region_mapping is not None
assert numpy.unique(
dt.region_mapping
).size == dt.region_mapping_data.connectivity.number_of_regions
def test_store_partial_connectivity(tmph5factory):
partial_conn = Connectivity(
region_labels=numpy.array(["a", "b"]),
weights=numpy.zeros((2, 2)),
tract_lengths=numpy.zeros((2, 2)),
centres=numpy.zeros((2, 2)),
number_of_regions=int(2),
number_of_connections=int(4),
)
conn_h5 = ConnectivityH5(tmph5factory())
conn_h5.store(partial_conn)
conn_h5.close()
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 = TestFactory.get_entity(self.test_project, Connectivity())
self.assertTrue(self.connectivity 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 = 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 _prepare_connectivity():
connectivity = Connectivity(weights=numpy.array([[0.0, 2.0, 3.0, 4.0],
[2.0, 0.0, 2.0, 3.0],
[3.0, 2.0, 0.0, 1.0],
[4.0, 3.0, 1.0, 0.0]]),
tract_lengths=numpy.array([[0.0, 2.0, 3.0, 4.0],
[2.0, 0.0, 2.0, 3.0],
[3.0, 2.0, 0.0, 1.0],
[4.0, 3.0, 1.0, 0.0]]),
region_labels=numpy.array(["a", "b", "c", "d"]),
centres=numpy.array([1.0, 2.0, 3.0, 4.0]),
areas=numpy.array([1.0, 2.0, 3.0, 4.0]))
return connectivity
def launch(self, view_model):
# type: (RegionStimulusCreatorModel) -> [StimuliRegionIndex]
"""
Used for creating a `StimuliRegion` instance
"""
stimuli_region = StimuliRegion()
stimuli_region.connectivity = Connectivity()
stimuli_region.connectivity.gid = view_model.connectivity
stimuli_region.weight = view_model.weight
stimuli_region.temporal = view_model.temporal
self.generic_attributes.user_tag_1 = view_model.display_name
stimuli_region_idx = self.store_complete(stimuli_region)
return stimuli_region_idx
def build(nr_regions=4):
return Connectivity(region_labels=numpy.array(["a"] * nr_regions),
weights=numpy.zeros((nr_regions, nr_regions)),
undirected=True,
tract_lengths=numpy.zeros(
(nr_regions, nr_regions)),
centres=numpy.zeros((nr_regions, nr_regions)),
cortical=numpy.array([True] * nr_regions),
hemispheres=numpy.array([True] * nr_regions),
orientations=numpy.zeros((nr_regions, nr_regions)),
areas=numpy.zeros((nr_regions * nr_regions, )),
number_of_regions=nr_regions,
number_of_connections=nr_regions * nr_regions,
saved_selection=[1, 2, 3])
def launch(self, resolution, weighting, inj_f_thresh, vol_thresh):
resolution = int(resolution)
weighting = int(weighting)
inj_f_thresh = float(inj_f_thresh)/100.
vol_thresh = float(vol_thresh)
project = dao.get_project_by_id(self.current_project_id)
manifest_file = self.file_handler.get_allen_mouse_cache_folder(project.name)
manifest_file = os.path.join(manifest_file, 'mouse_connectivity_manifest.json')
cache = MouseConnectivityCache(resolution=resolution, manifest_file=manifest_file)
# the method creates a dictionary with information about which experiments need to be downloaded
ist2e = dictionary_builder(cache, False)
# the method downloads experiments necessary to build the connectivity
projmaps = download_an_construct_matrix(cache, weighting, ist2e, False)
# the method cleans the file projmaps in 4 steps
projmaps = pms_cleaner(projmaps)
# download from the AllenSDK the annotation volume, the template volume
vol, annot_info = cache.get_annotation_volume()
template, template_info = cache.get_template_volume()
# rotate template in the TVB 3D reference:
template = rotate_reference(template)
# grab the StructureTree instance
structure_tree = cache.get_structure_tree()
# the method includes in the parcellation only brain regions whose volume is greater than vol_thresh
projmaps = areas_volume_threshold(cache, projmaps, vol_thresh, resolution)
# the method exclude from the experimental dataset
# those exps where the injected fraction of pixel in the injection site is lower than than the inj_f_thr
projmaps = infected_threshold(cache, projmaps, inj_f_thresh)
# the method creates file order and keyword that will be the link between the SC order and the
# id key in the Allen database
[order, key_ord] = create_file_order(projmaps, structure_tree)
# the method builds the Structural Connectivity (SC) matrix
structural_conn = construct_structural_conn(projmaps, order, key_ord)
# the method returns the coordinate of the centres and the name of the brain areas in the selected parcellation
[centres, names] = construct_centres(cache, order, key_ord)
# the method returns the tract lengths between the brain areas in the selected parcellation
tract_lengths = construct_tract_lengths(centres)
# the method associated the parent and the grandparents to the child in the selected parcellation with
# the biggest volume
[unique_parents, unique_grandparents] = parents_and_grandparents_finder(cache, order, key_ord, structure_tree)
# the method returns a volume indexed between 0 and N-1, with N=tot brain areas in the parcellation.
# -1=background and areas that are not in the parcellation
vol_parcel = mouse_brain_visualizer(vol, order, key_ord, unique_parents, unique_grandparents,
structure_tree, projmaps)
# results: Connectivity, Volume & RegionVolumeMapping
# Connectivity
result_connectivity = Connectivity(storage_path=self.storage_path)
result_connectivity.centres = centres
result_connectivity.region_labels = names
result_connectivity.weights = structural_conn
result_connectivity.tract_lengths = tract_lengths
# Volume
result_volume = Volume(storage_path=self.storage_path)
result_volume.origin = [[0.0, 0.0, 0.0]]
result_volume.voxel_size = [resolution, resolution, resolution]
# result_volume.voxel_unit= micron
# Region Volume Mapping
result_rvm = RegionVolumeMapping(storage_path=self.storage_path)
result_rvm.volume = result_volume
result_rvm.array_data = vol_parcel
result_rvm.connectivity = result_connectivity
result_rvm.title = "Volume mouse brain "
result_rvm.dimensions_labels = ["X", "Y", "Z"]
# Volume template
result_template = StructuralMRI(storage_path=self.storage_path)
result_template.array_data = template
result_template.weighting = 'T1'
result_template.volume = result_volume
return [result_connectivity, result_volume, result_rvm, result_template]
def launch(self, uploaded, rotate_x=0, rotate_y=0, rotate_z=0):
"""
Execute import operations: unpack ZIP and build Connectivity object as result.
:param uploaded: an archive containing the Connectivity data to be imported
:returns: `Connectivity`
:raises LaunchException: when `uploaded` is empty or nonexistent
:raises Exception: when
* weights or tracts matrix is invalid (negative values, wrong shape)
* any of the vector orientation, areas, cortical or hemisphere is \
different from the expected number of nodes
"""
if uploaded is None:
raise LaunchException("Please select ZIP file which contains data to import")
files = FilesHelper().unpack_zip(uploaded, self.storage_path)
weights_matrix = None
centres = None
labels_vector = None
tract_matrix = None
orientation = None
areas = None
cortical_vector = None
hemisphere_vector = None
for file_name in files:
if file_name.lower().find(self.WEIGHT_TOKEN) >= 0:
weights_matrix = read_list_data(file_name)
continue
if file_name.lower().find(self.POSITION_TOKEN) >= 0:
centres = read_list_data(file_name, skiprows=1, usecols=[1, 2, 3])
labels_vector = read_list_data(file_name, dtype=numpy.str, skiprows=1, usecols=[0])
continue
if file_name.lower().find(self.TRACT_TOKEN) >= 0:
tract_matrix = read_list_data(file_name)
continue
if file_name.lower().find(self.ORIENTATION_TOKEN) >= 0:
orientation = read_list_data(file_name)
continue
if file_name.lower().find(self.AREA_TOKEN) >= 0:
areas = read_list_data(file_name)
continue
if file_name.lower().find(self.CORTICAL_INFO) >= 0:
cortical_vector = read_list_data(file_name, dtype=numpy.bool)
continue
if file_name.lower().find(self.HEMISPHERE_INFO) >= 0:
hemisphere_vector = read_list_data(file_name, dtype=numpy.bool)
continue
### Clean remaining text-files.
FilesHelper.remove_files(files, True)
result = Connectivity()
result.storage_path = self.storage_path
result.nose_correction = [rotate_x, rotate_y, rotate_z]
### Fill positions
if centres is None:
raise Exception("Positions for Connectivity Regions are required! "
"We expect a file *position* inside the uploaded ZIP.")
expected_number_of_nodes = len(centres)
if expected_number_of_nodes < 2:
raise Exception("A connectivity with at least 2 nodes is expected")
result.centres = centres
if labels_vector is not None:
result.region_labels = labels_vector
### Fill and check weights
if weights_matrix is not None:
if numpy.any([x < 0 for x in weights_matrix.flatten()]):
raise Exception("Negative values are not accepted in weights matrix! "
"Please check your file, and use values >= 0")
if weights_matrix.shape != (expected_number_of_nodes, expected_number_of_nodes):
raise Exception("Unexpected shape for weights matrix! "
"Should be %d x %d " % (expected_number_of_nodes, expected_number_of_nodes))
result.weights = weights_matrix
### Fill and check tracts
if tract_matrix is not None:
if numpy.any([x < 0 for x in tract_matrix.flatten()]):
raise Exception("Negative values are not accepted in tracts matrix! "
"Please check your file, and use values >= 0")
if tract_matrix.shape != (expected_number_of_nodes, expected_number_of_nodes):
raise Exception("Unexpected shape for tracts matrix! "
"Should be %d x %d " % (expected_number_of_nodes, expected_number_of_nodes))
result.tract_lengths = tract_matrix
if orientation is not None:
if len(orientation) != expected_number_of_nodes:
raise Exception("Invalid size for vector orientation. "
"Expected the same as region-centers number %d" % expected_number_of_nodes)
result.orientations = orientation
if areas is not None:
if len(areas) != expected_number_of_nodes:
raise Exception("Invalid size for vector areas. "
"Expected the same as region-centers number %d" % expected_number_of_nodes)
result.areas = areas
if cortical_vector is not None:
if len(cortical_vector) != expected_number_of_nodes:
raise Exception("Invalid size for vector cortical. "
"Expected the same as region-centers number %d" % expected_number_of_nodes)
result.cortical = cortical_vector
if hemisphere_vector is not None:
if len(hemisphere_vector) != expected_number_of_nodes:
raise Exception("Invalid size for vector hemispheres. "
"Expected the same as region-centers number %d" % expected_number_of_nodes)
result.hemispheres = hemisphere_vector
return result
def networkx2connectivity(network_obj, storage_path):
"""
Populate Connectivity DataType from NetworkX object.
"""
network_obj.load()
weights_matrix, tract_matrix, labels_vector = [], [], []
positions, areas, orientation = [], [], []
# Read all nodes
graph_data = network_obj.data
graph_size = len(graph_data.nodes())
for node in graph_data.nodes():
positions.append([graph_data.node[node][ct.KEY_POS_X],
graph_data.node[node][ct.KEY_POS_Y],
graph_data.node[node][ct.KEY_POS_Z]])
labels_vector.append(graph_data.node[node][ct.KEY_POS_LABEL])
if ct.KEY_AREA in graph_data.node[node]:
areas.append(graph_data.node[node][ct.KEY_AREA])
if ct.KEY_ORIENTATION_AVG in graph_data.node[node]:
orientation.append(graph_data.node[node][ct.KEY_ORIENTATION_AVG])
weights_matrix.append([0.0] * graph_size)
tract_matrix.append([0.0] * graph_size)
# Read all edges
for edge in network_obj.data.edges():
start = edge[0]
end = edge[1]
weights_matrix[start][end] = graph_data.adj[start][end][ct.KEY_WEIGHT]
tract_matrix[start][end] = graph_data.adj[start][end][ct.KEY_TRACT]
meta = network_obj.get_metadata_as_dict()
result = Connectivity()
result.storage_path = storage_path
result.nose_correction = meta[ct.KEY_NOSE] if ct.KEY_NOSE in meta else None
result.weights = weights_matrix
result.centres = positions
result.region_labels = labels_vector
result.set_metadata({'description':'Array Columns: labels, X, Y, Z'},'centres')
result.orientations = orientation
result.areas = areas
result.tract_lengths = tract_matrix
return result, (meta[ct.KEY_UID] if ct.KEY_UID in meta else None)
def launch(self, resolution, weighting, inf_vox_thresh, vol_thresh):
resolution = int(resolution)
weighting = int(weighting)
inf_vox_thresh = float(inf_vox_thresh)
vol_thresh = float(vol_thresh)
project = dao.get_project_by_id(self.current_project_id)
manifest_file = self.file_handler.get_allen_mouse_cache_folder(project.name)
manifest_file = os.path.join(manifest_file, "mouse_connectivity_manifest.json")
cache = MouseConnectivityCache(resolution=resolution, manifest_file=manifest_file)
# the method creates a dictionary with information about which experiments need to be downloaded
ist2e = DictionaireBuilder(cache, False)
# the method downloads experiments necessary to build the connectivity
projmaps = DownloadAndConstructMatrix(cache, weighting, ist2e, False)
# the method cleans the file projmaps in 4 steps
projmaps = pmsCleaner(projmaps)
Vol, annot_info = cache.get_annotation_volume()
ontology = cache.get_ontology()
# the method includes in the parcellation only brain regions whose volume is greater than vol_thresh
projmaps = AreasVolumeTreshold(projmaps, vol_thresh, resolution, Vol, ontology)
# the method includes in the parcellation only brain regions where at least one injection experiment had infected more than N voxel (where N is inf_vox_thresh)
projmaps = AreasVoxelTreshold(cache, projmaps, inf_vox_thresh, Vol, ontology)
# the method creates file order and keyord that will be the link between the SC order and the id key in the Allen database
[order, key_ord] = CreateFileOrder(projmaps, ontology)
# the method builds the Structural Connectivity (SC) matrix
SC = ConstructingSC(projmaps, order, key_ord)
# the method returns the coordinate of the centres and the name of the brain areas in the selected parcellation
[centres, names] = Construct_centres(ontology, order, key_ord, Vol)
# the method returns the tract lengths between the brain areas in the selected parcellation
tract_lengths = ConstructTractLengths(centres)
# the method associated the parent and the grandparents to the child in the selected parcellation with the biggest volume
[unique_parents, unique_grandparents] = ParentsAndGrandParentsFinder(order, key_ord, Vol, ontology)
# the method returns a volume indexed between 0 and N-1, with N=tot brain areas in the parcellation. -1=background and areas that are not in the parcellation
Vol_parcel = MouseBrainVisualizer(Vol, order, key_ord, unique_parents, unique_grandparents, ontology, projmaps)
# results: Connectivity, Volume & RegionVolumeMapping
# Connectivity
result_connectivity = Connectivity(storage_path=self.storage_path)
result_connectivity.centres = centres
result_connectivity.region_labels = names
result_connectivity.weights = SC
result_connectivity.tract_lengths = tract_lengths
# Volume
result_volume = Volume(storage_path=self.storage_path)
result_volume.origin = [[0.0, 0.0, 0.0]]
result_volume.voxel_size = [resolution, resolution, resolution]
# result_volume.voxel_unit= micron
# Region Volume Mapping
result_rvm = RegionVolumeMapping(storage_path=self.storage_path)
result_rvm.volume = result_volume
result_rvm.array_data = Vol_parcel
result_rvm.connectivity = result_connectivity
result_rvm.title = "Volume mouse brain "
result_rvm.dimensions_labels = ["X", "Y", "Z"]
return [result_connectivity, result_rvm, result_volume]
def launch(self, weights, tracts, input_data):
"""
Execute import operations: process the weights and tracts csv files, then use
the reference connectivity passed as input_data for the rest of the attributes.
:param weights: csv file containing the weights measures
:param tracts: csv file containing the tracts measures
:param input_data: a reference connectivity with the additional attributes
:raises LaunchException: when the number of nodes in CSV files doesn't match the one in the connectivity
"""
dti_service = DTIPipelineService()
dti_service._process_csv_file(weights, dti_service.WEIGHTS_FILE)
dti_service._process_csv_file(tracts, dti_service.TRACT_FILE)
weights_matrix = read_list_data(os.path.join(os.path.dirname(weights), dti_service.WEIGHTS_FILE))
tract_matrix = read_list_data(os.path.join(os.path.dirname(tracts), dti_service.TRACT_FILE))
FilesHelper.remove_files([os.path.join(os.path.dirname(weights), dti_service.WEIGHTS_FILE),
os.path.join(os.path.dirname(tracts), dti_service.TRACT_FILE)])
if weights_matrix.shape[0] != input_data.orientations.shape[0]:
raise LaunchException("The csv files define %s nodes but the connectivity you selected as reference "
"has only %s nodes." % (weights_matrix.shape[0], input_data.orientations.shape[0]))
result = Connectivity()
result.storage_path = self.storage_path
result.nose_correction = input_data.nose_correction
result.centres = input_data.centres
result.region_labels = input_data.region_labels
result.weights = weights_matrix
result.tract_lengths = tract_matrix
result.orientations = input_data.orientations
result.areas = input_data.areas
result.cortical = input_data.cortical
result.hemispheres = input_data.hemispheres
return result
