def setUp(self):
num_segments = int(100)
num_vertices = num_segments + 1
x = np.linspace(0, 10, num_vertices)
y = np.zeros(num_vertices)
z = np.zeros(num_vertices)
d = np.linspace(1, 0.01, num_vertices)
connectivity = range(-1, num_segments)
vertices = np.array([x, y, z, d]).T
self.complex_vertices = vertices
physical_mask = np.zeros(num_vertices)
#third segment is non-physical:
physical_mask[2] = 1
physical_mask[20] = 1
self.complex_morphology = am.ArrayMorphology(
vertices=vertices,
connectivity=connectivity,
physical_mask=physical_mask,
id='test_arraymorph')
self.valid_vertices = [[0, 0, 0, 0.1], [1, 0, 0, 0.2], [2, 0, 0, 0.3],
[3, 0, 0, 0.4]]
self.valid_connectivity = [-1, 0, 1, 2]
self.optimized_morphology = am.ArrayMorphology(
vertices=self.valid_vertices,
connectivity=self.valid_connectivity,
id='test_arraymorph')
proximal_point = neuroml.Point3DWithDiam(
x=0.1,
y=0.2,
z=0.3,
diameter=1.1,
)
distal_point = neuroml.Point3DWithDiam(
x=0.0,
y=0.0,
z=0.0,
diameter=1.1,
)
soma = neuroml.Segment(
proximal=proximal_point,
distal=distal_point,
)
self.small_morphology = am.ArrayMorphology()
self.small_morphology.segments.append(soma)
def setUp(self):
num_segments = int(1e4) #Per cell
num_vertices = num_segments + 1
x = np.linspace(0, 10, num_vertices)
y = np.zeros(num_vertices)
z = np.zeros(num_vertices)
d = np.linspace(1, 0.01, num_vertices)
vertices = np.array([x, y, z, d]).T
connectivity = range(-1, num_segments)
big_arraymorph = am.ArrayMorphology(vertices=vertices,
connectivity=connectivity)
transposed_x = x + 10
transposed_vertices = np.array([transposed_x, y, z, d]).T
transposed_arraymorph = am.ArrayMorphology(
vertices=transposed_vertices, connectivity=connectivity)
bigger_d = d + 0.5
fatter_vertices = np.array([x, y, z, bigger_d]).T
fatter_arraymorph = am.ArrayMorphology(vertices=fatter_vertices,
connectivity=connectivity)
neuroml_cell = neuroml.Cell(id='cell_4')
neuroml_morphology = neuroml.Morphology(id='my_morph')
neuroml_cell.morphology = neuroml_morphology
self.transposed_arraymorph = transposed_arraymorph
self.fatter_arraymorph = fatter_arraymorph
self.big_arraymorph = big_arraymorph
self.cell_1 = neuroml.Cell(id='cell_1')
self.cell_2 = neuroml.Cell(id='cell_2')
self.cell_3 = neuroml.Cell(id='cell_3')
self.cell_1.morphology = transposed_arraymorph
self.cell_2.morphology = fatter_arraymorph
self.cell_3.morphology = big_arraymorph
self.test_doc = neuroml.NeuroMLDocument(id='TestDocument')
self.test_doc.cells.append(self.cell_1)
self.test_doc.cells.append(self.cell_2)
self.test_doc.cells.append(self.cell_3)
self.test_doc.cells.append(neuroml_cell)
def test_large_arraymorph(self):
"""
This will generate a morphology which will be difficult to
generate without the optimized intenral representation.
The morphology has 3 million segments
"""
num_segments = int(1e6)
num_vertices = num_segments + 1
x = np.linspace(0,10,num_vertices)
y = np.zeros(num_vertices)
z = np.zeros(num_vertices)
d = np.linspace(1,0.01,num_vertices)
vertices = np.array([x,y,z,d]).T
connectivity = range(-1,num_segments)
big_arraymorph = am.ArrayMorphology(vertices = vertices,
connectivity = connectivity)
self.assertIsInstance(big_arraymorph.segments[3],neuroml.Segment)
self.assertEqual(big_arraymorph.segments[0].distal.diameter,1.0)
#following test not as obvious as it seems - first execution of getter does not have the same result as second
self.assertEqual(big_arraymorph.segments[2333],big_arraymorph.segments[2333])
self.assertEqual(big_arraymorph.segments[0].distal.diameter,1.0)
self.assertEqual(big_arraymorph.segments[num_segments-1].proximal.x,10.0)
self.assertEqual(big_arraymorph.segments[0].distal.x,0.0)
self.assertEqual(big_arraymorph.segments[num_segments-1].proximal.diameter,0.01)
def test_pop(self):
new_morphology = am.ArrayMorphology(self.optimized_morphology.vertices,
self.optimized_morphology.connectivity)#
new_morphology.pop(1)
new_connectivity = new_morphology.connectivity
self.assertTrue(np.array_equal(new_connectivity,[-1,0,1]))
def test_to_root(self):
new_morphology = am.ArrayMorphology(self.optimized_morphology.vertices,
self.optimized_morphology.connectivity)
new_morphology.to_root(2)
new_connectivity = new_morphology.connectivity
self.assertTrue(np.array_equal(new_connectivity,[1,2,-1,2]))
def __init__(self, num_segments=1e6):
num_segments = int(num_segments)
num_vertices = int(num_segments) + 1
x = np.linspace(0, 10, num_vertices)
y = np.zeros(num_vertices)
z = np.zeros(num_vertices)
d = np.linspace(1, 0.01, num_vertices)
vertices = np.array([x, y, z, d]).T
connectivity = range(-1, num_segments)
big_arraymorph = am.ArrayMorphology(vertices=vertices,
connectivity=connectivity)
self.big_arraymorph = big_arraymorph
self.cell = neuroml.Cell(id='test_cell')
self.cell.morphology = big_arraymorph
self.test_doc = neuroml.NeuroMLDocument(id='TestDocument')
self.test_doc.cells.append(self.cell)
self.__write_time = None
self.num_segments = num_segments
def __extract_morphology(cls, node):
loaded_morphology = arraymorph.ArrayMorphology()
loaded_morphology.physical_mask = node.physical_mask[:]
loaded_morphology.vertices = node.vertices[:]
loaded_morphology.connectivity = node.connectivity[:]
return loaded_morphology
def load_swc_single(cls, src, name=None):
import numpy as np
from neuroml import arraymorph
dtype = {
'names': ('id', 'type', 'x', 'y', 'z', 'r', 'pid'),
'formats': ('int32', 'int32', 'f4', 'f4', 'f4', 'f4', 'int32')
}
d = np.loadtxt(src, dtype=dtype)
if len(np.nonzero(d['pid'] == -1)) != 1:
assert False, "Unexpected number of id's of -1 in file"
num_nodes = len(d['pid'])
root_index = np.where(d['pid'] == -1)[0][0]
# We might not nessesarily have continuous indices in the
# SWC file, so lets convert them:
index_to_id = d['id']
id_to_index_dict = dict([(id, index)
for index, id in enumerate(index_to_id)])
if len(id_to_index_dict) != len(index_to_id):
s = "Internal Error Loading SWC: Index and ID map are different lengths."
s += " [ID:%d, Index:%d]" % (len(index_to_id),
len(id_to_index_dict))
raise MorphologyImportError(s)
# Vertices and section types are easy:
vertices = d[['x', 'y', 'z', 'r']]
vertices = np.vstack([d['x'], d['y'], d['z'], d['r']]).T
section_types = [swctype for ID, swctype in d[['id', 'type']]]
#for connection indices we want the root to have index -1:
connection_indices = np.zeros(num_nodes, dtype='int32')
for i in range(num_nodes):
pID = d['pid'][i]
if pID != -1:
parent_index = id_to_index_dict[pID]
connection_indices[i] = parent_index
else:
connection_indices[i] = -1
#This needs to become an "Optimized Morphology" of some kind
return arraymorph.ArrayMorphology(vertices=vertices,
connectivity=connection_indices,
node_types=section_types,
name=name)
def setUp(self):
"""
Testing a complex hand-built morphology (from neuroml objects
rather than arrays)
"""
p = neuroml.Point3DWithDiam(x=0,y=0,z=0,diameter=50)
d = neuroml.Point3DWithDiam(x=50,y=0,z=0,diameter=50)
soma = neuroml.Segment(proximal=p, distal=d)
soma.name = 'Soma'
soma.id = 0
#now make an axon with 100 compartments:
parent = neuroml.SegmentParent(segments=soma.id)
parent_segment = soma
axon_segments = []
seg_id = 1
for i in range(100):
p = neuroml.Point3DWithDiam(x=parent_segment.distal.x,
y=parent_segment.distal.y,
z=parent_segment.distal.z,
diameter=0.1)
d = neuroml.Point3DWithDiam(x=parent_segment.distal.x+10,
y=parent_segment.distal.y,
z=parent_segment.distal.z,
diameter=0.1)
axon_segment = neuroml.Segment(proximal = p,
distal = d,
parent = parent)
axon_segment.id = seg_id
axon_segment.name = 'axon_segment_' + str(axon_segment.id)
#now reset everything:
parent = neuroml.SegmentParent(segments=axon_segment.id)
parent_segment = axon_segment
seg_id += 1
axon_segments.append(axon_segment)
test_morphology = am.ArrayMorphology()
test_morphology.segments.append(soma)
test_morphology.segments += axon_segments
test_morphology.id = "TestMorphology"
self.test_morphology = test_morphology
def setUp(self):
"""
Make an optimized morphology, add a couple of segments, save it
and then load it back
"""
vertices = [[0, 0, 0, 0.1], [1, 0, 0, 0.2], [2, 0, 0, 0.3],
[3, 0, 0, 0.4]]
connectivity = [-1, 0, 1, 2]
self.optimized_morphology = am.ArrayMorphology(
vertices=vertices, connectivity=connectivity, id="arraymorph_test")
seg = neuroml.Segment()
#TODO:
#self.optimized_morphology.segments.append(seg)
doc = neuroml.NeuroMLDocument()
cell = neuroml.Cell()
def test_instantiation(self):
"""
Test an arraymorph can be instantiated with default parameters
"""
morphology = am.ArrayMorphology()
diameter=0.1)
axon_segment = neuroml.Segment(proximal=p, distal=d, parent=parent)
axon_segment.id = seg_id
axon_segment.name = 'axon_segment_' + str(axon_segment.id)
#now reset everything:
parent = neuroml.SegmentParent(segments=axon_segment.id)
parent_segment = axon_segment
seg_id += 1
axon_segments.append(axon_segment)
test_morphology = am.ArrayMorphology()
test_morphology.segments.append(soma)
test_morphology.segments += axon_segments
test_morphology.id = "TestMorphology"
cell = neuroml.Cell()
cell.name = 'TestCell'
cell.id = 'TestCell'
cell.morphology = test_morphology
doc = neuroml.NeuroMLDocument()
#doc.name = "Test neuroML document"
doc.cells.append(cell)
doc.id = "TestNeuroMLDocument"
