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

LineageTree/__init__.py

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

LineageTree/lineageTree.py

@@ -20,7 +20,8 @@ try:
     from edist import uted
 except ImportError:
     warnings.warn(
-        "No edist installed therefore you will not be able to compute the tree edit distance."
+        "No edist installed therefore you will not be able to compute the tree edit distance.",
+        stacklevel=2,
     )
 import matplotlib.pyplot as plt
 import numpy as np
@@ -88,7 +89,7 @@ class lineageTree(lineageTreeLoaders):
             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
-            reverese (bool): If reverse will add a successor branch instead of a predecessor branch
+            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.
         """
@@ -129,9 +130,12 @@ class lineageTree(lineageTreeLoaders):
                     )
                     pred = _next
         else:
-            for t in range(length):
+            for _ in range(length):
                 _next = self.add_node(
-                    time + t, succ=pred, pos=self.pos[original], reverse=False
+                    self.time[pred] + 1,
+                    succ=pred,
+                    pos=self.pos[original],
+                    reverse=False,
                 )
                 pred = _next
             self.labels[pred] = "New branch"
@@ -325,7 +329,10 @@ class lineageTree(lineageTreeLoaders):
         if length == 1 and new_length != 1:
             pred = self.predecessor.pop(node, None)
             new_node = self.add_branch(
-                node, length=new_length, move_timepoints=True, reverse=False
+                node,
+                length=new_length - 1,
+                move_timepoints=True,
+                reverse=False,
             )
             if pred:
                 self.successor[pred[0]].remove(node)
@@ -365,6 +372,20 @@ class lineageTree(lineageTreeLoaders):
         else:
             return None
 
+    @property
+    def time_resolution(self):
+        if not hasattr(self, "_time_resolution"):
+            self.time_resolution = 1
+        return self._time_resolution / 10
+
+    @time_resolution.setter
+    def time_resolution(self, time_resolution):
+        if time_resolution is not None:
+            self._time_resolution = int(time_resolution * 10)
+        else:
+            warnings.warn("Time resolution set to default 1", stacklevel=2)
+            self._time_resolution = 10
+
     @property
     def roots(self):
         if not hasattr(self, "_roots"):
@@ -1178,6 +1199,8 @@ class lineageTree(lineageTreeLoaders):
         with open(fname, "br") as f:
             lT = pkl.load(f)
             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():
@@ -1392,8 +1415,10 @@ class lineageTree(lineageTreeLoaders):
         while to_do:
             current = to_do.pop()
             track = self.get_successors(current, end_time=end_time)
-            branches += [track]
-            to_do += self[track[-1]]
+            # if len(track) != 1 or self.time[current] <= end_time:
+            if self.time[track[-1]] <= end_time:
+                branches += [track]
+                to_do += self[track[-1]]
         return branches
 
     def get_all_tracks(self, force_recompute: bool = False) -> list:
@@ -1629,6 +1654,8 @@ class lineageTree(lineageTreeLoaders):
         at a given time `time`.
 
         If there is no ancestor, returns `-1`
+        If time is None return the root of the sub tree that spawns
+        the node n.
 
         Args:
             n (int): node for which to look the ancestor
@@ -1645,7 +1672,9 @@ class lineageTree(lineageTreeLoaders):
         if time is None:
             time = self.t_b
         ancestor = n
-        while time < self.time.get(ancestor, -1):
+        while (
+            time < self.time.get(ancestor, -1) and ancestor in self.predecessor
+        ):
             ancestor = self.predecessor.get(ancestor, [-1])[0]
         return ancestor
 
@@ -1674,10 +1703,11 @@ class lineageTree(lineageTreeLoaders):
     def unordered_tree_edit_distances_at_time_t(
         self,
         t: int,
-        delta: callable = None,
-        norm: callable = None,
-        recompute: bool = False,
         end_time: int = None,
+        style="simple",
+        downsample: int = 2,
+        normalize: bool = True,
+        recompute: bool = False,
     ) -> dict:
         """
         Compute all the pairwise unordered tree edit distances from Zhang 996 between the trees spawned at time `t`
@@ -1704,7 +1734,12 @@ class lineageTree(lineageTreeLoaders):
         for n1, n2 in combinations(roots, 2):
             key = tuple(sorted((n1, n2)))
             self.uted[t][key] = self.unordered_tree_edit_distance(
-                n1, n2, end_time=end_time
+                n1,
+                n2,
+                end_time=end_time,
+                style=style,
+                downsample=downsample,
+                normalize=normalize,
             )
         return self.uted[t]
 
@@ -1713,11 +1748,11 @@ class lineageTree(lineageTreeLoaders):
         n1: int,
         n2: int,
         end_time: int = None,
-        style="fragmented",
-        node_lengths: tuple = (1, 5, 7),
+        norm: Union["max", "sum", None] = "max",
+        style="simple",
+        downsample: int = 2,
     ) -> float:
         """
-        TODO: Add option for choosing which tree aproximation should be used (Full, simple, comp)
         Compute the unordered tree edit distance from Zhang 1996 between the trees spawned
         by two nodes `n1` and `n2`. The topology of the trees are compared and the matching
         cost is given by the function delta (see edist doc for more information).
@@ -1736,10 +1771,18 @@ class lineageTree(lineageTreeLoaders):
 
         tree = tree_style[style].value
         tree1 = tree(
-            lT=self, node_length=node_lengths, end_time=end_time, root=n1
+            lT=self,
+            downsample=downsample,
+            end_time=end_time,
+            root=n1,
+            time_scale=1,
         )
         tree2 = tree(
-            lT=self, node_length=node_lengths, end_time=end_time, root=n2
+            lT=self,
+            downsample=downsample,
+            end_time=end_time,
+            root=n2,
+            time_scale=1,
         )
         delta = tree1.delta
         _, times1 = tree1.tree
@@ -1763,70 +1806,141 @@ class lineageTree(lineageTreeLoaders):
             times1=times1,
             times2=times2,
         )
+        norm1 = tree1.get_norm()
+        norm2 = tree2.get_norm()
+        norm_dict = {"max": max, "sum": sum, "None": lambda x: 1}
+        if norm is None:
+            norm = "None"
+        if norm not in norm_dict:
+            raise Warning(
+                "Select a viable normalization method (max, sum, None)"
+            )
+        return uted.uted(
+            nodes1, adj1, nodes2, adj2, delta=delta_tmp
+        ) / norm_dict[norm]([norm1, norm2])
 
-        return uted.uted(nodes1, adj1, nodes2, adj2, delta=delta_tmp) / max(
-            tree1.get_norm(), tree2.get_norm()
+    @staticmethod
+    def __plot_nodes(
+        hier, selected_nodes, color, size, ax, default_color="black", **kwargs
+    ):
+        """
+        Private method that plots the nodes of the tree.
+        """
+        hier_unselected = np.array(
+            [v for k, v in hier.items() if k not in selected_nodes]
         )
+        if hier_unselected.any():
+            ax.scatter(
+                *hier_unselected.T,
+                s=size,
+                zorder=10,
+                color=default_color,
+                **kwargs,
+            )
+        if selected_nodes.intersection(hier.keys()):
+            hier_selected = np.array(
+                [v for k, v in hier.items() if k in selected_nodes]
+            )
+            ax.scatter(
+                *hier_selected.T, s=size, zorder=10, color=color, **kwargs
+            )
+
+    @staticmethod
+    def __plot_edges(
+        hier,
+        lnks_tms,
+        selected_edges,
+        color,
+        ax,
+        default_color="black",
+        **kwargs,
+    ):
+        """
+        Private method that plots the edges of the tree.
+        """
+        x, y = [], []
+        for pred, succs in lnks_tms["links"].items():
+            for succ in succs:
+                if pred not in selected_edges or succ not in selected_edges:
+                    x.extend((hier[succ][0], hier[pred][0], None))
+                    y.extend((hier[succ][1], hier[pred][1], None))
+        ax.plot(x, y, linewidth=0.3, zorder=0.1, c=default_color, **kwargs)
+        x, y = [], []
+        for pred, succs in lnks_tms["links"].items():
+            for succ in succs:
+                if pred in selected_edges and succ in selected_edges:
+                    x.extend((hier[succ][0], hier[pred][0], None))
+                    y.extend((hier[succ][1], hier[pred][1], None))
+        ax.plot(x, y, linewidth=0.3, zorder=0.2, c=color, **kwargs)
 
     def draw_tree_graph(
         self,
         hier,
         lnks_tms,
-        selected_cells=None,
-        color="magenta",
+        selected_nodes=None,
+        selected_edges=None,
+        color_of_nodes="magenta",
+        color_of_edges=None,
+        size=10,
         ax=None,
+        figure=None,
+        default_color="black",
         **kwargs,
     ):
-        if selected_cells is None:
-            selected_cells = []
+        """Function to plot the tree graph.
+
+        Args:
+            hier (dict): Dictinary that contains the positions of all nodes.
+            lnks_tms (dict): 2 dictionaries: 1 contains all links from start of life cycle to end of life cycle and
+                                             the succesors of each cell.
+                                             1 contains the length of each life cycle.
+            selected_nodes (list|set, optional): Which cells are to be selected (Painted with a different color). Defaults to None.
+            selected_edges (list|set, optional): Which edges are to be selected (Painted with a different color). Defaults to None.
+            color_of_nodes (str, optional): Color of selected nodes. Defaults to "magenta".
+            color_of_edges (_type_, optional): Color of selected edges. Defaults to None.
+            size (int, optional): Size of the nodes. Defaults to 10.
+            ax (_type_, optional): Plot the graph on existing ax. Defaults to None.
+            figure (_type_, optional): _description_. Defaults to None.
+            default_color (str, optional): Default color of nodes. Defaults to "black".
+
+        Returns:
+            figure, ax: The matplotlib figure and ax object.
+        """
+        if selected_nodes is None:
+            selected_nodes = []
+        if selected_edges is None:
+            selected_edges = []
         if ax is None:
-            _, ax = plt.subplots()
+            figure, ax = plt.subplots()
         else:
             ax.clear()
-
-        selected_cells = set(selected_cells)
-        hier_unselected = {
-            k: v for k, v in hier.items() if k not in selected_cells
-        }
-        hier_selected = {k: v for k, v in hier.items() if k in selected_cells}
-        unselected = np.array(tuple(hier_unselected.values()))
-        x = []
-        y = []
-        if hier_unselected:
-            for pred, succs in lnks_tms["links"].items():
-                if pred not in selected_cells:
-                    for succ in succs:
-                        x.extend((hier[succ][0], hier[pred][0], None))
-                        y.extend((hier[succ][1], hier[pred][1], None))
-            ax.plot(x, y, c="black", linewidth=0.3, zorder=0.5, **kwargs)
-            ax.scatter(
-                *unselected.T,
-                s=0.1,
-                c="black",
-                zorder=1,
-                **kwargs,
-            )
-        if selected_cells:
-            selected = np.array(tuple(hier_selected.values()))
-            x = []
-            y = []
-            for pred, succs in lnks_tms["links"].items():
-                if pred in selected_cells:
-                    for succ in succs:
-                        x.extend((hier[succ][0], hier[pred][0], None))
-                        y.extend((hier[succ][1], hier[pred][1], None))
-            ax.plot(x, y, c=color, linewidth=0.3, zorder=0.4, **kwargs)
-            ax.scatter(
-                selected.T[0],
-                selected.T[1],
-                s=0.1,
-                c=color,
-                zorder=0.9,
-                **kwargs,
-            )
+        if not isinstance(selected_nodes, set):
+            selected_nodes = set(selected_nodes)
+        if not isinstance(selected_edges, set):
+            selected_edges = set(selected_edges)
+        self.__plot_nodes(
+            hier,
+            selected_nodes,
+            color_of_nodes,
+            size=size,
+            ax=ax,
+            default_color=default_color,
+            **kwargs,
+        )
+        if not color_of_edges:
+            color_of_edges = color_of_nodes
+        self.__plot_edges(
+            hier,
+            lnks_tms,
+            selected_edges,
+            color_of_edges,
+            ax,
+            default_color=default_color,
+            **kwargs,
+        )
         ax.get_yaxis().set_visible(False)
         ax.get_xaxis().set_visible(False)
-        return ax
+        return 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
@@ -1960,6 +2074,7 @@ class lineageTree(lineageTreeLoaders):
             ),
             lnks_tms=graph,
             ax=ax,
+            **kwargs,
         )
         return figure, ax
 
@@ -2635,6 +2750,7 @@ class lineageTree(lineageTreeLoaders):
         reorder: bool = False,
         xml_attributes: tuple = None,
         name: str = None,
+        time_resolution: Union[int, None] = None,
     ):
         """
         TODO: complete the doc
@@ -2645,13 +2761,22 @@ class lineageTree(lineageTreeLoaders):
             file_format (str): either - path format to TGMM xmls
                                       - path to the MaMuT xml
                                       - path to the binary file
-            tb (int): first time point (necessary for TGMM xmls only)
-            te (int): last time point (necessary for TGMM xmls only)
-            z_mult (float): z aspect ratio if necessary (usually only for TGMM xmls)
-            file_type (str): type of input file. Accepts:
+            tb (int, optional):first time point (necessary for TGMM xmls only)
+            te (int, optional): last time point (necessary for TGMM xmls only)
+            z_mult (float, optional):z aspect ratio if necessary (usually only for TGMM xmls)
+            file_type (str, optional):type of input file. Accepts:
                 'TGMM, 'ASTEC', MaMuT', 'TrackMate', 'csv', 'celegans', 'binary'
                 default is 'binary'
+            delim (str, optional): _description_. Defaults to ",".
+            eigen (bool, optional): _description_. Defaults to False.
+            shape (tuple, optional): _description_. Defaults to None.
+            raw_size (tuple, optional): _description_. Defaults to None.
+            reorder (bool, optional): _description_. Defaults to False.
+            xml_attributes (tuple, optional): _description_. Defaults to None.
+            name (str, optional): The name of the dataset. Defaults to None.
+            time_resolution (Union[int, None], optional): Time resolution in mins (If time resolution is smaller than one minute input the time in ms). Defaults to None.
         """
+
         self.name = name
         self.time_nodes = {}
         self.time_edges = {}
@@ -2663,6 +2788,8 @@ class lineageTree(lineageTreeLoaders):
         self.pos = {}
         self.time_id = {}
         self.time = {}
+        if time_resolution is not None:
+            self._time_resolution = time_resolution
         self.kdtrees = {}
         self.spatial_density = {}
         if file_type and file_format:

LineageTree/lineageTreeManager.py

@@ -2,12 +2,14 @@ import os
 import pickle as pkl
 import warnings
 from functools import partial
+import numpy as np
 
 try:
     from edist import uted
 except ImportError:
     warnings.warn(
-        "No edist installed therefore you will not be able to compute the tree edit distance."
+        "No edist installed therefore you will not be able to compute the tree edit distance.",
+        stacklevel=2,
     )
 from LineageTree import lineageTree
 
@@ -17,14 +19,24 @@ from .tree_styles import tree_style
 class lineageTreeManager:
     def __init__(self):
         self.lineagetrees = {}
-        # self.classification = {"Wt": {}, "Ptb": {}}
         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,
+                    )
+                )
+
     def add(
         self, other_tree: lineageTree, name: str = "", classification: str = ""
     ):
@@ -38,7 +50,7 @@ class lineageTreeManager:
             name (str, optional): Then name of. Defaults to "".
 
         """
-        if isinstance(other_tree, lineageTree):
+        if isinstance(other_tree, lineageTree) and other_tree.time_resolution:
             for tree in self.lineagetrees.values():
                 if tree == other_tree:
                     return False
@@ -52,25 +64,15 @@ class lineageTreeManager:
                     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}
+                    # self.greatest_common_divisors[name] = gcd
+        else:
+            raise Exception(
+                "Please add a LineageTree object or add time resolution to the LineageTree added."
+            )
 
     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
 
@@ -119,8 +121,8 @@ class lineageTreeManager:
         embryo_2,
         end_time2: int,
         style="fragmented",
-        node_lengths: tuple = (1, 5, 7),
-        registration=None,
+        downsample: int = 2,
+        registration=None,  # will be added as a later feature
     ):
         """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
@@ -141,13 +143,13 @@ class lineageTreeManager:
         tree = tree_style[style].value
         tree1 = tree(
             lT=self.lineagetrees[embryo_1],
-            node_length=node_lengths,
+            downsample=downsample,
             end_time=end_time1,
             root=n1,
         )
         tree2 = tree(
             lT=self.lineagetrees[embryo_2],
-            node_length=node_lengths,
+            downsample=downsample,
             end_time=end_time2,
             root=n2,
         )

LineageTree/loaders.py

@@ -1,11 +1,79 @@
 import csv
+import os
 import pickle as pkl
 import xml.etree.ElementTree as ET
-import os
+
 import numpy as np
 
 
 class lineageTreeLoaders:
+
+    def read_from_csv(
+        self, file_path: str, z_mult: float, link: int = 1, delim: str = ","
+    ):
+        """
+        TODO: write doc
+        """
+        with open(file_path) as f:
+            lines = f.readlines()
+            f.close()
+        self.time_nodes = {}
+        self.time_edges = {}
+        unique_id = 0
+        self.nodes = set()
+        self.edges = set()
+        self.successor = {}
+        self.predecessor = {}
+        self.pos = {}
+        self.time_id = {}
+        self.time = {}
+        self.lin = {}
+        self.C_lin = {}
+        if not link:
+            self.displacement = {}
+        lines_to_int = []
+        corres = {}
+        for line in lines:
+            lines_to_int += [[eval(v.strip()) for v in line.split(delim)]]
+        lines_to_int = np.array(lines_to_int)
+        if link == 2:
+            lines_to_int = lines_to_int[np.argsort(lines_to_int[:, 0])]
+        else:
+            lines_to_int = lines_to_int[np.argsort(lines_to_int[:, 1])]
+        for line in lines_to_int:
+            if link == 1:
+                id_, t, z, y, x, pred, lin_id = line
+            elif link == 2:
+                t, z, y, x, id_, pred, lin_id = line
+            else:
+                id_, t, z, y, x, dz, dy, dx = line
+                pred = None
+                lin_id = None
+            t = int(t)
+            pos = np.array([x, y, z])
+            C = unique_id
+            corres[id_] = C
+            pos[-1] = pos[-1] * z_mult
+            if pred in corres:
+                M = corres[pred]
+                self.predecessor[C] = [M]
+                self.successor.setdefault(M, []).append(C)
+                self.edges.add((M, C))
+                self.time_edges.setdefault(t, set()).add((M, C))
+                self.lin.setdefault(lin_id, []).append(C)
+                self.C_lin[C] = lin_id
+            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])
+            unique_id += 1
+        self.max_id = unique_id - 1
+        self.t_b = min(self.time_nodes)
+        self.t_e = max(self.time_nodes)
+
     def read_from_ASTEC(self, file_path: str, eigen: bool = False):
         """
         Read an `xml` or `pkl` file produced by the ASTEC algorithm.

LineageTree/tree_styles.py

@@ -7,14 +7,30 @@ from LineageTree import lineageTree
 
 
 class abstract_trees(ABC):
+    """Template class to produce different techniques to comapare lineageTrees.
+    To add a new technique you need to iherit this class or one of its children
+    and add them to the tree_style enum.
+    For a class to be valid you need a
+    - tree constructor (get_tree) that produces one dictionary that contains
+    arbitary unique labels and one dictionary that contains the duration of each node.
+    - delta function: A function that handles the cost of comparing nodes to each other.
+    - normalization function, a function that returns the length of the tree or any interger.
+    """
+
     def __init__(
-        self, lT: lineageTree, root: int, node_length: int, end_time: int
+        self,
+        lT: lineageTree,
+        root: int,
+        downsample: int,
+        end_time: int = None,
+        time_scale: int = None,
     ):
-        self.lT = lT
-        self.root = root
-        self.node_length = node_length
-        self.end_time = end_time
-        self.tree = self.get_tree()
+        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.tree: tuple = self.get_tree()
         self.edist = self._edist_format(self.tree[0])
 
     @abstractmethod
@@ -124,7 +140,7 @@ class mini_tree(abstract_trees):
             cycle = cycle[cycle_times <= self.end_time]
             if cycle.size:
                 _next = self.lT[cycle[-1]]
-                if len(_next) > 1:
+                if 1 < len(_next):
                     out_dict[current] = _next
                     to_do.extend(_next)
                 else:
@@ -177,86 +193,76 @@ class simple_tree(abstract_trees):
                     to_do.extend(_next)
                 else:
                     out_dict[current] = []
-            self.times[current] = len(
-                cycle
-            )  # * time_resolution will be fixed when working on registered trees.
+            self.times[current] = len(cycle) * self.time_scale
         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))
+        return (
+            len(self.lT.get_sub_tree(self.root, end_time=self.end_time))
+            * self.time_scale
+        )
 
 
-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.
-    """
+class downsample_tree(abstract_trees):
+    """Downsamples a tree so every n nodes are being used as one."""
 
     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)
+            _next = self.lT.get_cells_at_t_from_root(
+                current, self.lT.time[current] + self.downsample
             )
-            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] = []
-
+            if _next == [current]:
+                _next = None
+            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] = self.downsample
         return self.out_dict, self.times
 
     def get_norm(self):
-        return len(self.lT.get_sub_tree(self.root, end_time=self.end_time))
+        return sum(self.times.values())
 
     def delta(self, x, y, corres1, corres2, times1, times2):
-        return super().delta(x, y, corres1, corres2, times1, times2)
+        if x is None and y is None:
+            return 0
+        if x is None:
+            return self.downsample
+        if y is None:
+            return self.downsample
+        return 0
+
+
+class normalized_simple_tree(simple_tree):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    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 abs(times1[corres1[x]] - times2[corres2[y]]) / (
+            times1[corres1[x]] + times2[corres2[y]]
+        )
+
+    def get_norm(self):
+        return len(
+            self.lT.get_all_branches_of_node(self.root, end_time=self.end_time)
+        )
 
 
 class full_tree(abstract_trees):
@@ -276,6 +282,11 @@ class full_tree(abstract_trees):
             current = to_do.pop()
             _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):
+                        next_id = self.lT.get_next_id()
+                        self.out_dict[current] = next_id
+                        current = next_id
                 self.out_dict[current] = _next
                 to_do.extend(_next)
             else:
@@ -284,16 +295,26 @@ class full_tree(abstract_trees):
         return self.out_dict, self.times
 
     def get_norm(self):
-        return len(self.lT.get_sub_tree(self.root, end_time=self.end_time))
+        return (
+            len(self.lT.get_sub_tree(self.root, end_time=self.end_time))
+            * self.time_scale
+        )
 
     def delta(self, x, y, corres1, corres2, times1, times2):
-        return super().delta(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 tree_style(Enum):
     mini = mini_tree
     simple = simple_tree
-    fragmented = fragmented_tree
+    normalized_simple = normalized_simple_tree
+    downsampled = downsample_tree
     full = full_tree
 
     @classmethod

LineageTree/utils.py

@@ -1,8 +1,6 @@
 import csv
-import random
 import warnings
 
-
 from LineageTree import lineageTree
 
 try:

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: LineageTree
-Version: 1.6.0
+Version: 1.7.0
 Summary: Lineage tree structure
 Home-page: https://github.com/leoguignard/LineageTree
 Author: Léo Guignard
@@ -28,14 +28,6 @@ Requires-Dist: scipy>=1.9
 Requires-Dist: numpy>=1.23
 Requires-Dist: mastodon-reader
 Requires-Dist: matplotlib
-Provides-Extra: all
-Requires-Dist: svgwrite; extra == "all"
-Requires-Dist: matplotlib; extra == "all"
-Requires-Dist: tox; extra == "all"
-Requires-Dist: pytest; extra == "all"
-Requires-Dist: pytest-cov; extra == "all"
-Requires-Dist: edist; extra == "all"
-Requires-Dist: mastodon-reader; extra == "all"
 Provides-Extra: svg
 Requires-Dist: svgwrite; extra == "svg"
 Requires-Dist: matplotlib; extra == "svg"
@@ -48,6 +40,14 @@ Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: mastodon-reader; extra == "test"
 Provides-Extra: treeedit
 Requires-Dist: edist; extra == "treeedit"
+Provides-Extra: all
+Requires-Dist: svgwrite; extra == "all"
+Requires-Dist: matplotlib; extra == "all"
+Requires-Dist: tox; extra == "all"
+Requires-Dist: pytest; extra == "all"
+Requires-Dist: pytest-cov; extra == "all"
+Requires-Dist: edist; extra == "all"
+Requires-Dist: mastodon-reader; extra == "all"
 
 # LineageTree
 

LineageTree-1.7.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+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,,

{LineageTree-1.6.0.dist-info → LineageTree-1.7.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

LineageTree-1.6.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-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,,