Esempio n. 1
0
    def test_children_of(self):

        morphology = test_morphology_small()
        node = test_node(id=1,
                         type=SOMA,
                         x=800,
                         y=610,
                         z=30,
                         radius=35,
                         parent_node_id=-1)
        children = morphology.children_of(node)
        expected_children = [
            test_node(id=2,
                      type=BASAL_DENDRITE,
                      x=400,
                      y=600,
                      z=10,
                      radius=3,
                      parent_node_id=1),
            test_node(id=4,
                      type=APICAL_DENDRITE,
                      x=600,
                      y=300,
                      z=20,
                      radius=3,
                      parent_node_id=1),
            test_node(id=6,
                      type=AXON,
                      x=900,
                      y=600,
                      z=30,
                      radius=3,
                      parent_node_id=1)
        ]
        self.assertEqual(children, expected_children)
Esempio n. 2
0
    def test_get_leaf_nodes(self):

        morphology = test_morphology_small()
        leaf_nodes = morphology.get_leaf_nodes()
        expected_leaf_node_ids = set([3, 5, 7])
        self.assertEqual(set([leaf_node['id'] for leaf_node in leaf_nodes]),
                         expected_leaf_node_ids)
Esempio n. 3
0
    def test_get_root(self):

        morphology = test_morphology_small()
        expected_root = test_node(id=1,
                                  type=SOMA,
                                  x=800,
                                  y=610,
                                  z=30,
                                  radius=35,
                                  parent_node_id=-1)
        self.assertEqual(expected_root, morphology.get_root())
Esempio n. 4
0
    def test_node_by_id(self):

        morphology = test_morphology_small()
        expected_node = test_node(id=4,
                                  type=APICAL_DENDRITE,
                                  x=600,
                                  y=300,
                                  z=20,
                                  radius=3,
                                  parent_node_id=1)
        node_by_id = morphology.node_by_id(4)
        self.assertEqual(expected_node, node_by_id)
Esempio n. 5
0
    def test_get_compartment_for_node_with_type(self):

        morphology = test_morphology_small()
        node_types = [AXON]
        node = test_node(id=2,
                         type=BASAL_DENDRITE,
                         x=400,
                         y=600,
                         z=10,
                         radius=3,
                         parent_node_id=1)
        compartment = morphology.get_compartment_for_node(node, node_types)
        expected_compartment = None
        self.assertEqual(expected_compartment, compartment)
Esempio n. 6
0
    def test_get_non_soma_nodes(self):

        morphology = test_morphology_small()
        expected_nodes = [
            test_node(id=2,
                      type=BASAL_DENDRITE,
                      x=400,
                      y=600,
                      z=10,
                      radius=3,
                      parent_node_id=1),
            test_node(id=3,
                      type=BASAL_DENDRITE,
                      x=400,
                      y=600,
                      z=10,
                      radius=3,
                      parent_node_id=2),
            test_node(id=4,
                      type=APICAL_DENDRITE,
                      x=600,
                      y=300,
                      z=20,
                      radius=3,
                      parent_node_id=1),
            test_node(id=5,
                      type=APICAL_DENDRITE,
                      x=600,
                      y=300,
                      z=20,
                      radius=3,
                      parent_node_id=4),
            test_node(id=6,
                      type=AXON,
                      x=900,
                      y=600,
                      z=30,
                      radius=3,
                      parent_node_id=1),
            test_node(id=7,
                      type=AXON,
                      x=900,
                      y=600,
                      z=30,
                      radius=3,
                      parent_node_id=6)
        ]

        nodes = morphology.get_non_soma_nodes()
        self.assertEqual(expected_nodes, nodes)
Esempio n. 7
0
    def test_get_compartment_volume(self):
        morphology = test_morphology_small()  # not actually using nodes

        compartment = [{
            "x": 0,
            "y": 0,
            "z": 0,
            "radius": 10
        }, {
            "x": 0,
            "y": 0,
            "z": 5,
            "radius": 5
        }]

        self.assertAlmostEqual(morphology.get_compartment_volume(compartment),
                               916.297857,
                               places=6)
Esempio n. 8
0
    def test_get_compartment_surface_area(self):
        morphology = test_morphology_small()  # not actually using nodes

        compartment = [{
            "x": 0,
            "y": 0,
            "z": 0,
            "radius": 10
        }, {
            "x": 0,
            "y": 0,
            "z": 5,
            "radius": 5
        }]

        self.assertAlmostEqual(
            morphology.get_compartment_surface_area(compartment),
            333.21622,
            places=6)
Esempio n. 9
0
    def test_parent_of(self):

        morphology = test_morphology_small()
        node = test_node(id=2,
                         type=BASAL_DENDRITE,
                         x=400,
                         y=600,
                         z=10,
                         radius=3,
                         parent_node_id=1)
        expected_parent = test_node(id=1,
                                    type=SOMA,
                                    x=800,
                                    y=610,
                                    z=30,
                                    radius=35,
                                    parent_node_id=-1)
        parent = morphology.parent_of(node)
        self.assertEqual(expected_parent, parent)
Esempio n. 10
0
    def test_get_children_of_node_by_type(self):

        morphology = test_morphology_small()
        node = test_node(id=1,
                         type=SOMA,
                         x=800,
                         y=610,
                         z=30,
                         radius=35,
                         parent_node_id=-1)
        expected_children_by_type = {
            BASAL_DENDRITE: [
                test_node(id=2,
                          type=BASAL_DENDRITE,
                          x=400,
                          y=600,
                          z=10,
                          radius=3,
                          parent_node_id=1)
            ],
            APICAL_DENDRITE: [
                test_node(id=4,
                          type=APICAL_DENDRITE,
                          x=600,
                          y=300,
                          z=20,
                          radius=3,
                          parent_node_id=1)
            ],
            AXON: [
                test_node(id=6,
                          type=AXON,
                          x=900,
                          y=600,
                          z=30,
                          radius=3,
                          parent_node_id=1)
            ]
        }
        for node_type in [BASAL_DENDRITE, APICAL_DENDRITE, AXON]:
            child = morphology.get_children_of_node_by_types(node, [node_type])
            self.assertEqual(expected_children_by_type[node_type], child)
Esempio n. 11
0
    def test_get_compartment_for_node_with_no_type(self):

        morphology = test_morphology_small()
        node = test_node(id=2,
                         type=BASAL_DENDRITE,
                         x=400,
                         y=600,
                         z=10,
                         radius=3,
                         parent_node_id=1)
        compartment = morphology.get_compartment_for_node(node)
        expected_compartment = [
            test_node(id=1,
                      type=SOMA,
                      x=800,
                      y=610,
                      z=30,
                      radius=35,
                      parent_node_id=-1), node
        ]
        self.assertEqual(expected_compartment, compartment)
Esempio n. 12
0
    def test_get_compartment_midpoint(self):

        morphology = test_morphology_small()
        compartment = [
            test_node(id=1,
                      type=SOMA,
                      x=800,
                      y=610,
                      z=30,
                      radius=35,
                      parent_node_id=-1),
            test_node(id=2,
                      type=BASAL_DENDRITE,
                      x=400,
                      y=600,
                      z=10,
                      radius=3,
                      parent_node_id=1)
        ]
        midpoint = morphology.get_compartment_midpoint(compartment)
        expected_midpoint = [600.0, 605.0, 20.0]
        self.assertEqual(expected_midpoint, midpoint)
Esempio n. 13
0
    def test_get_compartment_length(self):

        morphology = test_morphology_small()
        compartment = [
            test_node(id=1,
                      type=SOMA,
                      x=800,
                      y=610,
                      z=30,
                      radius=35,
                      parent_node_id=-1),
            test_node(id=2,
                      type=BASAL_DENDRITE,
                      x=400,
                      y=600,
                      z=10,
                      radius=3,
                      parent_node_id=1)
        ]
        expected_legnth = 400.6245124802026
        length = morphology.get_compartment_length(compartment)
        self.assertEqual(expected_legnth, length)
Esempio n. 14
0
    def test_get_compartment_list(self):

        morphology = test_morphology_small()
        compartments = morphology.compartments
        expected_compartments = [[
            test_node(id=1,
                      type=SOMA,
                      x=800,
                      y=610,
                      z=30,
                      radius=35,
                      parent_node_id=-1),
            test_node(id=2,
                      type=BASAL_DENDRITE,
                      x=400,
                      y=600,
                      z=10,
                      radius=3,
                      parent_node_id=1)
        ],
                                 [
                                     test_node(id=2,
                                               type=BASAL_DENDRITE,
                                               x=400,
                                               y=600,
                                               z=10,
                                               radius=3,
                                               parent_node_id=1),
                                     test_node(id=3,
                                               type=BASAL_DENDRITE,
                                               x=400,
                                               y=600,
                                               z=10,
                                               radius=3,
                                               parent_node_id=2)
                                 ],
                                 [
                                     test_node(id=1,
                                               type=SOMA,
                                               x=800,
                                               y=610,
                                               z=30,
                                               radius=35,
                                               parent_node_id=-1),
                                     test_node(id=4,
                                               type=APICAL_DENDRITE,
                                               x=600,
                                               y=300,
                                               z=20,
                                               radius=3,
                                               parent_node_id=1)
                                 ],
                                 [
                                     test_node(id=4,
                                               type=APICAL_DENDRITE,
                                               x=600,
                                               y=300,
                                               z=20,
                                               radius=3,
                                               parent_node_id=1),
                                     test_node(id=5,
                                               type=APICAL_DENDRITE,
                                               x=600,
                                               y=300,
                                               z=20,
                                               radius=3,
                                               parent_node_id=4)
                                 ],
                                 [
                                     test_node(id=1,
                                               type=SOMA,
                                               x=800,
                                               y=610,
                                               z=30,
                                               radius=35,
                                               parent_node_id=-1),
                                     test_node(id=6,
                                               type=AXON,
                                               x=900,
                                               y=600,
                                               z=30,
                                               radius=3,
                                               parent_node_id=1)
                                 ],
                                 [
                                     test_node(id=6,
                                               type=AXON,
                                               x=900,
                                               y=600,
                                               z=30,
                                               radius=3,
                                               parent_node_id=1),
                                     test_node(id=7,
                                               type=AXON,
                                               x=900,
                                               y=600,
                                               z=30,
                                               radius=3,
                                               parent_node_id=6)
                                 ]]

        self.assertEqual(expected_compartments, compartments)
Esempio n. 15
0
    def test_len(self):

        morphology = test_morphology_small()
        expected_length = 7
        self.assertEqual(expected_length, len(morphology))
Esempio n. 16
0
    def test_get_root_id(self):

        morphology = test_morphology_small()
        expected_root_id = 1
        root_id = morphology.get_root_id()
        self.assertEqual(expected_root_id, root_id)