LineageTree 1.4.3__py3-none-any.whl → 1.5.0__py3-none-any.whl

LineageTree/lineageTreeManager.py

@@ -0,0 +1,170 @@
+import os
+import pickle as pkl
+from functools import partial
+
+try:
+    from edist import uted
+except ImportError:
+    warnings.warn(
+        "No edist installed therefore you will not be able to compute the tree edit distance."
+    )
+from LineageTree import lineageTree
+
+from .tree_styles import tree_style
+
+
+class lineageTreeManager:
+    def __init__(self):
+        self.lineagetrees = {}
+        # self.classification = {"Wt": {}, "Ptb": {}}
+        self.lineageTree_counter = 0
+        self.registered = {}
+
+    def __next__(self):
+        self.lineageTree_counter += 1
+        return self.lineageTree_counter - 1
+
+    def add(
+        self, other_tree: lineageTree, name: str = "", classification: str = ""
+    ):
+        """Function that adds a new lineagetree object to the class.
+        Can be added either by .add or by using the + operator. If a name is
+        specified it will also add it as this specific name, otherwise it will
+        use the already existing name of the lineagetree.
+
+        Args:
+            other_tree (lineageTree): Thelineagetree to be added.
+            name (str, optional): Then name of. Defaults to "".
+
+        """
+        if isinstance(other_tree, lineageTree):
+            for tree in self.lineagetrees.values():
+                if tree == other_tree:
+                    return False
+            if name:
+                self.lineagetrees[name] = other_tree
+            else:
+                if hasattr(other_tree, "name"):
+                    name = other_tree.name
+                    self.lineagetrees[name] = other_tree
+                else:
+                    name = f"Lineagetree {next(self)}"
+                    self.lineagetrees[name] = other_tree
+                    self.lineagetrees[name].name = name
+                # try:
+                #     name = other_tree.name
+                #     self.lineagetrees[name] = other_tree
+                # except:
+                #     self.lineagetrees[
+                #         f"Lineagetree {next(self)}"
+                #     ] = other_tree
+        # if classification in ("Wt", "Ptb"):
+        #     self.classification[type] = {name: other_tree}
+
+    def __add__(self, other):
+        self.add(other)
+
+    # def classify_existing(self, key, classification: str):
+    #     if classification in ("Wt", "Ptb"):
+    #         self.classification[classification] = {key: self.lineagetrees[key]}
+    #     else:
+    #         return False
+
+    def write(self, fname: str):
+        """Saves the manager
+
+        Args:
+            fname (str): The path and name of the file that is to be saved.
+        """
+        if os.path.splitext(fname)[-1] != ".ltM":
+            fname = os.path.extsep.join((fname, "ltM"))
+        with open(fname, "bw") as f:
+            pkl.dump(self, f)
+            f.close()
+
+    def remove_embryo(self, key):
+        """Removes the embryo from the manager.
+
+        Args:
+            key (str): The name of the lineagetree to be removed
+
+        Raises:
+            Exception: If there is not such a lineagetree
+        """
+        self.lineagetrees.pop(key, None)
+
+    @classmethod
+    def load(cls, fname: str):
+        """
+        Loading a lineage tree Manager from a ".ltm" file.
+
+        Args:
+            fname (str): path to and name of the file to read
+
+        Returns:
+            (lineageTree): loaded file
+        """
+        with open(fname, "br") as f:
+            ltm = pkl.load(f)
+            f.close()
+        return ltm
+
+    def cross_lineage_edit_distance(
+        self,
+        n1: int,
+        embryo_1,
+        end_time1: int,
+        n2: int,
+        embryo_2,
+        end_time2: int,
+        style="fragmented",
+        node_lengths: tuple = (1, 5, 7),
+        registration=None,
+    ):
+        """Compute the unordered tree edit distance from Zhang 1996 between the trees spawned
+        by two nodes `n1` from lineagetree1 and `n2` lineagetree2. The topology of the trees
+        are compared and the matching cost is given by the function delta (see edist doc for
+        more information).The distance is normed by the function norm that takes the two list
+        of nodes spawned by the trees `n1` and `n2`.
+
+        Args:
+            n1 (int): Node of the first Lineagetree
+            embryo_1 (str): The key/name of the first Lineagetree
+            end_time1 (int): End time of first Lineagetree
+            n2 (int): The key/name of the first Lineagetree
+            embryo_2 (str): Node of the second Lineagetree
+            end_time2 (int): End time of second lineagetree
+            registration (_type_, optional): _description_. Defaults to None.
+        """
+
+        tree = tree_style[style].value
+        tree1 = tree(
+            lT=self.lineagetrees[embryo_1],
+            node_length=node_lengths,
+            end_time=end_time1,
+            root=n1,
+        )
+        tree2 = tree(
+            lT=self.lineagetrees[embryo_2],
+            node_length=node_lengths,
+            end_time=end_time2,
+            root=n2,
+        )
+        delta = tree1.delta
+        _, times1 = tree1.tree
+        _, times2 = tree2.tree
+        nodes1, adj1, corres1 = tree1.edist
+        nodes2, adj2, corres2 = tree2.edist
+        if len(nodes1) == len(nodes2) == 0:
+            return 0
+
+        delta_tmp = partial(
+            delta,
+            corres1=corres1,
+            times1=times1,
+            corres2=corres2,
+            times2=times2,
+        )
+        return uted.uted(nodes1, adj1, nodes2, adj2, delta=delta_tmp) / max(
+            tree1.get_norm(), tree2.get_norm()
+        )

LineageTree/tree_styles.py

@@ -0,0 +1,305 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+
+import numpy as np
+
+from LineageTree import lineageTree
+
+
+class abstract_trees(ABC):
+    def __init__(
+        self, lT: lineageTree, root: int, node_length: int, end_time: int
+    ):
+        self.lT = lT
+        self.root = root
+        self.node_length = node_length
+        self.end_time = end_time
+        self.tree = self.get_tree()
+        self.edist = self._edist_format(self.tree[0])
+
+    @abstractmethod
+    def get_tree(self):
+        """
+        Get a tree version of the tree spawned by the node `r`
+
+        Args:
+            r (int): root of the tree to spawn
+            end_time (int): the last time point to consider
+            time_resolution (float): the time between two consecutive time points
+
+        Returns:
+            (dict) {m (int): [d1 (int), d2 (int)]}: an adjacency dictionnary
+                where the ids are the ids of the cells in the original tree
+                at their first time point (except for the cell `r` if it was
+                not the first time point).
+            (dict) {m (int): duration (float)}: life time duration of the cell `m`
+        """
+
+    @abstractmethod
+    def delta(self, x, y, corres1, corres2, times1, times2):
+        """The distance of two nodes inside a tree. Behaves like a staticmethod.
+            The corres1/2 and time1/2 should always be provided and will be handled accordingly by the specific
+            delta of each tree style.
+
+        Args:
+            x (int): The first node to compare, takes the names provided by the edist.
+            y (int): The second node to compare, takes the names provided by the edist
+            corres1 (dict): Correspondance between node1 and its name in the real tree.
+            corres2 (dict): Correspondance between node2 and its name in the real tree.
+            times1 (dict): The dictionary of the branch lengths of the tree that n1 is spawned from.
+            times2 (dict): The dictionary of the branch lengths of the tree that n2 is spawned from.
+
+        Returns:
+            (int|float): The diatance between these 2 nodes.
+        """
+        if x is None and y is None:
+            return 0
+        if x is None:
+            return times2[corres2[y]]
+        if y is None:
+            return times1[corres1[x]]
+        len_x = times1[corres1[x]]
+        len_y = times2[corres2[y]]
+        return np.abs(len_x - len_y)
+
+    @abstractmethod
+    def get_norm(self):
+        """
+        Returns the valid value for normalizing the edit distance.
+        Returns:
+            (int|float): The number of nodes of each tree according to each style.
+        """
+
+    def _edist_format(self, adj_dict: dict):
+        """Formating the custom tree style to the format needed by edist.
+        SHOULD NOT BE CHANGED.
+
+        Args:
+            adj_dict (dict): _description_
+
+        Returns:
+            _type_: _description_
+        """
+        inv_adj = {vi: k for k, v in adj_dict.items() for vi in v}
+        roots = set(adj_dict).difference(inv_adj)
+        nid2list = {}
+        list2nid = {}
+        nodes = []
+        adj_list = []
+        curr_id = 0
+        for r in roots:
+            to_do = [r]
+            while to_do:
+                curr = to_do.pop(0)
+                nid2list[curr] = curr_id
+                list2nid[curr_id] = curr
+                nodes.append(curr_id)
+                to_do = adj_dict.get(curr, []) + to_do
+                curr_id += 1
+            adj_list = [
+                [nid2list[d] for d in adj_dict.get(list2nid[_id], [])]
+                for _id in nodes
+            ]
+        return nodes, adj_list, list2nid
+
+
+class mini_tree(abstract_trees):
+    """Each branch is converted to a node of length 1, it is useful for comparing synchronous developing cells, extremely fast.
+    Mainly used for testing.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def get_tree(self):
+        if self.end_time is None:
+            self.end_time = self.lT.t_e
+        out_dict = {}
+        self.times = {}
+        to_do = [self.root]
+        while to_do:
+            current = to_do.pop()
+            cycle = np.array(self.lT.get_successors(current))
+            cycle_times = np.array([self.lT.time[c] for c in cycle])
+            cycle = cycle[cycle_times <= self.end_time]
+            if cycle.size:
+                _next = self.lT[cycle[-1]]
+                if len(_next) > 1:
+                    out_dict[current] = _next
+                    to_do.extend(_next)
+                else:
+                    out_dict[current] = []
+        self.length = len(out_dict)
+        return out_dict, None
+
+    def get_norm(self):
+        return len(
+            self.lT.get_all_branches_of_node(self.root, end_time=self.end_time)
+        )
+
+    def _edist_format(self, adj_dict: dict):
+        return super()._edist_format(adj_dict)
+
+    def delta(self, x, y, corres1, corres2, times1, times2):
+        if x is None and y is None:
+            return 0
+        if x is None:
+            return 1
+        if y is None:
+            return 1
+        return 0
+
+
+class simple_tree(abstract_trees):
+    """Each branch is converted to one node with length the same as the life cycle of the cell.
+    This method is fast, but imprecise, especialy for small trees (recommended height of the trees should be 100 at least).
+    Use with CAUTION.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def get_tree(self):
+        if self.end_time is None:
+            self.end_time = self.lT.t_e
+        out_dict = {}
+        self.times = {}
+        to_do = [self.root]
+        while to_do:
+            current = to_do.pop()
+            cycle = np.array(self.lT.get_successors(current))
+            cycle_times = np.array([self.lT.time[c] for c in cycle])
+            cycle = cycle[cycle_times <= self.end_time]
+            if cycle.size:
+                _next = self.lT[cycle[-1]]
+                if 1 < len(_next) and self.lT.time[cycle[-1]] < self.end_time:
+                    out_dict[current] = _next
+                    to_do.extend(_next)
+                else:
+                    out_dict[current] = []
+            self.times[current] = len(
+                cycle
+            )  # * time_resolution will be fixed when working on registered trees.
+        return out_dict, self.times
+
+    def delta(self, x, y, corres1, corres2, times1, times2):
+        return super().delta(x, y, corres1, corres2, times1, times2)
+
+    def get_norm(self):
+        return len(
+            self.lT.get_sub_tree(self.root, end_time=self.end_time)
+        )
+
+
+class fragmented_tree(abstract_trees):
+    """Similar idea to simple tree, but tries to correct its flaws.
+        Instead of having branches with length == life cycle of cell,nodes of specific length are added on the
+        edges of the branch, providing both accuratr results and speed.
+        It's the recommended method for calculating edit distances on developing embryos.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def get_tree(self):
+        if self.end_time is None:
+            self.end_time = self.lT.t_e
+        self.out_dict = {}
+        self.times = {}
+        to_do = [self.root]
+        if not isinstance(self.node_length, list):
+            self.node_length = list(self.node_length)
+        while to_do:
+            current = to_do.pop()
+            cycle = np.array(
+                self.lT.get_successors(current, end_time=self.end_time)
+            )
+            if cycle.size > 0:
+                cumul_sum_of_nodes = np.cumsum(self.node_length) * 2 + 1
+                max_number_fragments = len(
+                    cumul_sum_of_nodes[cumul_sum_of_nodes < len(cycle)]
+                )
+                if max_number_fragments > 0:
+                    current_node_lengths = self.node_length[
+                        :max_number_fragments
+                    ].copy()
+                    length_middle_node = (
+                        len(cycle) - sum(current_node_lengths) * 2
+                    )
+                    times_tmp = (
+                        current_node_lengths
+                        + [length_middle_node]
+                        + current_node_lengths[::-1]
+                    )
+                    pos_all_nodes = np.concatenate(
+                        [[0], np.cumsum(times_tmp[:-1])]
+                    )
+                    track = cycle[pos_all_nodes]
+                    self.out_dict.update(
+                        {k: [v] for k, v in zip(track[:-1], track[1:])}
+                    )
+                    self.times.update(zip(track, times_tmp))
+                else:
+                    for i, cell in enumerate(cycle[:-1]):
+                        self.out_dict[cell] = [cycle[i + 1]]
+                        self.times[cell] = 1
+                current = cycle[-1]
+                _next = self.lT[current]
+                self.times[current] = 1
+                if _next and self.lT.time[_next[0]] <= self.end_time:
+                    to_do.extend(_next)
+                    self.out_dict[current] = _next
+                else:
+                    self.out_dict[current] = []
+
+        return self.out_dict, self.times
+
+    def get_norm(self):
+        return len(
+            self.lT.get_sub_tree(self.root, end_time=self.end_time)
+        )
+
+    def delta(self, x, y, corres1, corres2, times1, times2):
+        return super().delta(x, y, corres1, corres2, times1, times2)
+
+
+class full_tree(abstract_trees):
+    """No approximations the whole tree is used here. Perfect accuracy, but heavy on ram and speed.
+    Not recommended to use on napari.
+
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def get_tree(self) -> dict:
+        self.out_dict = {}
+        self.times = {}
+        to_do = [self.root]
+        while to_do:
+            current = to_do.pop()
+            _next = self.lT.successor.get(current, [])
+            if _next and self.lT.time[_next[0]] <= self.end_time:
+                self.out_dict[current] = _next
+                to_do.extend(_next)
+            else:
+                self.out_dict[current] = []
+            self.times[current] = 1
+        return self.out_dict, self.times
+
+    def get_norm(self):
+        return len(self.lT.get_sub_tree(self.root, end_time=self.end_time))
+
+    def delta(self, x, y, corres1, corres2, times1, times2):
+        return super().delta(x, y, corres1, corres2, times1, times2)
+
+
+class tree_style(Enum):
+    mini = mini_tree
+    simple = simple_tree
+    fragmented = fragmented_tree
+    full = full_tree
+
+    @classmethod
+    def list_names(self):
+        return [style.name for style in self]

LineageTree/utils.py

@@ -0,0 +1,211 @@
+import csv
+import random
+import warnings
+
+import networkx as nx
+
+from LineageTree import lineageTree
+
+try:
+    import motile
+except ImportError:
+    warnings.warn(
+        "No motile installed therefore you will not be able to produce links with motile."
+    )
+
+
+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
+):
+    fmt = nx.DiGraph()
+    if not crop:
+        crop = lT.t_e
+    # time_nodes = [
+    for time in range(crop):
+        #     time_nodes += lT.time_nodes[time]
+        # print(time_nodes)
+        for time_node in lT.time_nodes[time]:
+            fmt.add_node(
+                time_node,
+                t=lT.time[time_node],
+                pos=lT.pos[time_node],
+                score=1,
+            )
+            # for suc in lT.successor:
+            #     fmt.add_edge(time_node, suc, **{"score":0})
+
+    motile.add_cand_edges(fmt, max_dist, max_skip_frames=max_skip_frames)
+
+    return fmt
+
+
+def write_csv_from_lT_to_lineaja(
+    lT, path_to, start: int = 0, finish: int = 300
+):
+    csv_dict = {}
+    for time in range(start, finish):
+        for node in lT.time_nodes[time]:
+            csv_dict[node] = {"pos": lT.pos[node], "t": time}
+    with open(path_to, "w", newline="\n") as file:
+        fieldnames = [
+            "time",
+            "positions_x",
+            "positions_y",
+            "positions_z",
+            "id",
+        ]
+        writer = csv.DictWriter(file, fieldnames=fieldnames)
+        writer.writeheader()
+        for node in csv_dict:
+            writer.writerow(
+                {
+                    "time": csv_dict[node]["t"],
+                    "positions_z": csv_dict[node]["pos"][0],
+                    "positions_y": csv_dict[node]["pos"][1],
+                    "positions_x": csv_dict[node]["pos"][2],
+                    "id": node,
+                }
+            )
+
+
+def postions_of_nx(lt, graphs):
+    """Calculates the positions of the Lineagetree to be plotted.
+
+    Args:
+        graphs (nx.Digraph): Graphs produced by export_nx_simple_graph
+
+    Returns:
+        pos (list): The positions of the nodes of the graphs for plotting
+    """
+    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