# Copyright 2003-2008 by Leighton Pritchard. All rights reserved. # # This file is part of the Biopython distribution and governed by your # choice of the "Biopython License Agreement" or the "BSD 3-Clause License". # Please see the LICENSE file that should have been included as part of this # package. # # Contact: Leighton Pritchard, The James Hutton Institute, # Invergowrie, Dundee, Scotland, DD2 5DA, UK # Leighton.Pritchard@hutton.ac.uk ################################################################################ """Track module. Provides: - Track - Container for a single track on the diagram, containing FeatureSet and GraphSet objects For drawing capabilities, this module uses reportlab to draw and write the diagram: http://www.reportlab.com """ from reportlab.lib import colors # GenomeDiagram imports from ._FeatureSet import FeatureSet from ._GraphSet import GraphSet _grey = colors.Color(0.6, 0.6, 0.6) class Track: """Track. Attributes: - height Int describing the relative height to other trackscale_fontsizes in the diagram - name String describing the track - hide Boolean, 0 if the track is not to be drawn - start, end Integers (or None) specifying start/end to draw just a partial track. - greytrack Boolean, 1 if a grey background to the track is to be drawn - greytrack_labels Int describing how many track-identifying labels should be placed on the track at regular intervals - greytrack_font String describing the font to use for the greytrack labels - greytrack_fontsize Int describing the font size to display the labels on the grey track - greytrack_font_rotation Int describing the angle through which to rotate the grey track labels (Linear only) - greytrack_font_color colors.Color describing the color to draw the grey track labels - scale Boolean, 1 if a scale is to be drawn on the track - scale_format String, defaults to None, when scale values are written as numerals. Setting this to 'SInt' invokes SI unit-like multiples, such as Mbp, Kbp and so on. - scale_color colors.Color to draw the elements of the scale - scale_font String describing the font to use for the scale labels - scale_fontsize Int describing the size of the scale label font - scale_fontangle Int describing the angle at which to draw the scale labels (linear only) - scale_ticks Boolean, 1 if ticks should be drawn at all on the scale - scale_largeticks Float (0->1) describing the height of large scale ticks relative to the track height. - scale_smallticks Float (0->1) describing the height of large scale ticks relative to the track height. - scale_largetick_interval Int, describing the number of bases that should separate large ticks - scale_smalltick_interval Int, describing the number of bases that should separate small ticks - scale_largetick_labels Boolean describing whether position labels should be written over large ticks - scale_smalltick_labels Boolean describing whether position labels should be written over small ticks - axis_labels Boolean describing whether the value labels should be placed on the Y axes """ def __init__( self, name=None, height=1, hide=0, greytrack=0, greytrack_labels=5, greytrack_fontsize=8, greytrack_font="Helvetica", greytrack_font_rotation=0, greytrack_font_color=_grey, scale=1, scale_format=None, scale_color=colors.black, scale_font="Helvetica", scale_fontsize=6, scale_fontangle=45, scale_largeticks=0.5, scale_ticks=1, scale_smallticks=0.3, scale_largetick_interval=1e6, scale_smalltick_interval=1e4, scale_largetick_labels=1, scale_smalltick_labels=0, axis_labels=1, start=None, end=None, greytrack_font_colour=None, scale_colour=None, ): """Initialize. Arguments: - height Int describing the relative height to other tracks in the diagram - name String describing the track - hide Boolean, 0 if the track is not to be drawn - greytrack Boolean, 1 if a grey background to the track is to be drawn - greytrack_labels Int describing how many track-identifying labels should be placed on the track at regular intervals - greytrack_font String describing the font to use for the greytrack labels - greytrack_fontsize Int describing the font size to display the labels on the grey track - greytrack_font_rotation Int describing the angle through which to rotate the grey track labels (Linear only) - greytrack_font_color colors.Color describing the color to draw the grey track labels (overridden by backwards compatible argument with UK spelling, colour). - scale Boolean, 1 if a scale is to be drawn on the track - scale_color colors.Color to draw the elements of the scale (overridden by backwards compatible argument with UK spelling, colour). - scale_font String describing the font to use for the scale labels - scale_fontsize Int describing the size of the scale label font - scale_fontangle Int describing the angle at which to draw the scale labels (linear only) - scale_ticks Boolean, 1 if ticks should be drawn at all on the scale - scale_largeticks Float (0->1) describing the height of large scale ticks relative to the track height. - scale_smallticks Float (0->1) describing the height of large scale ticks relative to the track height. - scale_largetick_interval Int, describing the number of bases that should separate large ticks - scale_smalltick_interval Int, describing the number of bases that should separate small ticks - scale_largetick_labels Boolean describing whether position labels should be written over large ticks - scale_smalltick_labels Boolean describing whether position labels should be written over small ticks - name String to help identify the track - height Relative height to draw the track - axis_labels Boolean describing whether the value labels should be placed on the Y axes """ # Let the UK spelling (colour) override the USA spelling (color) if greytrack_font_colour is not None: greytrack_font_color = greytrack_font_colour if scale_colour is not None: scale_color = scale_colour self._next_id = 0 # This will count sets as they are added to the track self._sets = {} # Holds sets, keyed by unique ID # Assign attribute values from instantiation self.height = height if name is not None: self.name = str(name) else: self.name = "Track" self.hide = hide self.start = start self.end = end # Attributes for the grey track background and labels self.greytrack = greytrack self.greytrack_labels = greytrack_labels self.greytrack_fontsize = greytrack_fontsize self.greytrack_font = greytrack_font self.greytrack_font_rotation = greytrack_font_rotation self.greytrack_fontcolor = greytrack_font_color # Attributes for the track scale self.scale = scale self.scale_format = scale_format self.scale_color = scale_color self.scale_font = scale_font self.scale_fontsize = scale_fontsize self.scale_fontangle = scale_fontangle self.scale_ticks = scale_ticks self.scale_largeticks = scale_largeticks self.scale_smallticks = scale_smallticks self.scale_largetick_interval = scale_largetick_interval self.scale_smalltick_interval = scale_smalltick_interval self.scale_largetick_labels = scale_largetick_labels self.scale_smalltick_labels = scale_smalltick_labels self.axis_labels = axis_labels def add_set(self, set): """Add a preexisting FeatureSet or GraphSet object to the track.""" set.id = self._next_id # Assign unique id to set set.parent = self # Make set's parent this track self._sets[self._next_id] = set # Add set, keyed by unique id self._next_id += 1 # Increment unique set ids def new_set(self, type="feature", **args): """Create a new FeatureSet or GraphSet object. Create a new FeatureSet or GraphSet object, add it to the track, and return for user manipulation """ type_dict = {"feature": FeatureSet, "graph": GraphSet} set = type_dict[type]() for key in args: setattr(set, key, args[key]) set.id = self._next_id # Assign unique id to set set.parent = self # Make set's parent this track self._sets[self._next_id] = set # Add set, keyed by unique id self._next_id += 1 # Increment unique set ids return set def del_set(self, set_id): """Remove the set with the passed id from the track.""" del self._sets[set_id] def get_sets(self): """Return the sets contained in this track.""" return list(self._sets.values()) def get_ids(self): """Return the ids of all sets contained in this track.""" return list(self._sets.keys()) def range(self): """Return the lowest and highest base (or mark) numbers as a tuple.""" lows, highs = [], [] # Holds set of low and high values from sets if self.start is not None: lows.append(self.start) if self.end is not None: highs.append(self.end) for set in self._sets.values(): low, high = set.range() # Get each set range lows.append(low) highs.append(high) if lows: low = min(lows) else: low = None if highs: high = max(highs) else: high = None return low, high # Return lowest and highest values def to_string(self, verbose=0): """Return a formatted string with information about the track. Arguments: - verbose - Boolean indicating whether a short or complete account of the track is required """ if not verbose: # Return the short description return f"{self}" # Use __str__ method instead else: # Return the long description outstr = [f"\n<{self.__class__}: {self.name}>"] outstr.append("%d sets" % len(self._sets)) for key in self._sets: outstr.append(f"set: {self._sets[key]}") return "\n".join(outstr) def __getitem__(self, key): """Return the set with the passed id.""" return self._sets[key] def __str__(self): """Return a formatted string with information about the Track.""" outstr = [f"\n<{self.__class__}: {self.name}>"] outstr.append("%d sets" % len(self._sets)) return "\n".join(outstr)