LineageTree 1.7.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

LineageTree/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.7.0"
+__version__ = "1.8.0"
 from .lineageTree import lineageTree
 from .lineageTreeManager import lineageTreeManager
 

LineageTree/lineageTree.py

@@ -70,7 +70,12 @@ class lineageTree(lineageTreeLoaders):
             sub = set(self.get_sub_tree(node))
             specific_leaves = sub.intersection(self.leaves)
             for leaf in specific_leaves:
-                self.add_branch(leaf, self.t_e - self.time[leaf], reverse=True)
+                self.add_branch(
+                    leaf,
+                    (self.t_e - self.time[leaf]),
+                    reverse=True,
+                    move_timepoints=True,
+                )
 
     ###TODO pos can be callable and stay motionless (copy the position of the succ node, use something like optical flow)
     def add_branch(
@@ -88,7 +93,7 @@ class lineageTree(lineageTreeLoaders):
             pred (int): Id of the successor (predecessor if reverse is False)
             length (int): The length of the new branch.
             pos (np.ndarray, optional): The new position of the branch. Defaults to None.
-            move_timepoints (bool): Moves the ti Important only if reverse= True
+            move_timepoints (bool): Moves the time, important only if reverse= True
             reverese (bool): If True will create a branch that goes forwards in time otherwise backwards.
         Returns:
             (int): Id of the first node of the sublineage.
@@ -138,14 +143,12 @@ class lineageTree(lineageTreeLoaders):
                     reverse=False,
                 )
                 pred = _next
+            self.successor[self.get_cycle(pred)[-1]] = []
             self.labels[pred] = "New branch"
         if self.time[pred] == self.t_b:
-            self.roots.add(pred)
             self.labels[pred] = "New branch"
         if original in self.roots and reverse is True:
-            self.roots.add(pred)
             self.labels[pred] = "New branch"
-            self.roots.remove(original)
             self.labels.pop(original, -1)
         self.t_e = max(self.time_nodes)
         return pred
@@ -167,9 +170,7 @@ class lineageTree(lineageTreeLoaders):
             self.predecessor.pop(new_lT)
             label_of_root = self.labels.get(cycle[0], cycle[0])
             self.labels[cycle[0]] = f"L-Split {label_of_root}"
-            new_tr = self.add_branch(
-                new_lT, len(cycle) + 1, move_timepoints=False
-            )
+            new_tr = self.add_branch(new_lT, len(cycle), move_timepoints=False)
             self.roots.add(new_tr)
             self.labels[new_tr] = f"R-Split {label_of_root}"
             return new_tr
@@ -209,7 +210,10 @@ class lineageTree(lineageTreeLoaders):
         self.remove_nodes(new_root1)
         self.successor[new_root2].append(next_root1)
         self.predecessor[next_root1] = [new_root2]
-        new_branch = self.add_branch(new_root2, length)
+        new_branch = self.add_branch(
+            new_root2,
+            length - 1,
+        )
         self.labels[new_branch] = f"Fusion of {new_root1} and {new_root2}"
         return new_branch
 
@@ -321,7 +325,7 @@ class lineageTree(lineageTreeLoaders):
             new_length (int): The new length of the tree.
         """
         if new_length <= 1:
-            warnings.warn("New length should be more than 1")
+            warnings.warn("New length should be more than 1", stacklevel=2)
             return None
         cycle = self.get_cycle(node)
         length = len(cycle)
@@ -383,14 +387,29 @@ class lineageTree(lineageTreeLoaders):
         if time_resolution is not None:
             self._time_resolution = int(time_resolution * 10)
         else:
-            warnings.warn("Time resolution set to default 1", stacklevel=2)
+            warnings.warn("Time resolution set to default 0", stacklevel=2)
             self._time_resolution = 10
 
+    @property
+    def depth(self):
+        if not hasattr(self, "_depth"):
+            self._depth = {}
+            for leaf in self.leaves:
+                self._depth[leaf] = 1
+                while leaf in self.predecessor:
+                    parent = self.predecessor[leaf][0]
+                    current_depth = self._depth.get(parent, 0)
+                    self._depth[parent] = max(
+                        self._depth[leaf] + 1, current_depth
+                    )
+                    leaf = parent
+            for root in self.roots - set(self._depth):
+                self._depth[root] = 1
+        return self._depth
+
     @property
     def roots(self):
-        if not hasattr(self, "_roots"):
-            self._roots = set(self.nodes).difference(self.predecessor)
-        return self._roots
+        return set(self.nodes).difference(self.predecessor)
 
     @property
     def edges(self):
@@ -398,7 +417,7 @@ class lineageTree(lineageTreeLoaders):
 
     @property
     def leaves(self):
-        return set(self.predecessor).difference(self.successor)
+        return {p for p, s in self.successor.items() if s == []}
 
     @property
     def labels(self):
@@ -409,10 +428,10 @@ class lineageTree(lineageTreeLoaders):
                 }
             else:
                 self._labels = {
-                    i: "Unlabeled"
-                    for i in self.roots
-                    for l in self.find_leaves(i)
-                    if abs(self.time[l] - self.time[i])
+                    root: "Unlabeled"
+                    for root in self.roots
+                    for leaf in self.find_leaves(root)
+                    if abs(self.time[leaf] - self.time[root])
                     >= abs(self.t_e - self.t_b) / 4
                 }
         return self._labels
@@ -504,7 +523,7 @@ class lineageTree(lineageTreeLoaders):
 
                 f.write("@5\n")
                 for C in self.to_take_time[t]:
-                    f.write("%f\n" % (manual_labels.get(C, default_label)))
+                    f.write(f"{manual_labels.get(C, default_label):f}\n")
                     f.write(f"{0:f}\n")
 
                 f.write("@6\n")
@@ -523,8 +542,7 @@ class lineageTree(lineageTreeLoaders):
                 f.write("@7\n")
                 for C in self.to_take_time[t]:
                     f.write(
-                        "%f\n"
-                        % (np.linalg.norm(points_v[C][0] - points_v[C][-1]))
+                        f"{np.linalg.norm(points_v[C][0] - points_v[C][-1]):f}\n"
                     )
 
                 f.write("@8\n")
@@ -953,10 +971,10 @@ class lineageTree(lineageTreeLoaders):
             if node_properties:
                 for p_name, (p_dict, default) in node_properties.items():
                     if isinstance(list(p_dict.values())[0], str):
-                        f.write('(property 0 string "%s"\n' % p_name)
+                        f.write(f'(property 0 string "{p_name}"\n')
                         f.write(f"\t(default {default} {default})\n")
                     elif isinstance(list(p_dict.values())[0], Number):
-                        f.write('(property 0 double "%s"\n' % p_name)
+                        f.write(f'(property 0 double "{p_name}"\n')
                         f.write('\t(default "0" "0")\n')
                     for n in nodes_to_use:
                         f.write(
@@ -1030,148 +1048,6 @@ class lineageTree(lineageTreeLoaders):
 
             f.close()
 
-    def read_from_binary(self, fname: str):
-        """
-        Reads a binary lineageTree file name.
-        Format description: see self.to_binary
-
-        Args:
-            fname: string, path to the binary file
-            reverse_time: bool, not used
-        """
-        q_size = struct.calcsize("q")
-        H_size = struct.calcsize("H")
-        d_size = struct.calcsize("d")
-
-        with open(fname, "rb") as f:
-            len_tree = struct.unpack("q", f.read(q_size))[0]
-            len_time = struct.unpack("q", f.read(q_size))[0]
-            len_pos = struct.unpack("q", f.read(q_size))[0]
-            number_sequence = list(
-                struct.unpack("q" * len_tree, f.read(q_size * len_tree))
-            )
-            time_sequence = list(
-                struct.unpack("H" * len_time, f.read(H_size * len_time))
-            )
-            pos_sequence = np.array(
-                struct.unpack("d" * len_pos, f.read(d_size * len_pos))
-            )
-
-            f.close()
-
-        successor = {}
-        predecessor = {}
-        time = {}
-        time_nodes = {}
-        time_edges = {}
-        pos = {}
-        is_root = {}
-        nodes = []
-        edges = []
-        waiting_list = []
-        print(number_sequence[0])
-        i = 0
-        done = False
-        if max(number_sequence[::2]) == -1:
-            tmp = number_sequence[1::2]
-            if len(tmp) * 3 == len(pos_sequence) == len(time_sequence) * 3:
-                time = dict(list(zip(tmp, time_sequence)))
-                for c, t in time.items():
-                    time_nodes.setdefault(t, set()).add(c)
-                pos = dict(
-                    list(zip(tmp, np.reshape(pos_sequence, (len_time, 3))))
-                )
-                is_root = {c: True for c in tmp}
-                nodes = tmp
-                done = True
-        while (
-            i < len(number_sequence) and not done
-        ):  # , c in enumerate(number_sequence[:-1]):
-            c = number_sequence[i]
-            if c == -1:
-                if waiting_list != []:
-                    prev_mother = waiting_list.pop()
-                    successor[prev_mother].insert(0, number_sequence[i + 1])
-                    edges.append((prev_mother, number_sequence[i + 1]))
-                    time_edges.setdefault(t, set()).add(
-                        (prev_mother, number_sequence[i + 1])
-                    )
-                    is_root[number_sequence[i + 1]] = False
-                    t = time[prev_mother] + 1
-                else:
-                    t = time_sequence.pop(0)
-                    is_root[number_sequence[i + 1]] = True
-
-            elif c == -2:
-                successor[waiting_list[-1]] = [number_sequence[i + 1]]
-                edges.append((waiting_list[-1], number_sequence[i + 1]))
-                time_edges.setdefault(t, set()).add(
-                    (waiting_list[-1], number_sequence[i + 1])
-                )
-                is_root[number_sequence[i + 1]] = False
-                pos[waiting_list[-1]] = pos_sequence[:3]
-                pos_sequence = pos_sequence[3:]
-                nodes.append(waiting_list[-1])
-                time[waiting_list[-1]] = t
-                time_nodes.setdefault(t, set()).add(waiting_list[-1])
-                t += 1
-
-            elif number_sequence[i + 1] >= 0:
-                successor[c] = [number_sequence[i + 1]]
-                edges.append((c, number_sequence[i + 1]))
-                time_edges.setdefault(t, set()).add(
-                    (c, number_sequence[i + 1])
-                )
-                is_root[number_sequence[i + 1]] = False
-                pos[c] = pos_sequence[:3]
-                pos_sequence = pos_sequence[3:]
-                nodes.append(c)
-                time[c] = t
-                time_nodes.setdefault(t, set()).add(c)
-                t += 1
-
-            elif number_sequence[i + 1] == -2:
-                waiting_list += [c]
-
-            elif number_sequence[i + 1] == -1:
-                pos[c] = pos_sequence[:3]
-                pos_sequence = pos_sequence[3:]
-                nodes.append(c)
-                time[c] = t
-                time_nodes.setdefault(t, set()).add(c)
-                t += 1
-                i += 1
-                if waiting_list != []:
-                    prev_mother = waiting_list.pop()
-                    successor[prev_mother].insert(0, number_sequence[i + 1])
-                    edges.append((prev_mother, number_sequence[i + 1]))
-                    time_edges.setdefault(t, set()).add(
-                        (prev_mother, number_sequence[i + 1])
-                    )
-                    if i + 1 < len(number_sequence):
-                        is_root[number_sequence[i + 1]] = False
-                    t = time[prev_mother] + 1
-                else:
-                    if len(time_sequence) > 0:
-                        t = time_sequence.pop(0)
-                    if i + 1 < len(number_sequence):
-                        is_root[number_sequence[i + 1]] = True
-            i += 1
-
-        predecessor = {vi: [k] for k, v in successor.items() for vi in v}
-
-        self.successor = successor
-        self.predecessor = predecessor
-        self.time = time
-        self.time_nodes = time_nodes
-        self.time_edges = time_edges
-        self.pos = pos
-        self.nodes = set(nodes)
-        self.t_b = min(time_nodes.keys())
-        self.t_e = max(time_nodes.keys())
-        self.is_root = is_root
-        self.max_id = max(self.nodes)
-
     def write(self, fname: str):
         """
         Write a lineage tree on disk as an .lT file.
@@ -1186,7 +1062,7 @@ class lineageTree(lineageTreeLoaders):
             f.close()
 
     @classmethod
-    def load(clf, fname: str, rm_empty_lists=True):
+    def load(clf, fname: str, rm_empty_lists=False):
         """
         Loading a lineage tree from a ".lT" file.
 
@@ -1201,18 +1077,6 @@ class lineageTree(lineageTreeLoaders):
             f.close()
         if not hasattr(lT, "time_resolution"):
             lT.time_resolution = None
-        if rm_empty_lists:
-            if [] in lT.successor.values():
-                for node, succ in lT.successor.items():
-                    if succ == []:
-                        lT.successor.pop(node)
-            if [] in lT.predecessor.values():
-                for node, succ in lT.predecessor.items():
-                    if succ == []:
-                        lT.predecessor.pop(node)
-            lT.t_e = max(lT.time_nodes)
-            lT.t_b = min(lT.time_nodes)
-            warnings.warn("Empty lists have been removed")
         return lT
 
     def get_idx3d(self, t: int) -> tuple:
@@ -1474,11 +1338,10 @@ class lineageTree(lineageTreeLoaders):
         leaves = set()
         while to_do:
             curr = to_do.pop()
-            succ = self.successor.get(curr)
-            if succ is not None:
+            succ = self.successor.get(curr, [])
+            if not succ:
                 leaves.add(curr)
-            else:
-                to_do += succ
+            to_do += succ
         return leaves
 
     def get_sub_tree(
@@ -1883,7 +1746,6 @@ class lineageTree(lineageTreeLoaders):
         color_of_edges=None,
         size=10,
         ax=None,
-        figure=None,
         default_color="black",
         **kwargs,
     ):
@@ -1940,7 +1802,7 @@ class lineageTree(lineageTreeLoaders):
         )
         ax.get_yaxis().set_visible(False)
         ax.get_xaxis().set_visible(False)
-        return figure, ax
+        return ax.get_figure(), ax
 
     def to_simple_graph(self, node=None, start_time: int = None):
         """Generates a dictionary of graphs where the keys are the index of the graph and
@@ -1975,8 +1837,8 @@ class lineageTree(lineageTreeLoaders):
         figsize=(10, 15),
         dpi=100,
         fontsize=15,
-        figure=None,
         axes=None,
+        vert_gap=1,
         **kwargs,
     ):
         """Plots all lineages.
@@ -2006,14 +1868,24 @@ class lineageTree(lineageTreeLoaders):
             )
         pos = {
             i: hierarchical_pos(
-                g, g["root"], ycenter=-int(self.time[g["root"]])
+                g,
+                g["root"],
+                ycenter=-int(self.time[g["root"]]),
+                vert_gap=vert_gap,
             )
             for i, g in graphs.items()
         }
-        ncols = int(len(graphs) // nrows) + (+np.sign(len(graphs) % nrows))
-        figure, axes = plt.subplots(
-            figsize=figsize, nrows=nrows, ncols=ncols, dpi=dpi, sharey=True
-        )
+        if axes is None:
+            ncols = int(len(graphs) // nrows) + (+np.sign(len(graphs) % nrows))
+            figure, axes = plt.subplots(
+                figsize=figsize, nrows=nrows, ncols=ncols, dpi=dpi, sharey=True
+            )
+        else:
+            figure, axes = axes.flatten()[0].get_figure(), axes
+            if len(axes.flatten()) < len(graphs):
+                raise Exception(
+                    f"Not enough axes, they should be at least {len(graphs)}."
+                )
         flat_axes = axes.flatten()
         ax2root = {}
         min_width, min_height = float("inf"), float("inf")
@@ -2051,9 +1923,17 @@ class lineageTree(lineageTreeLoaders):
                 },
             )
         [figure.delaxes(ax) for ax in axes.flatten() if not ax.has_data()]
-        return figure, axes, ax2root
+        return axes.flatten()[0].get_figure(), axes, ax2root
 
-    def plot_node(self, node, figsize=(4, 7), dpi=150, vert_gap=2, **kwargs):
+    def plot_node(
+        self,
+        node,
+        figsize=(4, 7),
+        dpi=150,
+        vert_gap=2,
+        ax=None,
+        **kwargs,
+    ):
         """Plots the subtree spawn by a node.
 
         Args:
@@ -2064,7 +1944,10 @@ class lineageTree(lineageTreeLoaders):
         if len(graph) > 1:
             raise Warning("Please enter only one node")
         graph = graph[0]
-        figure, ax = plt.subplots(nrows=1, ncols=1, figsize=figsize, dpi=dpi)
+        if not ax:
+            figure, ax = plt.subplots(
+                nrows=1, ncols=1, figsize=figsize, dpi=dpi
+            )
         self.draw_tree_graph(
             hier=hierarchical_pos(
                 graph,
@@ -2074,9 +1957,8 @@ class lineageTree(lineageTreeLoaders):
             ),
             lnks_tms=graph,
             ax=ax,
-            **kwargs,
         )
-        return figure, ax
+        return ax.get_figure(), ax
 
     # def DTW(self, t1, t2, max_w=None, start_delay=None, end_delay=None,
     #         metric='euclidian', **kwargs):
@@ -2729,6 +2611,7 @@ class lineageTree(lineageTreeLoaders):
             warnings.warn(
                 "Error: not possible to show alignment in PCA projection !",
                 UserWarning,
+                stacklevel=2,
             )
 
         return distance, fig
@@ -2824,6 +2707,8 @@ class lineageTree(lineageTreeLoaders):
                 self.read_from_ASTEC(file_format, eigen)
             elif file_type == "csv":
                 self.read_from_csv(file_format, z_mult, link=1, delim=delim)
+            elif file_type == "bao":
+                self.read_C_elegans_bao(file_format)
             elif file_format and file_format.endswith(".lT"):
                 with open(file_format, "br") as f:
                     tmp = pkl.load(f)
@@ -2834,15 +2719,5 @@ class lineageTree(lineageTreeLoaders):
             if self.name is None:
                 try:
                     self.name = Path(file_format).stem
-                except:
+                except TypeError:
                     self.name = Path(file_format[0]).stem
-        if [] in self.successor.values():
-            successors = list(self.successor.keys())
-            for succ in successors:
-                if self[succ] == []:
-                    self.successor.pop(succ)
-        if [] in self.predecessor.values():
-            predecessors = list(self.predecessor.keys())
-            for succ in predecessors:
-                if self[succ] == []:
-                    self.predecessor.pop(succ)

LineageTree/lineageTreeManager.py

@@ -2,6 +2,7 @@ import os
 import pickle as pkl
 import warnings
 from functools import partial
+
 import numpy as np
 
 try:
@@ -21,21 +22,19 @@ class lineageTreeManager:
         self.lineagetrees = {}
         self.lineageTree_counter = 0
         self.registered = {}
-        self.greatest_common_divisors = {}
 
     def __next__(self):
         self.lineageTree_counter += 1
         return self.lineageTree_counter - 1
 
-    def gcd_update(self, new_embryo):
-        if len(self.lineagetrees) > 1:
-            for lineagetree in self.lineagetrees:
-                self.greatest_common_divisors[lineagetree, new_embryo.name] = (
-                    np.gcd(
-                        self.lineagetrees[lineagetree].time_resolution,
-                        new_embryo.time_resolution,
-                    )
-                )
+    @property
+    def gcd(self):
+        if len(self.lineagetrees) >= 1:
+            all_time_res = [
+                embryo._time_resolution
+                for embryo in self.lineagetrees.values()
+            ]
+            return np.gcd.reduce(all_time_res)
 
     def add(
         self, other_tree: lineageTree, name: str = "", classification: str = ""
@@ -64,7 +63,6 @@ class lineageTreeManager:
                     name = f"Lineagetree {next(self)}"
                     self.lineagetrees[name] = other_tree
                     self.lineagetrees[name].name = name
-                    # self.greatest_common_divisors[name] = gcd
         else:
             raise Exception(
                 "Please add a LineageTree object or add time resolution to the LineageTree added."
@@ -120,7 +118,7 @@ class lineageTreeManager:
         n2: int,
         embryo_2,
         end_time2: int,
-        style="fragmented",
+        style="simple",
         downsample: int = 2,
         registration=None,  # will be added as a later feature
     ):
@@ -141,21 +139,48 @@ class lineageTreeManager:
         """
 
         tree = tree_style[style].value
+        lcm = (
+            self.lineagetrees[embryo_1]._time_resolution
+            * self.lineagetrees[embryo_2]._time_resolution
+        ) / self.gcd
+        if style == "downsampled":
+            if downsample % (lcm / 10) != 0:
+                raise Exception(
+                    f"Use a valid downsampling rate (multiple of {lcm/10})"
+                )
+            time_res = [
+                downsample / self.lineagetrees[embryo_2].time_resolution,
+                downsample / self.lineagetrees[embryo_1].time_resolution,
+            ]
+        elif style == "full":
+            time_res = [
+                lcm / 10 / self.lineagetrees[embryo_2].time_resolution,
+                lcm / 10 / self.lineagetrees[embryo_1].time_resolution,
+            ]
+        else:
+            time_res = [
+                self.lineagetrees[embryo_1]._time_resolution,
+                self.lineagetrees[embryo_2]._time_resolution,
+            ]
+            time_res = [i / self.gcd for i in time_res]
         tree1 = tree(
             lT=self.lineagetrees[embryo_1],
             downsample=downsample,
             end_time=end_time1,
             root=n1,
+            time_scale=time_res[0],
         )
         tree2 = tree(
             lT=self.lineagetrees[embryo_2],
             downsample=downsample,
             end_time=end_time2,
             root=n2,
+            time_scale=time_res[1],
         )
         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:

LineageTree/loaders.py

@@ -1,12 +1,28 @@
 import csv
 import os
 import pickle as pkl
+import struct
 import xml.etree.ElementTree as ET
+from warnings import warn
 
 import numpy as np
 
 
 class lineageTreeLoaders:
+    implicit_l_t = {
+        "AB": "P0",
+        "P1": "P0",
+        "EMS": "P1",
+        "P2": "P1",
+        "MS": "EMS",
+        "E": "EMS",
+        "C": "P2",
+        "P3": "P2",
+        "D": "P3",
+        "P4": "P3",
+        "Z2": "P4",
+        "Z3": "P4",
+    }
 
     def read_from_csv(
         self, file_path: str, z_mult: float, link: int = 1, delim: str = ","
@@ -65,7 +81,6 @@ class lineageTreeLoaders:
             self.pos[C] = pos
             self.nodes.add(C)
             self.time_nodes.setdefault(t, set()).add(C)
-            # self.time_id[(t, cell_id)] = C
             self.time[C] = t
             if not link:
                 self.displacement[C] = np.array([dx, dy, dz * z_mult])
@@ -314,6 +329,147 @@ class lineageTreeLoaders:
                 new_dict[k] = v
         return new_dict
 
+    def read_from_binary(self, fname: str):
+        """
+        Reads a binary lineageTree file name.
+        Format description: see self.to_binary
+
+        Args:
+            fname: string, path to the binary file
+            reverse_time: bool, not used
+        """
+        q_size = struct.calcsize("q")
+        H_size = struct.calcsize("H")
+        d_size = struct.calcsize("d")
+
+        with open(fname, "rb") as f:
+            len_tree = struct.unpack("q", f.read(q_size))[0]
+            len_time = struct.unpack("q", f.read(q_size))[0]
+            len_pos = struct.unpack("q", f.read(q_size))[0]
+            number_sequence = list(
+                struct.unpack("q" * len_tree, f.read(q_size * len_tree))
+            )
+            time_sequence = list(
+                struct.unpack("H" * len_time, f.read(H_size * len_time))
+            )
+            pos_sequence = np.array(
+                struct.unpack("d" * len_pos, f.read(d_size * len_pos))
+            )
+
+            f.close()
+
+        successor = {}
+        predecessor = {}
+        time = {}
+        time_nodes = {}
+        time_edges = {}
+        pos = {}
+        is_root = {}
+        nodes = []
+        edges = []
+        waiting_list = []
+        i = 0
+        done = False
+        if max(number_sequence[::2]) == -1:
+            tmp = number_sequence[1::2]
+            if len(tmp) * 3 == len(pos_sequence) == len(time_sequence) * 3:
+                time = dict(list(zip(tmp, time_sequence)))
+                for c, t in time.items():
+                    time_nodes.setdefault(t, set()).add(c)
+                pos = dict(
+                    list(zip(tmp, np.reshape(pos_sequence, (len_time, 3))))
+                )
+                is_root = {c: True for c in tmp}
+                nodes = tmp
+                done = True
+        while (
+            i < len(number_sequence) and not done
+        ):  # , c in enumerate(number_sequence[:-1]):
+            c = number_sequence[i]
+            if c == -1:
+                if waiting_list != []:
+                    prev_mother = waiting_list.pop()
+                    successor[prev_mother].insert(0, number_sequence[i + 1])
+                    edges.append((prev_mother, number_sequence[i + 1]))
+                    time_edges.setdefault(t, set()).add(
+                        (prev_mother, number_sequence[i + 1])
+                    )
+                    is_root[number_sequence[i + 1]] = False
+                    t = time[prev_mother] + 1
+                else:
+                    t = time_sequence.pop(0)
+                    is_root[number_sequence[i + 1]] = True
+
+            elif c == -2:
+                successor[waiting_list[-1]] = [number_sequence[i + 1]]
+                edges.append((waiting_list[-1], number_sequence[i + 1]))
+                time_edges.setdefault(t, set()).add(
+                    (waiting_list[-1], number_sequence[i + 1])
+                )
+                is_root[number_sequence[i + 1]] = False
+                pos[waiting_list[-1]] = pos_sequence[:3]
+                pos_sequence = pos_sequence[3:]
+                nodes.append(waiting_list[-1])
+                time[waiting_list[-1]] = t
+                time_nodes.setdefault(t, set()).add(waiting_list[-1])
+                t += 1
+
+            elif number_sequence[i + 1] >= 0:
+                successor[c] = [number_sequence[i + 1]]
+                edges.append((c, number_sequence[i + 1]))
+                time_edges.setdefault(t, set()).add(
+                    (c, number_sequence[i + 1])
+                )
+                is_root[number_sequence[i + 1]] = False
+                pos[c] = pos_sequence[:3]
+                pos_sequence = pos_sequence[3:]
+                nodes.append(c)
+                time[c] = t
+                time_nodes.setdefault(t, set()).add(c)
+                t += 1
+
+            elif number_sequence[i + 1] == -2:
+                waiting_list += [c]
+
+            elif number_sequence[i + 1] == -1:
+                pos[c] = pos_sequence[:3]
+                pos_sequence = pos_sequence[3:]
+                nodes.append(c)
+                time[c] = t
+                time_nodes.setdefault(t, set()).add(c)
+                t += 1
+                i += 1
+                if waiting_list != []:
+                    prev_mother = waiting_list.pop()
+                    successor[prev_mother].insert(0, number_sequence[i + 1])
+                    edges.append((prev_mother, number_sequence[i + 1]))
+                    time_edges.setdefault(t, set()).add(
+                        (prev_mother, number_sequence[i + 1])
+                    )
+                    if i + 1 < len(number_sequence):
+                        is_root[number_sequence[i + 1]] = False
+                    t = time[prev_mother] + 1
+                else:
+                    if len(time_sequence) > 0:
+                        t = time_sequence.pop(0)
+                    if i + 1 < len(number_sequence):
+                        is_root[number_sequence[i + 1]] = True
+            i += 1
+
+        predecessor = {vi: [k] for k, v in successor.items() for vi in v}
+
+        self.successor = successor
+        self.predecessor = predecessor
+        self.time = time
+        self.time_nodes = time_nodes
+        self.time_edges = time_edges
+        self.pos = pos
+        self.nodes = set(nodes)
+        self.t_b = min(time_nodes)
+        self.t_e = max(time_nodes)
+        self.is_root = is_root
+        self.max_id = max(self.nodes)
+
     def read_from_txt_for_celegans(self, file: str):
         """
         Read a C. elegans lineage tree
@@ -321,20 +477,6 @@ class lineageTreeLoaders:
         Args:
             file (str): Path to the file to read
         """
-        implicit_l_t = {
-            "AB": "P0",
-            "P1": "P0",
-            "EMS": "P1",
-            "P2": "P1",
-            "MS": "EMS",
-            "E": "EMS",
-            "C": "P2",
-            "P3": "P2",
-            "D": "P3",
-            "P4": "P3",
-            "Z2": "P4",
-            "Z3": "P4",
-        }
         with open(file) as f:
             raw = f.readlines()[1:]
             f.close()
@@ -363,12 +505,9 @@ class lineageTreeLoaders:
                         p = name_to_id[self.name[c]]
                     elif self.name[c][:-1] in name_to_id:
                         p = name_to_id[self.name[c][:-1]]
-                    elif implicit_l_t.get(self.name[c]) in name_to_id:
-                        p = name_to_id[implicit_l_t.get(self.name[c])]
+                    elif self.implicit_l_t.get(self.name[c]) in name_to_id:
+                        p = name_to_id[self.implicit_l_t.get(self.name[c])]
                     else:
-                        print(
-                            "error, cell %s has no predecessors" % self.name[c]
-                        )
                         p = None
                     self.predecessor.setdefault(c, []).append(p)
                     self.successor.setdefault(p, []).append(c)
@@ -389,21 +528,6 @@ class lineageTreeLoaders:
             file (str): Path to the file to read
         """
 
-        implicit_l_t = {
-            "AB": "P0",
-            "P1": "P0",
-            "EMS": "P1",
-            "P2": "P1",
-            "MS": "EMS",
-            "E": "EMS",
-            "C": "P2",
-            "P3": "P2",
-            "D": "P3",
-            "P4": "P3",
-            "Z2": "P4",
-            "Z3": "P4",
-        }
-
         def split_line(line):
             return (
                 line.split()[0],
@@ -450,11 +574,12 @@ class lineageTreeLoaders:
                         p = name_to_id[self.name[c]]
                     elif self.name[c][:-1] in name_to_id:
                         p = name_to_id[self.name[c][:-1]]
-                    elif implicit_l_t.get(self.name[c]) in name_to_id:
-                        p = name_to_id[implicit_l_t.get(self.name[c])]
+                    elif self.implicit_l_t.get(self.name[c]) in name_to_id:
+                        p = name_to_id[self.implicit_l_t.get(self.name[c])]
                     else:
-                        print(
-                            "error, cell %s has no predecessors" % self.name[c]
+                        warn(
+                            f"error, cell {self.name[c]} has no predecessors",
+                            stacklevel=2,
                         )
                         p = None
                     self.predecessor.setdefault(c, []).append(p)
@@ -496,9 +621,6 @@ class lineageTreeLoaders:
         self.intensity = {}
         self.W = {}
         for t in range(tb, te + 1):
-            print(t, end=" ")
-            if t % 10 == 0:
-                print()
             tree = ET.parse(file_format.format(t=t))
             root = tree.getroot()
             self.time_nodes[t] = set()
@@ -720,3 +842,55 @@ class lineageTreeLoaders:
                     tracks[t_id].append((s, t))
         self.t_b = min(self.time_nodes.keys())
         self.t_e = max(self.time_nodes.keys())
+
+    def read_C_elegans_bao(self, path):
+        cell_times = {}
+        self.expression = {}
+        with open(path) as f:
+            for line in f:
+                if "cell_name" not in line:
+                    cell_times[line.split("\t")[0]] = list(
+                        line.split("\t")[-1].split(",")
+                    )
+        new_dict = {}
+        end_dict = {}
+        self.t_e = 0
+        self.t_b = 0
+        for c, lc in cell_times.items():
+            new_dict[c] = self.add_node(0)
+            tmp = self.add_branch(
+                new_dict[c],
+                length=len(lc) - 1,
+                reverse=True,
+                move_timepoints=True,
+            )
+            for i, node in enumerate(self.get_cycle(tmp)):
+                self.expression[node] = int(lc[i])
+            self._labels[self.get_cycle(tmp)[0]] = c
+            self._labels.pop(tmp)
+            end_dict[c] = self.get_cycle(new_dict[c])[-1]
+        cell_names = list(cell_times.keys())
+        c_to_p = {}
+        while cell_names:
+            cur = cell_names.pop()
+            if cur[:-1] in cell_names:
+                c_to_p[cur] = cur[:-1]
+        c_to_p.update(self.implicit_l_t)
+        for c, p in c_to_p.items():
+            if p in cell_times:
+                cyc = end_dict[p]
+                self.predecessor[new_dict[c]] = [cyc]
+                if cyc not in self.successor:
+                    self.successor[cyc] = []
+                self.successor[cyc].append(new_dict[c])
+        self.time_nodes.clear()
+        for root in self.roots:
+            to_do = [root]
+            while to_do:
+                cur = to_do.pop()
+                self.time_nodes.setdefault(self.time[cur], set()).add(cur)
+                _next = self.successor.get(cur, [])
+                to_do += _next
+                for n in _next:
+                    self.time[n] = self.time[cur] + 1
+        self.t_e = max(self.time.values())

LineageTree/tree_styles.py

@@ -1,3 +1,4 @@
+import warnings
 from abc import ABC, abstractmethod
 from enum import Enum
 
@@ -23,13 +24,15 @@ class abstract_trees(ABC):
         root: int,
         downsample: int,
         end_time: int = None,
-        time_scale: int = None,
+        time_scale: int = 1,
     ):
         self.lT: lineageTree = lT
         self.root: int = root
         self.downsample: int = downsample
         self.end_time: int = end_time if end_time else self.lT.t_e
-        self.time_scale: int = time_scale if time_scale is not None else 1
+        self.time_scale: int = int(time_scale) if time_scale else 1
+        if time_scale <= 0:
+            raise Exception("Please used a valid time_scale (Larger than 0)")
         self.tree: tuple = self.get_tree()
         self.edist = self._edist_format(self.tree[0])
 
@@ -211,6 +214,13 @@ class downsample_tree(abstract_trees):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
+        if self.downsample == 0:
+            raise Exception("Please use a valid downsampling rate")
+        if self.downsample == 1:
+            warnings.warn(
+                "Downsampling rate of 1 is identical to the full tree.",
+                stacklevel=1,
+            )
 
     def get_tree(self):
         self.out_dict = {}
@@ -219,7 +229,8 @@ class downsample_tree(abstract_trees):
         while to_do:
             current = to_do.pop()
             _next = self.lT.get_cells_at_t_from_root(
-                current, self.lT.time[current] + self.downsample
+                current,
+                self.lT.time[current] + (self.downsample / self.time_scale),
             )
             if _next == [current]:
                 _next = None
@@ -228,11 +239,11 @@ class downsample_tree(abstract_trees):
                 to_do.extend(_next)
             else:
                 self.out_dict[current] = []
-            self.times[current] = self.downsample
+            self.times[current] = 1  # self.downsample
         return self.out_dict, self.times
 
     def get_norm(self):
-        return sum(self.times.values())
+        return len(self.times.values()) * self.downsample / self.time_scale
 
     def delta(self, x, y, corres1, corres2, times1, times2):
         if x is None and y is None:
@@ -283,22 +294,23 @@ class full_tree(abstract_trees):
             _next = self.lT.successor.get(current, [])
             if _next and self.lT.time[_next[0]] <= self.end_time:
                 if self.time_scale > 1:
-                    for _ in range(self.time_scale):
+                    for _ in range(self.time_scale - 1):
                         next_id = self.lT.get_next_id()
-                        self.out_dict[current] = next_id
+                        self.out_dict[current] = [next_id]
                         current = next_id
                 self.out_dict[current] = _next
                 to_do.extend(_next)
             else:
+                for _ in range(self.time_scale - 1):
+                    next_id = self.lT.get_next_id()
+                    self.out_dict[current] = [next_id]
+                    current = next_id
                 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))
-            * self.time_scale
-        )
+        return len(self.times) * self.time_scale
 
     def delta(self, x, y, corres1, corres2, times1, times2):
         if x is None and y is None:

LineageTree/utils.py

@@ -7,7 +7,8 @@ try:
     import motile
 except ImportError:
     warnings.warn(
-        "No motile installed therefore you will not be able to produce links with motile."
+        "No motile installed therefore you will not be able to produce links with motile.",
+        stacklevel=2,
     )
 
 
@@ -16,16 +17,13 @@ def to_motile(
 ):
     try:
         import networkx as nx
-    except:
-        raise Warning("Please install networkx")
+    except ImportError:
+        raise Warning("Please install networkx")  # noqa: B904
 
     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,
@@ -33,8 +31,6 @@ def to_motile(
                 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)
 
@@ -135,7 +131,9 @@ def hierarchical_pos(
         elif len(succ) == 1:
             pos_node[succ[0]] = [
                 pos_node[curr][0],
-                pos_node[curr][1] - lnks_tms["times"].get(curr, 0),
+                pos_node[curr][1]
+                - lnks_tms["times"].get(curr, 0)
+                + min(vert_gap, lnks_tms["times"].get(curr, 0)),
             ]
             to_do.extend(succ)
             prev_width[succ[0]] = prev_width[curr]

{LineageTree-1.7.0.dist-info → LineageTree-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: LineageTree
-Version: 1.7.0
+Version: 1.8.0
 Summary: Lineage tree structure
 Home-page: https://github.com/leoguignard/LineageTree
 Author: Léo Guignard
@@ -59,6 +59,7 @@ With LineageTree you can read from:
 - MaMuT files described in [Wolff et al. 2018](https://doi.org/10.7554/eLife.34410)
 - SVF algorithm outputs described in [McDole, Guignard et al. 2018](https://doi.org/10.1016/j.cell.2018.09.031)
 - ASTEC algorithm outputs described in [Guignard, Fiuza et al. 2020](https://doi.org/10.1126/science.aar5663)
+- Data from the [Digital development Database](http://digital-development.org/index.html) described in [Du et al. 2014](https://www.cell.com/fulltext/S0092-8674(13)01542-0) and [Du et al. 2015](https://www.sciencedirect.com/science/article/pii/S1534580715004876?via%3Dihub)
 - and few others
 
 ## Basic usage

LineageTree-1.8.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+LineageTree/__init__.py,sha256=888vRBgs18oExOHp7Q87HSH1GL60m-YLLjkMWYnZcBI,155
+LineageTree/lineageTree.py,sha256=SoxLcYXhr5wzuX9ZXMDsK5fePd_6_Boq-y4HVJ6mBBI,102326
+LineageTree/lineageTreeManager.py,sha256=bBhJrCUmLa6D6cZ95jT4hTnNfG7q-l_FiqOf2oaBc2o,6458
+LineageTree/loaders.py,sha256=eStgVrqYeUlYQ-r7EByCZo2t5cgn-mXARTWBzLSN12Q,32778
+LineageTree/tree_styles.py,sha256=ZEj0HcoEaWk8zyObboXW-qoM3uzKAQgiNzX2-UUa0cg,11337
+LineageTree/utils.py,sha256=sFIj1eDid1EKP09g_jrSgqk4NLdNVf7KjC5UwN0Fihc,4878
+LineageTree-1.8.0.dist-info/LICENSE,sha256=IKncNCNpq93Kq7Ywg1V4I9Bu_99VMK-mX1EJyjTKLyc,1068
+LineageTree-1.8.0.dist-info/METADATA,sha256=X9UUm6EP44N_O3Uv0JN4Bu9wXU9kXAB9Nh-lHkjHoEs,4469
+LineageTree-1.8.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+LineageTree-1.8.0.dist-info/top_level.txt,sha256=CCqPCTX76zPTEUagUgTWbLaZun8752n59iOOwfUlvxs,12
+LineageTree-1.8.0.dist-info/RECORD,,

LineageTree-1.7.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-LineageTree/__init__.py,sha256=gRnB16cDWVXa8GC6errEK0JxnllNypanG8HOJeO9mgo,155
-LineageTree/lineageTree.py,sha256=WLpKDzlt0vDL4zMOuyEsWYiLgNJcX8qMORgD0wPwQJg,107536
-LineageTree/lineageTreeManager.py,sha256=OFcW4DmUtsPQb6dw1jKy3EPezs4UCQ666-Ki3IYuzbc,5641
-LineageTree/loaders.py,sha256=D5hE928OD2RUGwG8CBW-69V8tp-k-VyNCm4I9AmtK2A,25976
-LineageTree/tree_styles.py,sha256=U4mkcAYCK1WjWT3rdP1Hc-KxNXqEnwgZy0HAxTsUNpE,10746
-LineageTree/utils.py,sha256=nhOThtLVA29cvt9SwrC9LE7kf6DZMaBr0OC7_hZf3Rk,4947
-LineageTree-1.7.0.dist-info/LICENSE,sha256=IKncNCNpq93Kq7Ywg1V4I9Bu_99VMK-mX1EJyjTKLyc,1068
-LineageTree-1.7.0.dist-info/METADATA,sha256=rdZOPPbmNa5YRbjOhLpLJPEeDPuFR4eHcPfOiXyud18,4195
-LineageTree-1.7.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-LineageTree-1.7.0.dist-info/top_level.txt,sha256=CCqPCTX76zPTEUagUgTWbLaZun8752n59iOOwfUlvxs,12
-LineageTree-1.7.0.dist-info/RECORD,,