biotite 1.5.0__cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

biotite/sequence/graphics/color_schemes/sunset.json

@@ -0,0 +1,51 @@
+{
+    "name": "sunset",
+    "alphabet": [
+        "A",
+        "C",
+        "D",
+        "E",
+        "F",
+        "G",
+        "H",
+        "I",
+        "K",
+        "L",
+        "M",
+        "N",
+        "P",
+        "Q",
+        "R",
+        "S",
+        "T",
+        "V",
+        "W",
+        "Y",
+        "B",
+	"Z",
+	"X",
+	"*"
+    ],
+    "colors": {
+        "A": "#fea0fd",
+        "C": "#fc0cfe",
+        "D": "#2e7bbe",
+        "E": "#677892",
+        "F": "#ff385d",
+        "G": "#2799ff",
+        "H": "#dbc58e",
+        "I": "#fa21a1",
+        "K": "#debecc",
+        "L": "#e01e82",
+        "M": "#d13e7b",
+        "N": "#abc8f5",
+        "P": "#5766f9",
+        "Q": "#8c6e81",
+        "R": "#85746a",
+        "S": "#e7b4fd",
+        "T": "#a658b7",
+        "V": "#fe51b8",
+        "W": "#ff3701",
+        "Y": "#cb5339"
+    }
+}

biotite/sequence/graphics/color_schemes/wither.json

@@ -0,0 +1,51 @@
+{
+    "name": "wither",
+    "alphabet": [
+        "A",
+        "C",
+        "D",
+        "E",
+        "F",
+        "G",
+        "H",
+        "I",
+        "K",
+        "L",
+        "M",
+        "N",
+        "P",
+        "Q",
+        "R",
+        "S",
+        "T",
+        "V",
+        "W",
+        "Y",
+        "B",
+	"Z",
+	"X",
+	"*"
+    ],
+    "colors": {
+        "A": "#b36139",
+        "C": "#ef0300",
+        "D": "#068855",
+        "E": "#028489",
+        "F": "#da06b6",
+        "G": "#797c00",
+        "H": "#0f73ee",
+        "I": "#ea0063",
+        "K": "#0a81a2",
+        "L": "#de1a76",
+        "M": "#a10c56",
+        "N": "#0f5e46",
+        "P": "#1c8701",
+        "Q": "#19577b",
+        "R": "#0a7dbc",
+        "S": "#6e5842",
+        "T": "#843f07",
+        "V": "#da3952",
+        "W": "#4600ff",
+        "Y": "#8607b4"
+    }
+}

biotite/sequence/graphics/colorschemes.py

@@ -0,0 +1,170 @@
+# This source code is part of the Biotite package and is distributed
+# under the 3-Clause BSD License. Please see 'LICENSE.rst' for further
+# information.
+
+__name__ = "biotite.sequence.graphics"
+__author__ = "Patrick Kunzmann"
+__all__ = ["get_color_scheme", "list_color_scheme_names", "load_color_scheme"]
+
+import glob
+import json
+import os
+from os.path import dirname, join, realpath
+from biotite.sequence.alphabet import Alphabet
+
+
+def load_color_scheme(file_name):
+    """
+    Load a color scheme from a JSON file.
+
+    A color scheme is a list of colors that correspond to symbols of an
+    alphabet. The color for a symbol is list of colors indexed by the
+    corresponding symbol code.
+
+    Parameters
+    ----------
+    file_name : str
+        The file name of the JSON file containing the scheme.
+
+    Returns
+    -------
+    scheme : dict
+        A dictionary representing the color scheme, It contains the
+        following keys, if the input file is proper:
+
+           - **name** - Name of the scheme.
+           - **alphabet** - :class:`Alphabet` instance describing the
+             type of sequence the scheme can be used for.
+           - **colors** - List of *Matplotlib* compatible colors
+    """
+    with open(file_name, "r") as file:
+        scheme = json.load(file)
+        alphabet = Alphabet(scheme["alphabet"])
+        # Store alphabet as 'Alphabet' object
+        scheme["alphabet"] = alphabet
+        colors = [None] * len(alphabet)
+        for key, value in scheme["colors"].items():
+            index = alphabet.encode(key)
+            colors[index] = value
+        # Store colors as symbol code ordered list of colors,
+        # rather than dictionary
+        scheme["colors"] = colors
+        return scheme
+
+
+def get_color_scheme(name, alphabet, default="#FFFFFF"):
+    """
+    Get a color scheme by name and alphabet.
+
+    A color scheme is a list of colors that correspond to symbols of an
+    alphabet. The color for a symbol is list of colors indexed by the
+    corresponding symbol code.
+
+    Parameters
+    ----------
+    name : str
+        The name of the color scheme.
+    alphabet : Alphabet
+        The alphabet to obtain the scheme for. The alphabet of the
+        scheme must equal or extend this parameter.
+    default : str or tuple, optional
+        A *Matplotlib* compatible color that is used for symbols that
+        have no defined color in the scheme.
+
+    Returns
+    -------
+    colors : list
+        A list of *Matplotlib* compatible colors. The colors in the list
+        have the same order as the symbols in the given `alphabet`.
+        Since the alphabet of the color scheme may extend the given
+        `alphabet`, the list of colors can be longer than the
+        `alphabet`.
+
+    Notes
+    -----
+    There can be multiple color schemes with the same name but for
+    different alphabets (e.g. one for dna and one for protein
+    sequences).
+
+    Examples
+    --------
+
+    >>> alphabet = NucleotideSequence.alphabet_unamb
+    >>> color_scheme = get_color_scheme("rainbow", alphabet)
+    >>> print(color_scheme)
+    ['#3737f5', '#37f537', '#f5f537', '#f53737']
+    """
+    # Try exact alphabet match first
+    for scheme in _color_schemes:
+        if scheme["name"] == name and scheme["alphabet"] == alphabet:
+            return _fit_color_scheme(alphabet, scheme, default)
+    # If no exact match was found, try to find a scheme for an alphabet
+    # that extends the given alphabet
+    for scheme in _color_schemes:
+        if scheme["name"] == name and scheme["alphabet"].extends(alphabet):
+            return _fit_color_scheme(alphabet, scheme, default)
+
+    raise ValueError(f"Unkown scheme '{name}' for given alphabet")
+
+
+def list_color_scheme_names(alphabet, strict=False):
+    """
+    Get a list of available color scheme names for a given alphabet.
+
+    Parameters
+    ----------
+    alphabet : Alphabet
+        The alphabet to get the color scheme names for.
+    strict : bool, optional
+        If set to true, only schemes with an exact match to the given
+        alphabet are included in the list.
+        If set to false, schemes with an alphabet that extends the given
+        alphabet are also included.
+
+    Returns
+    -------
+    schemes : list of str
+        A list of available color schemes.
+    """
+    scheme_list = []
+    for scheme in _color_schemes:
+        if strict and scheme["alphabet"] == alphabet:
+            scheme_list.append(scheme["name"])
+        if not strict and scheme["alphabet"].extends(alphabet):
+            scheme_list.append(scheme["name"])
+    return scheme_list
+
+
+_scheme_dir = join(dirname(realpath(__file__)), "color_schemes")
+
+_color_schemes = []
+
+for file_name in glob.glob(_scheme_dir + os.sep + "*.json"):
+    scheme = load_color_scheme(file_name)
+    _color_schemes.append(scheme)
+
+
+def _fit_color_scheme(alphabet, color_scheme, default_color):
+    """
+    Fit a color scheme to the given alphabet.
+
+    Parameters
+    ----------
+    alphabet : Alphabet
+        The alphabet to get the color scheme for.
+    color_scheme : dict
+        The color scheme.
+    default_color : str or tuple
+        The default color.
+
+    Returns
+    -------
+    scheme : list of str
+        The colors from the scheme.
+    """
+    colors = color_scheme["colors"]
+    # Replace None values with default color
+    colors = [color if color is not None else default_color for color in colors]
+    # Only return colors that are in scope of this alphabet
+    # and not the extended alphabet
+    return colors[: len(alphabet)]

biotite/sequence/graphics/dendrogram.py

@@ -0,0 +1,231 @@
+# This source code is part of the Biotite package and is distributed
+# under the 3-Clause BSD License. Please see 'LICENSE.rst' for further
+# information.
+
+__name__ = "biotite.sequence.graphics"
+__author__ = "Patrick Kunzmann"
+__all__ = ["plot_dendrogram"]
+
+import numpy as np
+
+
+def plot_dendrogram(
+    axes,
+    tree,
+    orientation="left",
+    use_distances=True,
+    labels=None,
+    label_size=None,
+    color="black",
+    show_distance=True,
+    **kwargs,
+):
+    """
+    Plot a dendrogram from a (phylogenetic) tree.
+
+    Parameters
+    ----------
+    axes : Axes
+        A *Matplotlib* axes, that is used as plotting area.
+    tree : Tree
+        The tree to be visualized.
+    orientation : {'left', 'right', 'bottom', 'top'}, optional
+        The position of the root node in the plot
+    use_distances : bool, optional
+        If true, the `distance` attribute of the :class:`TreeNode`
+        objects are used as distance measure.
+        Otherwise the topological distance is used.
+    labels : list of str, optional
+        The leaf node labels.
+        The label of a leaf node is the entry at the position of its
+        `index` attribute.
+    label_size : float, optional
+        The font size of the labels.
+    color : tuple or str, optional
+        A *Matplotlib* compatible color, that is used to draw the lines
+        of the dendrogram.
+    show_distance : bool, optional
+        If true, the distance from the root is shown on the
+        corresponding axis.
+    **kwargs
+        Additional parameters that are used to draw the dendrogram
+        lines.
+    """
+
+    indices = tree.root.get_indices()
+    leaf_dict = {indices[i]: i for i in indices}
+
+    # Required for setting the plot limits
+    max_distance = 0
+
+    def _plot_node(node, distance):
+        """
+        Draw the lines from the given node to its children.
+
+        Parameters
+        ----------
+        dist : float
+            the distance of the node from root
+
+        Returns
+        -------
+        pos : float
+            the postion of the node on the 'label' axis
+        """
+        # The term 'distance'
+        # refers to positions along the 'distance' axis
+        # the term 'pos'
+        # refers to positions along the other axis
+        nonlocal max_distance
+        if max_distance < distance:
+            max_distance = distance
+        if node.is_leaf():
+            # No children -> no line can be drawn
+            return leaf_dict[node.index]
+        else:
+            children = node.children
+            if use_distances:
+                child_distances = [distance + c.distance for c in children]
+            else:
+                # Use topologic distance of children to this node,
+                # which is always 1
+                child_distances = [distance + 1 for c in children]
+            child_pos = [
+                _plot_node(child, child_distance)
+                for child, child_distance in zip(children, child_distances)
+            ]
+            # Position of this node is in the center of the child nodes
+            center_pos = sum(child_pos) / len(child_pos)
+            if orientation in ["left", "right"]:
+                # Line connecting the childs
+                axes.plot(
+                    [distance, distance],
+                    [child_pos[0], child_pos[-1]],
+                    color=color,
+                    marker="None",
+                    **kwargs,
+                )
+                # Lines depicting the distances of the childs
+                for child_dist, pos in zip(child_distances, child_pos):
+                    axes.plot(
+                        [distance, child_dist],
+                        [pos, pos],
+                        color=color,
+                        marker="None",
+                        **kwargs,
+                    )
+            elif orientation in ["bottom", "top"]:
+                # Line connecting the childs
+                axes.plot(
+                    [child_pos[0], child_pos[-1]],
+                    [distance, distance],
+                    color=color,
+                    marker="None",
+                    **kwargs,
+                )
+                # Lines depicting the distances of the childs
+                for child_dist, pos in zip(child_distances, child_pos):
+                    axes.plot(
+                        [pos, pos],
+                        [distance, child_dist],
+                        color=color,
+                        marker="None",
+                        **kwargs,
+                    )
+            else:
+                raise ValueError(f"'{orientation}' is not a valid orientation")
+            return center_pos
+
+    _plot_node(tree.root, 0)
+
+    if labels is not None:
+        # Sort labels using the order of indices in the tree
+        # A list cannot be directly indexed with a list,
+        # hence the conversion to a ndarray
+        labels = np.array(labels)[indices].tolist()
+    else:
+        labels = [str(i) for i in indices]
+    # The distance axis does not start at 0,
+    # since the root line would not properly rendered
+    # Hence the limit is set a to small fraction of the entire axis
+    # beyond 0
+    zero_limit = -0.01 * max_distance
+    if orientation == "left":
+        axes.set_xlim(zero_limit, max_distance)
+        axes.set_ylim(-1, len(indices))
+        axes.set_yticks(np.arange(0, len(indices)))
+        axes.set_yticklabels(labels)
+        axes.yaxis.set_tick_params(
+            left=False,
+            right=False,
+            labelleft=False,
+            labelright=True,
+            labelsize=label_size,
+        )
+        axes.xaxis.set_tick_params(
+            bottom=True,
+            top=False,
+            labelbottom=show_distance,
+            labeltop=False,
+            labelsize=label_size,
+        )
+    elif orientation == "right":
+        axes.set_xlim(max_distance, zero_limit)
+        axes.set_ylim(-1, len(indices))
+        axes.set_yticks(np.arange(0, len(indices)))
+        axes.set_yticklabels(labels)
+        axes.yaxis.set_tick_params(
+            left=False,
+            right=False,
+            labelleft=True,
+            labelright=False,
+            labelsize=label_size,
+        )
+        axes.xaxis.set_tick_params(
+            bottom=True,
+            top=False,
+            labelbottom=show_distance,
+            labeltop=False,
+            labelsize=label_size,
+        )
+    elif orientation == "bottom":
+        axes.set_ylim(zero_limit, max_distance)
+        axes.set_xlim(-1, len(indices))
+        axes.set_xticks(np.arange(0, len(indices)))
+        axes.set_xticklabels(labels)
+        axes.xaxis.set_tick_params(
+            bottom=False,
+            top=False,
+            labelbottom=False,
+            labeltop=True,
+            labelsize=label_size,
+        )
+        axes.yaxis.set_tick_params(
+            left=True,
+            right=False,
+            labelleft=show_distance,
+            labelright=False,
+            labelsize=label_size,
+        )
+    elif orientation == "top":
+        axes.set_ylim(max_distance, zero_limit)
+        axes.set_xlim(-1, len(indices))
+        axes.set_xticks(np.arange(0, len(indices)))
+        axes.set_xticklabels(labels)
+        axes.xaxis.set_tick_params(
+            bottom=False,
+            top=False,
+            labelbottom=True,
+            labeltop=False,
+            labelsize=label_size,
+        )
+        axes.yaxis.set_tick_params(
+            left=True,
+            right=False,
+            labelleft=show_distance,
+            labelright=False,
+            labelsize=label_size,
+        )
+    else:
+        raise ValueError(f"'{orientation}' is not a valid orientation")
+    axes.set_frame_on(False)