Beispiel #1
0
    def testAddLinked(self):
        """
        Tests addLinked() and getNLinked()
        """

        # read svs
        sv = Vesicles.read(files=self.sv_files, catalog=self.catalog, 
                           membrane=self.mem_files, lumen=self.lum_files)

        # read connectors
        conn_files = {
            'rim_wt' : {'77_4': 'segmentations/conn_77-4_new_rest.pkl',
                        '78_3': 'segmentations/conn_78-3_new_rest.pkl'},
            'rim_altered' : {'75_4' : 'segmentations/conn_75-4_new_rest.pkl'}}

        # calculate linked and N linked
        sv.addLinked(files=self.catalog.connector_files)
        sv.getNLinked()

        # test 77_4
        np_test.assert_equal(
            sv.rim_wt.getValue(identifier='77_4', property='linked', ids=3),
            [4, 30])
        np_test.assert_equal(
            sv.rim_wt.getValue(identifier='77_4', property='n_linked', ids=3), 
            2)
        np_test.assert_equal(
            sv.rim_wt.getValue(identifier='77_4', property='linked', ids=5),
            [4, 22, 88])
        np_test.assert_equal(
            sv.rim_wt.getValue(identifier='77_4', property='n_linked', ids=5), 
            3)
Beispiel #2
0
    def testReadCatalogs(self):
        """
        Tests read() with catalogs
        """

        # read
        sv = Vesicles.read(files=self.sv_files, catalog=self.catalog, 
                           membrane=self.mem_files, lumen=self.lum_files)

        # test general
        np_test.assert_equal(sv.rim_wt.identifiers, ['77_4', '78_3'])
        np_test.assert_equal(sv.rim_altered.identifiers, ['75_4'])

        # test 77_4
        np_test.assert_equal(
            sv.rim_wt.getValue(identifier='77_4', property='ids'), 
            list(range(2, 144)))
        np_test.assert_almost_equal(
            sv.rim_wt.getValue(identifier='77_4', property='density', ids=7),
            -0.02, decimal=2)
        np_test.assert_almost_equal(
            sv.rim_wt.getValue(identifier='77_4', property='membrane_density', 
                               ids=7),
            -0.04, decimal=2)
        np_test.assert_almost_equal(
            sv.rim_wt.getValue(identifier='77_4', property='lumen_density', 
                               ids=7),
            0.00, decimal=2)

        # test 78_3
        np_test.assert_equal(
            sv.rim_wt.getValue(identifier='78_3', property='ids'), 
            list(range(2,81)))
        np_test.assert_almost_equal(
            sv.rim_wt.getValue(identifier='78_3', property='meanDistance', 
                               ids=7), 
            50.4, decimal=1)
        np_test.assert_almost_equal(
            sv.rim_wt.getValue(identifier='78_3', property='minDistance', 
                               ids=7),
            44.0, decimal=1)

        # test 75_4
        np_test.assert_equal(
            sv.rim_altered.getValue(identifier='75_4', property='ids'), 
            list(range(2, 133)))
        np_test.assert_almost_equal(
            sv.rim_altered.getValue(identifier='75_4', property='radius', 
                                    ids=7),
            6.3, decimal=1)
        np_test.assert_almost_equal(
            sv.rim_altered.getValue(identifier='75_4', property='radius_nm', 
                                    ids=7),
            16.5, decimal=1)
Beispiel #3
0
    def testRead_order(self):
        """
        Tests read() with specified order
        """

        # make order and read
        order = {'rim_wt' : ['78_3', '77_4'], 'rim_altered' : ['75_4']}
        sv = Vesicles.read(
            files=self.sv_files, catalog=self.catalog, order=order,
            membrane=self.mem_files, lumen=self.lum_files)
 
        # test general
        np_test.assert_equal(sv.rim_wt.identifiers, ['78_3', '77_4'])
        np_test.assert_equal(sv.rim_altered.identifiers, ['75_4'])
Beispiel #4
0
    def testGetN(self):
        """
        Tests getN()
        """

        # read svs
        sv = Vesicles.read(files=self.sv_files, catalog=self.catalog,
                           membrane=self.mem_files, lumen=self.mem_files)
        pixel_size = self.catalog.pixel_size['rim_wt']['77_4']

        # n vesicles 
        sv.getNVesicles(name='n_ves')
        np_test.assert_equal(
            sv.rim_wt.getValue(identifier='77_4', property='n_ves'), 142)
        np_test.assert_equal(
            sv.rim_wt.getValue(identifier='78_3', property='n_ves'), 79)
        np_test.assert_equal(
            sv.rim_altered.getValue(identifier='75_4', property='n_ves'), 131)

        # n vesicles per unit layer area
        sv.getNVesicles(name='n_area', layer=self.layer)
        np_test.assert_almost_equal(
            sv.rim_wt.getValue(identifier='77_4', property='n_area'), 
            142 / (7557 * pixel_size**2 * 1e-6), 
            decimal=1)

        # n vesicles per unit layer area, layer_factor=0.001
        sv.getNVesicles(name='n_area', layer=self.layer, layer_factor=0.001)
        np_test.assert_almost_equal(
            sv.rim_wt.getValue(identifier='77_4', property='n_area'), 
            142 / (7557 * pixel_size**2 * 0.001), 
            decimal=4)
 
       # unit layer area in nm^2
        sv.getNVesicles(name='area_nm', layer=self.layer, inverse=True, 
                        fixed=1, layer_factor=1.)
        np_test.assert_almost_equal(
            sv.rim_wt.getValue(identifier='77_4', property='area_nm'), 
            7557 * pixel_size**2, 
            decimal=1)

       # unit layer area in nm^3
        sv.getNVesicles(name='area_um', layer=self.layer, inverse=True, 
                        fixed=1, layer_factor=1.e-6)
        np_test.assert_almost_equal(
            sv.rim_wt.getValue(identifier='77_4', property='area_um'), 
            7557 * pixel_size**2 * 1.e-6, 
            decimal=1)
Beispiel #5
0
    def testGetMeanConnectionLength(self):
        """
        Tests getMeanConnectionLength()
        """

        # read svs
        sv = Vesicles.read(files=self.sv_files, catalog=self.catalog,
                           membrane=self.mem_files, lumen=self.mem_files)

        # calculate mean tether lengths
        sv.getMeanConnectionLength(conn=self.tether, name='mean_tether_nm')

        # test 77_4
        np_test.assert_almost_equal(
            sv.rim_wt.getValue(identifier='77_4', property='mean_tether_nm', 
                               ids=3),
            5.54 * self.catalog.pixel_size['rim_wt']['77_4'], 
            decimal=1)
        np_test.assert_almost_equal(
            sv.rim_wt.getValue(identifier='77_4', property='mean_tether_nm', 
                               ids=5),
            4.88 * self.catalog.pixel_size['rim_wt']['77_4'], 
            decimal=1)
Beispiel #6
0
    def setUp(self):
        """
        """

        # set sv files and adjust paths
        dir_, base = os.path.split(__file__)
        sv_files = {
            'rim_wt' : {'77_4': 'segmentations/sv_77-4_vesicles.pkl',
                        '78_3': 'segmentations/sv_78-3_vesicles.pkl'},
            'rim_altered' : {'75_4' : 'segmentations/sv_75-4_vesicles.pkl'}}
        for categ in sv_files:
            for ident, name in list(sv_files[categ].items()):
               sv_files[categ][ident] = os.path.join(dir_, name)
        self.sv_files = sv_files

        # set membrane files and adjust paths
        mem_files = {          
            'rim_wt' : {'77_4': 'segmentations/sv_77-4_mem.pkl',
                        '78_3': 'segmentations/sv_78-3_mem.pkl'},
            'rim_altered' : {'75_4' : 'segmentations/sv_75-4_mem.pkl'}}
        for categ in mem_files:
            for ident, name in list(mem_files[categ].items()):
               mem_files[categ][ident] = os.path.join(dir_, name)
        self.mem_files = mem_files

        # set lumen files and adjust paths
        lum_files = {
            'rim_wt' : {'77_4': 'segmentations/sv_77-4_lum.pkl',
                        '78_3': 'segmentations/sv_78-3_lum.pkl'},
            'rim_altered' : {'75_4' : 'segmentations/sv_75-4_lum.pkl'}}
        for categ in lum_files:
            for ident, name in list(lum_files[categ].items()):
               lum_files[categ][ident] = os.path.join(dir_, name)
        self.lum_files = lum_files

        # set catalog for tethers and connectors
        dir_, base = os.path.split(__file__)
        catalog = pyto.analysis.Catalog()
        catalog._db = {
            'category' : {'77_4' : 'rim_wt', '78_3' : 'rim_wt', 
                          '75_4' : 'rim_altered'},
            'tether_files' : {'77_4': 'segmentations/conn_77-4_new_AZ.pkl',
                              '78_3': 'segmentations/conn_78-3_new_AZ.pkl',
                              '75_4' : 'segmentations/conn_75-4_new_AZ.pkl'},
            'connector_files' : {'77_4': 'segmentations/conn_77-4_new_rest.pkl',
                              '78_3': 'segmentations/conn_78-3_new_rest.pkl',
                              '75_4' : 'segmentations/conn_75-4_new_rest.pkl'},
            'layer_files' : {'77_4': 'segmentations/layers_77-4.dat',
                              '78_3': 'segmentations/layers_78-3.dat',
                              '75_4' : 'segmentations/layers_75-4.dat'},
            'pixel_size' : {'77_4' : 2.644, '78_3' : 2.644, '75_4' : 2.644},
            'operator' : {'77_4' : 'emerson', '78_3' : 'lake', 
                          '75_4' : 'palmer'}
            }
        for ident, name in list(catalog._db['tether_files'].items()):
               catalog._db['tether_files'][ident] = os.path.join(dir_, name)
        for ident, name in list(catalog._db['connector_files'].items()):
               catalog._db['connector_files'][ident] = os.path.join(dir_, name)
        for ident, name in list(catalog._db['layer_files'].items()):
               catalog._db['layer_files'][ident] = os.path.join(dir_, name)
        catalog.makeGroups()
        self.catalog = catalog

        # read tethers and connectors 
        from pyto.analysis.connections import Connections
        self.tether = Connections.read(files=catalog.tether_files, 
                                       mode='connectors', catalog=catalog)
        self.connector = Connections.read(
            files=catalog.connector_files, mode='connectors', catalog=catalog,
            order=self.tether)

        # read layers
        from pyto.analysis.layers import Layers
        self.layer = Layers.read(
            files=catalog.layer_files, catalog=catalog, order=self.tether)

        # read vesicles
        self.sv = Vesicles.read(files=self.sv_files, catalog=self.catalog,
                                membrane=self.mem_files, lumen=self.mem_files)
Beispiel #7
0
    def setUp(self):
        """
        """

        # local path
        dir_, base = os.path.split(__file__)

        # set catalog
        catalog = pyto.analysis.Catalog()
        catalog._db = {
            'category': {
                '77_4': 'rim_wt',
                '78_3': 'rim_wt',
                '75_4': 'rim_altered'
            },
            'tether_files': {
                '77_4': 'segmentations/conn_77-4_new_AZ.pkl',
                '78_3': 'segmentations/conn_78-3_new_AZ.pkl',
                '75_4': 'segmentations/conn_75-4_new_AZ.pkl'
            },
            'sv_files': {
                '77_4': 'segmentations/sv_77-4_vesicles.pkl',
                '78_3': 'segmentations/sv_78-3_vesicles.pkl',
                '75_4': 'segmentations/sv_75-4_vesicles.pkl'
            },
            'pixel_size': {
                '77_4': 2.644,
                '78_3': 2.644,
                '75_4': 2.644
            },
            'operator': {
                '77_4': 'emerson',
                '78_3': 'lake',
                '75_4': 'palmer'
            }
        }
        for ident, name in list(catalog._db['tether_files'].items()):
            catalog._db['tether_files'][ident] = os.path.join(dir_, name)
        for ident, name in list(catalog._db['sv_files'].items()):
            catalog._db['sv_files'][ident] = os.path.join(dir_, name)
        catalog.makeGroups()
        self.catalog = catalog

        # read tethers and sv
        self.tether = Connections.read(files=catalog.tether_files,
                                       mode='connectors',
                                       catalog=catalog)
        from pyto.analysis.vesicles import Vesicles
        self.sv = Vesicles.read(files=catalog.sv_files, catalog=catalog)

        # set segmentation files and adjust paths
        tether_files = {
            'rim_wt': {
                '77_4': 'segmentations/conn_77-4_AZ_all.pkl',
                '78_3': 'segmentations/conn_78-3_AZ_all.pkl'
            },
            'rim_altered': {
                '75_4': 'segmentations/conn_75-4_AZ_all.pkl'
            }
        }
        for categ in tether_files:
            for ident, name in list(tether_files[categ].items()):
                tether_files[categ][ident] = os.path.join(dir_, name)
        self.tether_files = tether_files

        # set pixel size
        self.pixel_size = {
            'rim_wt': {
                '77_4': 2.644,
                '78_3': 2.644
            },
            'rim_altered': {
                '75_4': 2.644
            }
        }