Пример #1
0
 def test_get_connectors(self):
     cn = pymaid.get_connectors(config_test.test_skids,
                                remote_instance=self.rm)
     self.assertIsInstance(cn, pd.DataFrame)
     self.assertIsInstance(
         pymaid.get_connector_details(cn.connector_id.tolist(),
                                      remote_instance=self.rm),
         pd.DataFrame)
Пример #2
0
 def get_pre_synaptic_positions(self, skid):
     pymaid.clear_cache()
     connectors = pymaid.get_connectors(skid,
                                        relation_type='presynaptic_to')
     x = connectors["x"].to_numpy()
     y = connectors["y"].to_numpy()
     z = connectors["z"].to_numpy()
     pos_array, ids = np.vstack(
         [z, y, x]).T, connectors["connector_id"].to_numpy()
     return [tuple(np.round(p).astype(np.uint64)) for p in pos_array], ids
Пример #3
0
def sum_Conns_on_Branch(path,neuron,confidence = 5):
    """ Input:  list of leafnode ids
                CatmaidNeuron object
                Confidence value
        Output: 
    """

    conn_dets = pymaid.get_connectors(neuron)

    neuron_conns = neuron.connectors[neuron.connectors.connector_id.isin(conn_dets.connector_id[conn_dets.confidence == confidence])]
    
    return sum(neuron_conns.node_id.isin(path))
Пример #4
0
def find_unlinked_connectors(remote_instance=None, verbose=True):
    if remote_instance in [None, 'source']:
        remote_instance = source_project
        if verbose:
            print('Searching for unlinked connectors in source project.')
    elif remote_instance == 'target':
        remote_instance = target_project
        if verbose:
            print('Searching for unlinked connectors in target project.')

    all_connectors = pymaid.get_connectors(None,
                                           remote_instance=remote_instance)
    # A connector's type being null seems to indicate it is unlinked.
    # I'm not confident this will always be true in future versions of pymaid
    # and catmaid. A more robust but slower approach would actually go check
    # there are no links.
    unlinked_connectors = all_connectors.connector_id[
        all_connectors.type.isnull()]
    return unlinked_connectors.to_list()
Пример #5
0
def get_connectors(nl):
    connectors = pymaid.get_connectors(nl)
    connectors.set_index("connector_id", inplace=True)
    connectors.drop(
        [
            "confidence",
            "creation_time",
            "edition_time",
            "tags",
            "creator",
            "editor",
            "type",
        ],
        inplace=True,
        axis=1,
    )
    details = pymaid.get_connector_details(connectors.index.values)
    details.set_index("connector_id", inplace=True)
    connectors = pd.concat((connectors, details), ignore_index=False, axis=1)
    connectors.reset_index(inplace=True)
    return connectors
Пример #6
0
def find_overlapping_connectors(remote_instance=None,
                                verbose=True,
                                tolerance=1):
    """Find pairs of connectors that are at exactly the same location"""
    if remote_instance in [None, 'source']:
        remote_instance = source_project
        if verbose:
            print('Searching for overlapping connectors in source project.')
    elif remote_instance == 'target':
        remote_instance = target_project
        if verbose:
            print('Searching for overlapping connectors in target project.')
    all_connectors = pymaid.get_connectors(None,
                                           remote_instance=remote_instance)
    all_connectors.sort_values(by=['x', 'y', 'z'],
                               inplace=True,
                               ignore_index=True)
    n_connectors = len(all_connectors)
    hits = []
    #d = lambda pt1, pt2: ((pt2 - pt1)**2).sum()**0.5  # euclidian distance
    #d = lambda pt1, pt2: np.abs(pt2 - pt1).max()  # Chebyshev distance
    d = lambda row1, row2: np.abs(all_connectors.loc[
        row2, ['x', 'y', 'z']].values - all_connectors.loc[
            row1, ['x', 'y', 'z']].values).max()  # Chebyshev distance
    for row1 in tqdm(range(n_connectors)):
        row2 = row1 + 1
        while (row2 < n_connectors
               and np.abs(all_connectors.at[row2, 'x'] -
                          all_connectors.at[row1, 'x']) <= tolerance):
            if d(row2, row1) <= tolerance:
                hits.append([
                    all_connectors.at[row1, 'connector_id'],
                    all_connectors.at[row2, 'connector_id']
                ])
            row2 += 1
    print(f'Found {len(hits)} pairs of overlapping connectors')
    return hits
Пример #7
0
# %% [markdown]
# #
mg = mg.sort_values("Pair ID")
nl = pymaid.get_neurons(mg.meta[mg.meta["Merge Class"] == "sens-ORN"].index.values)
fig, ax = nl.plot2d()


# %%
nl = pymaid.get_neurons(mg.meta.index.values)
print(len(nl))
# %% [markdown]
# #
import pandas as pd
import seaborn as sns

connectors = pymaid.get_connectors(nl)
connectors.set_index("connector_id", inplace=True)
connectors.drop(
    [
        "confidence",
        "creation_time",
        "edition_time",
        "tags",
        "creator",
        "editor",
        "type",
    ],
    inplace=True,
    axis=1,
)
details = pymaid.get_connector_details(connectors.index.values)