LineageTree 1.5.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

LineageTree/utils.py

@@ -2,7 +2,6 @@ import csv
 import random
 import warnings
 
-import networkx as nx
 
 from LineageTree import lineageTree
 
@@ -14,133 +13,14 @@ except ImportError:
     )
 
 
-def hierarchy_pos(
-    G,
-    a,
-    root=None,
-    width=2000.0,
-    vert_gap=0.5,
-    vert_loc=0,
-    xcenter=0,
-):
-    """
-    From Joel's answer at https://stackoverflow.com/a/29597209/2966723.
-    Licensed under Creative Commons Attribution-Share Alike
-
-    If the graph is a tree this will return the positions to plot this in a
-    hierarchical layout.
-
-
-    #The graph represents the lifetimes of cells, so there is no new point for each timepoint.
-    #Each lifetime is represented by length.
-
-    G: the graph (must be a tree)
-
-    root: the root node of current branch
-    - if the tree is directed and this is not given,
-
-    root: the root node of current branch
-    - if the tree is directed and this is not given,
-      the root will be found and used
-    - if the tree is directed and this is given, then
-    - if the tree is directed and this is given, then
-      the positions will be just for the descendants of this node.
-    - if the tree is undirected and not given,
-      then a random choice will be used.
-
-
-    width: horizontal space allocated for this branch - avoids overlap with other branches
-
-
-    vert_gap: gap between levels of hierarchy
-
-
-    vert_loc: vertical location of root
-
-
-    xcenter: horizontal location of root
-    """
-    if not nx.is_tree(G):
-        raise TypeError(
-            "cannot use hierarchy_pos on a graph that is not a tree"
-        )
-
-    if root is None:
-        if isinstance(G, nx.DiGraph):
-            root = next(
-                iter(nx.topological_sort(G))
-            )  # allows back compatibility with nx version 1.11
-        else:
-            root = random.choice(list(G.nodes))
-
-    def lengths(cell):
-        succ = a.successor.get(cell, [])
-        if len(succ) < 2:
-            if list(G.neighbors(cell)) == []:
-                return 0
-            if list(G.neighbors(cell))[0] in a.get_cycle(cell):
-                return (
-                    len(a.get_successors(cell))
-                    - len(a.get_successors(list(G.neighbors(cell))[0]))
-                    - 1
-                )
-            return len(a.get_successors(cell))
-        else:
-            return 0.7
-
-    def _hierarchy_pos(
-        G,
-        root,
-        width=2.0,
-        a=a,
-        vert_gap=0.5,
-        vert_loc=0,
-        xcenter=0.5,
-        pos=None,
-        parent=None,
-    ):
-        """
-        see hierarchy_pos docstring for most arguments
-
-        pos: a dict saying where all nodes go if they have been assigned
-        parent: parent of this branch. - only affects it if non-directed
-
-        """
-        if pos is None:
-            pos = {root: (xcenter, vert_loc)}
-        elif not a.predecessor.get(a.get_predecessors(root)[0]):
-            vert_loc = vert_loc - len(a.get_predecessors(root))
-            pos[root] = (xcenter, vert_loc)
-        else:
-            pos[root] = (xcenter, vert_loc)
-        children = list(G.neighbors(root))
-
-        if not isinstance(G, nx.DiGraph) and parent is not None:
-            children.remove(parent)
-        if len(children) != 0:
-            dx = width / len(children)
-            nextx = xcenter - width / 2 - dx / 2
-            for child in children:
-                nextx += dx
-                pos = _hierarchy_pos(
-                    G,
-                    child,
-                    width=dx,
-                    vert_gap=lengths(child),
-                    vert_loc=vert_loc - vert_gap,
-                    xcenter=nextx,
-                    pos=pos,
-                    a=a,
-                    parent=root,
-                )
-        return pos
-
-    return _hierarchy_pos(G, root, width, a, vert_gap, vert_loc, xcenter)
-
-
 def to_motile(
     lT: lineageTree, crop: int = None, max_dist=200, max_skip_frames=1
 ):
+    try:
+        import networkx as nx
+    except:
+        raise Warning("Please install networkx")
+
     fmt = nx.DiGraph()
     if not crop:
         crop = lT.t_e
@@ -192,20 +72,87 @@ def write_csv_from_lT_to_lineaja(
             )
 
 
-def postions_of_nx(lt, graphs):
-    """Calculates the positions of the Lineagetree to be plotted.
+def create_links_and_cycles(lT: lineageTree, roots=None):
+    """Generates a dictionary containing the links and the lengths of each branch.
+    Similar to simple tree, mainly used for tree manip app.
+
+    Args:
+        roots (Union[list,set,int]): The roots from which the tree will be generated.
+
+    Returns:
+        dict: A dictionary with keys "links" and "times" which contains the connections all cells and their branch
+        length.
+    """
+    if roots is None:
+        to_do = set(lT.roots)
+    elif isinstance(roots, list):
+        to_do = set(roots)
+    else:
+        to_do = {int(roots)}
+    times = {}
+    links = {}
+    while to_do:
+        curr = to_do.pop()
+        cyc = lT.get_successors(curr)
+        last = cyc[-1]
+        times[curr] = len(cyc)
+        if last != curr:
+            links[curr] = [cyc[-1]]
+        else:
+            links[curr] = []
+        succ = lT.successor.get(last)
+        if succ:
+            times[cyc[-1]] = 0
+            to_do.update(succ)
+            links[last] = succ
+    return {"links": links, "times": times, "root": roots}
+
+
+def hierarchical_pos(
+    lnks_tms: dict, root, width=1000, vert_gap=2, xcenter=0, ycenter=0
+):
+    """Calculates the position of each node on te tree graph.
 
     Args:
-        graphs (nx.Digraph): Graphs produced by export_nx_simple_graph
+        lnks_tms (dict): a dictionary created by create_links_and_cycles.
+        root (_type_): The id of the node, usually it exists inside lnks_tms dictionary, however you may use your own root.
+        width (int, optional): Max width, will not change the graph but the interacting with the graph takes this distance into account. Defaults to 1000.
+        vert_gap (int, optional): How far downwards each timepoint will go. Defaults to 2.
+        xcenter (int, optional): Where the root will be placed on the x axis. Defaults to 0.
+        ycenter (int, optional): Where the root will be placed on the y axis. Defaults to 0.
 
     Returns:
-        pos (list): The positions of the nodes of the graphs for plotting
+        _type_: _description_
     """
-    pos = {}
-    for i in range(len(graphs)):
-        pos[i] = hierarchy_pos(
-            graphs[i],
-            lt,
-            root=[n for n, d in graphs[i].in_degree() if d == 0][0],
-        )
-    return pos
+    to_do = [root]
+    if root not in lnks_tms["times"]:
+        return None
+    pos_node = {root: [xcenter, ycenter]}
+    prev_width = {root: width / 2}
+    while to_do:
+        curr = to_do.pop()
+        succ = lnks_tms["links"].get(curr, [])
+        if len(succ) == 0:
+            continue
+        elif len(succ) == 1:
+            pos_node[succ[0]] = [
+                pos_node[curr][0],
+                pos_node[curr][1] - lnks_tms["times"].get(curr, 0),
+            ]
+            to_do.extend(succ)
+            prev_width[succ[0]] = prev_width[curr]
+        elif len(succ) == 2:
+            pos_node[succ[0]] = [
+                pos_node[curr][0] - prev_width[curr] / 2,
+                pos_node[curr][1] - vert_gap,
+            ]
+            pos_node[succ[1]] = [
+                pos_node[curr][0] + prev_width[curr] / 2,
+                pos_node[curr][1] - vert_gap,
+            ]
+            to_do.extend(succ)
+            prev_width[succ[0]], prev_width[succ[1]] = (
+                prev_width[curr] / 2,
+                prev_width[curr] / 2,
+            )
+    return pos_node

{LineageTree-1.5.1.dist-info → LineageTree-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LineageTree
-Version: 1.5.1
+Version: 1.6.0
 Summary: Lineage tree structure
 Home-page: https://github.com/leoguignard/LineageTree
 Author: Léo Guignard

LineageTree-1.6.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+LineageTree/__init__.py,sha256=P4WGjjokRD5ugh27WC263Pwll1PmMdLgHyshMVLNvIc,155
+LineageTree/lineageTree.py,sha256=srhZ8UI4iBsKmSEIVhn0OpKuTSyrE6npEMxjj4v666M,102657
+LineageTree/lineageTreeManager.py,sha256=tQMNmxAvUEd4fNLJViB-9DGItpgCRnSF-bS2_IdebMo,5566
+LineageTree/loaders.py,sha256=hKd-69d_csjcsV0zabSTEOyy0NhprFqvnRAI18tYa9w,23718
+LineageTree/tree_styles.py,sha256=IUEq8RHfwXTv3WXylpLVa5XoThaWt1i1cRsgZGXdd50,10634
+LineageTree/utils.py,sha256=kC90fi8TFm8Pz7oom_bDsq7HPPKnFdJ6wI-x36fLvHE,4962
+LineageTree-1.6.0.dist-info/LICENSE,sha256=IKncNCNpq93Kq7Ywg1V4I9Bu_99VMK-mX1EJyjTKLyc,1068
+LineageTree-1.6.0.dist-info/METADATA,sha256=XlCCU5B8WqbKT0EiGqgf-kvVFH5D2aSWQzygUCc3YT4,4195
+LineageTree-1.6.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+LineageTree-1.6.0.dist-info/top_level.txt,sha256=CCqPCTX76zPTEUagUgTWbLaZun8752n59iOOwfUlvxs,12
+LineageTree-1.6.0.dist-info/RECORD,,

LineageTree-1.5.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-LineageTree/__init__.py,sha256=9nFMRvaUfOOjmlQa_wULLdgtNx8qKnajSRWBrRiiYJo,155
-LineageTree/lineageTree.py,sha256=DrJRj6uZt9P2mdZGPTTIcX8RJM7zipgfuX_aoLUFA5A,127181
-LineageTree/lineageTreeManager.py,sha256=tQMNmxAvUEd4fNLJViB-9DGItpgCRnSF-bS2_IdebMo,5566
-LineageTree/tree_styles.py,sha256=cDrGZaHz-1d_bp1hAhvAtBmVcSbNeTcY5YHPyaJ4g3w,10690
-LineageTree/utils.py,sha256=cWJVSETN2npEoP1Ud86e17aXT-0dwf2gWsf5DMpxV9k,5993
-LineageTree-1.5.1.dist-info/LICENSE,sha256=IKncNCNpq93Kq7Ywg1V4I9Bu_99VMK-mX1EJyjTKLyc,1068
-LineageTree-1.5.1.dist-info/METADATA,sha256=gY9oz2iSQdbfjZ1RKBpnBj16383bAa3kSUXwpTHvFvE,4195
-LineageTree-1.5.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-LineageTree-1.5.1.dist-info/top_level.txt,sha256=CCqPCTX76zPTEUagUgTWbLaZun8752n59iOOwfUlvxs,12
-LineageTree-1.5.1.dist-info/RECORD,,