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

LineageTree/utils.py

@@ -1,126 +1,88 @@
-import csv
-import warnings
-
-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 to_motile(
-    lT: lineageTree, crop: int = None, max_dist=200, max_skip_frames=1
-):
-    try:
-        import networkx as nx
-    except:
-        raise Warning("Please install networkx")
-
-    fmt = nx.DiGraph()
-    if not crop:
-        crop = lT.t_e
-    # 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 create_links_and_cycles(lT: lineageTree, roots=None):
-    """Generates a dictionary containing the links and the lengths of each branch.
-    Similar to simple tree, mainly used for tree manip app.
-
-    Args:
-        roots (Union[list,set,int]): The roots from which the tree will be generated.
-
-    Returns:
-        dict: A dictionary with keys "links" and "times" which contains the connections all cells and their branch
-        length.
+from collections.abc import Iterable
+
+from LineageTree import lineageTree, tree_approximation
+
+
+def create_links_and_chains(
+    lT: lineageTree,
+    roots: int | Iterable | None = None,
+    end_time: int | None = None,
+) -> dict[str, dict]:
+    """Generates a dictionary containing all the edges (from start of lifetime to end not the intermediate timepoints)
+      of a subtree spawned by node/s and their duration
+
+
+    Parameters
+    ----------
+    lT : lineageTree
+        The lineagetree that the user is working on
+    roots : int or Iterable, optional
+        The root/s from which the tree/s will be generated, if 'None' all the roots will be selected.
+    end_time : int, optional
+        The last timepoint to be considered, if 'None' the last timepoint of the dataset (t_e) is considered, by default None.
+
+    Returns
+    -------
+    dict mapping str to set or dict mapping int to list or int
+        A dictionary that contains:
+            - "links": The dictionary that contains the hierarchy of the nodes (only start and end of each chain)
+            - "times": The time distance between the start and the end of a chain
+            - "roots": The roots used
     """
     if roots is None:
         to_do = set(lT.roots)
-    elif isinstance(roots, list):
+    elif isinstance(roots, Iterable):
         to_do = set(roots)
     else:
         to_do = {int(roots)}
+    if end_time is None:
+        end_time = lT.t_e
     times = {}
     links = {}
     while to_do:
         curr = to_do.pop()
-        cyc = lT.get_successors(curr)
-        last = cyc[-1]
-        times[curr] = len(cyc)
-        if last != curr:
-            links[curr] = [cyc[-1]]
-        else:
-            links[curr] = []
-        succ = lT.successor.get(last)
-        if succ:
-            times[cyc[-1]] = 0
-            to_do.update(succ)
+        cyc = lT.get_successors(curr, end_time=end_time)
+        if cyc[-1] != curr or lT.time[cyc[-1]] <= end_time:
+            last = cyc[-1]
+            times[curr] = len(cyc)
+            if last != curr:
+                links[curr] = [last]
+            else:
+                links[curr] = []
+            succ = lT._successor.get(last)
+            if succ:
+                times[cyc[-1]] = 0
+                to_do.update(succ)
             links[last] = succ
     return {"links": links, "times": times, "root": roots}
 
 
 def hierarchical_pos(
     lnks_tms: dict, root, width=1000, vert_gap=2, xcenter=0, ycenter=0
-):
-    """Calculates the position of each node on te tree graph.
-
-    Args:
-        lnks_tms (dict): a dictionary created by create_links_and_cycles.
-        root (_type_): The id of the node, usually it exists inside lnks_tms dictionary, however you may use your own root.
-        width (int, optional): Max width, will not change the graph but the interacting with the graph takes this distance into account. Defaults to 1000.
-        vert_gap (int, optional): How far downwards each timepoint will go. Defaults to 2.
-        xcenter (int, optional): Where the root will be placed on the x axis. Defaults to 0.
-        ycenter (int, optional): Where the root will be placed on the y axis. Defaults to 0.
-
-    Returns:
-        _type_: _description_
+) -> dict[int, list[float]] | None:
+    """Calculates the position of each node on the tree graph.
+
+    Parameters
+    ----------
+    lnks_tms : dict
+         a dictionary created by create_links_and_chains.
+    root : _type_
+        The id of the node, usually it exists inside lnks_tms dictionary, however you may use your own root.
+    width : int, optional
+        Max width, will not change the graph but interacting with the graph takes this distance into account, by default 1000
+    vert_gap : int, optional
+        How far downwards each timepoint will go, by default 2
+    xcenter : int, optional
+        Where the root will be placed on the x axis, by default 0
+    ycenter : int, optional
+        Where the root will be placed on the y axis, by default 0
+
+    Returns
+    -------
+    dict mapping int to list of float
+        Provides a dictionary that contains the id of each node as keys and its 2-d position on the
+        tree graph as values.
+        If the root requested does not exists, None is then returned
     """
     to_do = [root]
     if root not in lnks_tms["times"]:
@@ -135,7 +97,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]
@@ -154,3 +118,37 @@ def hierarchical_pos(
                 prev_width[curr] / 2,
             )
     return pos_node
+
+
+def convert_style_to_number(
+    style: str | tree_approximation.TreeApproximationTemplate,
+    downsample: int | None,
+) -> int:
+    """Converts tree_style and downsampling to a single number.
+
+    Parameters
+    ----------
+    style : str
+        the tree style
+    downsample : int
+        the downsampling factor
+
+    Returns
+    -------
+    int
+        A number which serves as ID if the tree style and downsampling used.
+    """
+    style_dict = {
+        "full": 0,
+        "simple": -1,
+        "normalized_simple": -2,
+        "mini": -1000,
+    }
+    if style == "downsampled" and downsample is not None:
+        return downsample
+    elif not isinstance(style, str) and issubclass(
+        style, tree_approximation.TreeApproximationTemplate
+    ):
+        return hash(style.__name__)
+    else:
+        return style_dict[style]

{LineageTree-1.7.0.dist-info → lineagetree-2.0.1.dist-info}/METADATA

@@ -1,53 +1,49 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: LineageTree
-Version: 1.7.0
-Summary: Lineage tree structure
-Home-page: https://github.com/leoguignard/LineageTree
-Author: Léo Guignard
-Author-email: leo.guignard@univ-amu.fr
-License: MIT
-Project-URL: Bug Tracker, https://github.com/leoguignard/LineageTree/issues
-Project-URL: Documentation, https://github.com/leoguignard/LineageTree#README.md
-Project-URL: Source Code, https://github.com/leoguignard/LineageTree
-Project-URL: User Support, https://github.com/leoguignard/LineageTree/issues
-Classifier: Development Status :: 2 - Pre-Alpha
+Version: 2.0.1
+Summary: Structure for Lineage Trees
+Author: Giannis Liaskas, Christopher Mazzerbo
+Author-email: Léo Guignard <leo.guignard@univ-amu.fr>
+Maintainer-email: Léo Guignard <leo.guignard@univ-amu.fr>
+License-Expression: MIT
+Project-URL: Bug Tracker, https://github.com/GuignardLab/LineageTree/issues
+Project-URL: Documentation, https://github.com/GuignardLab/LineageTree#README.md
+Project-URL: Source Code, https://github.com/GuignardLab/LineageTree
+Project-URL: User Support, https://github.com/GuignardLab/LineageTree/issues
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
-Classifier: Topic :: Scientific/Engineering :: Image Processing
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: scipy>=1.9
 Requires-Dist: numpy>=1.23
 Requires-Dist: mastodon-reader
 Requires-Dist: matplotlib
-Provides-Extra: svg
-Requires-Dist: svgwrite; extra == "svg"
-Requires-Dist: matplotlib; extra == "svg"
+Requires-Dist: edist
+Requires-Dist: svgwrite
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: tox; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: sphinx-rtd-theme; extra == "doc"
+Requires-Dist: myst-parser; extra == "doc"
+Requires-Dist: sphinx_book_theme; extra == "doc"
 Provides-Extra: test
-Requires-Dist: svgwrite; extra == "test"
-Requires-Dist: matplotlib; extra == "test"
-Requires-Dist: tox; extra == "test"
 Requires-Dist: pytest; extra == "test"
 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"
+Dynamic: license-file
 
 # LineageTree
 
@@ -59,6 +55,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-2.0.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+LineageTree/__init__.py,sha256=Mkxh44uNuGueMMHEnOWpEchFefwMS6rht_EqHShIYew,749
+LineageTree/lineageTree.py,sha256=dWpGuQ_h4JMvTzOBaMg_dC4mkPwIR2Rb3EvDKowcVxM,125146
+LineageTree/lineageTreeManager.py,sha256=25QWNbj3Ep7itQKd6LrddICG457BEp1DlfKWgVHlx5I,31753
+LineageTree/loaders.py,sha256=rjLHSaukBI23oxndkqrkK_6UBjmzU4LUkr_lgOaZqvM,30189
+LineageTree/tree_approximation.py,sha256=61Omn0gUaRiNTDcIucDM4DUPBW5voXRxCZQ0uYGRDSg,16170
+LineageTree/utils.py,sha256=EOH2MGlBH3cFs8DVOX-3fJRwoj0ZmiE_nPkAjzWXK48,5124
+LineageTree/legacy/export_csv.py,sha256=cJ1R3GCGEy9Oey73jbFhoKRGTonNbqg229fVnGm_FuU,2009
+LineageTree/legacy/to_lineajea.py,sha256=iZyZTsrvWYHkGJ8npf91lQPrXPgKouiy7Zrywx5Lkkw,926
+LineageTree/legacy/to_motile.py,sha256=4AC9BmGa-hpqt8_x6HTR_XqCrTERlKo9WwYHUFtheM0,860
+LineageTree/test/test_lineageTree.py,sha256=d5uucokzE7OWQirsW7XxaGEgeRszQ5KICbAYhriXEQo,16492
+LineageTree/test/test_uted.py,sha256=Vl7uNGZp57XUD3v3SHRJtXhb0Lte8mDjpOtEKp_dxt0,6496
+lineagetree-2.0.1.dist-info/licenses/LICENSE,sha256=IKncNCNpq93Kq7Ywg1V4I9Bu_99VMK-mX1EJyjTKLyc,1068
+lineagetree-2.0.1.dist-info/METADATA,sha256=UwtX1LWAG-s-7aaGkss_UTpourt3InBk5ab5x-4W4i0,4300
+lineagetree-2.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lineagetree-2.0.1.dist-info/top_level.txt,sha256=CCqPCTX76zPTEUagUgTWbLaZun8752n59iOOwfUlvxs,12
+lineagetree-2.0.1.dist-info/RECORD,,

{LineageTree-1.7.0.dist-info → lineagetree-2.0.1.dist-info}/WHEEL

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

LineageTree/tree_styles.py

@@ -1,322 +0,0 @@
-from abc import ABC, abstractmethod
-from enum import Enum
-
-import numpy as np
-
-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,
-        downsample: int,
-        end_time: int = None,
-        time_scale: int = None,
-    ):
-        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
-    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 1 < len(_next):
-                    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 len(_next) > 1 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) * 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))
-            * self.time_scale
-        )
-
-
-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):
-        self.out_dict = {}
-        self.times = {}
-        to_do = [self.root]
-        while to_do:
-            current = to_do.pop()
-            _next = self.lT.get_cells_at_t_from_root(
-                current, self.lT.time[current] + self.downsample
-            )
-            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 sum(self.times.values())
-
-    def delta(self, 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):
-    """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:
-                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:
-                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
-        )
-
-    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 tree_style(Enum):
-    mini = mini_tree
-    simple = simple_tree
-    normalized_simple = normalized_simple_tree
-    downsampled = downsample_tree
-    full = full_tree
-
-    @classmethod
-    def list_names(self):
-        return [style.name for style in self]