biotite 0.41.1__cp312-cp312-macosx_10_16_x86_64.whl

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,139 @@
+# 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 numpy as np
+import json
+from os.path import join, dirname, realpath
+import glob
+import os
+from ..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']
+    """
+    for scheme in _color_schemes:
+        if scheme["name"] == name and scheme["alphabet"].extends(alphabet):
+            colors = scheme["colors"]
+            # Replace None values with default color
+            colors = [color if color is not None else default
+                      for color in colors]
+            # Only return colors that are in scope of this alphabet
+            # and not the extended alphabet
+            return colors[:len(alphabet)]
+    raise ValueError(f"Unkown scheme '{name}' for given alphabet")
+
+
+def list_color_scheme_names(alphabet):
+    """
+    Get a list of available color scheme names for a given alphabet.
+
+    Parameters
+    ----------
+    alphabet : Alphabet
+        The alphbet to get the color scheme names for.
+        The alphabet of the scheme must equal or extend this parameter,
+        to be included in the list.
+    
+    Returns
+    -------
+    schemes : list of str
+        A list of available color schemes.
+    """
+    scheme_list = []
+    for scheme in _color_schemes:
+        if 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)

biotite/sequence/graphics/dendrogram.py

@@ -0,0 +1,184 @@
+# 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
+    ----------
+    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)