# Copyright 2003-2008 by Leighton Pritchard. All rights reserved. # Revisions copyright 2008-2009 by Peter Cock. # # 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 ################################################################################ """Linear Drawer module. Provides: - LinearDrawer - Drawing object for linear diagrams For drawing capabilities, this module uses reportlab to draw and write the diagram: http://www.reportlab.com """ from math import ceil from reportlab.graphics.shapes import Drawing from reportlab.graphics.shapes import Group from reportlab.graphics.shapes import Line from reportlab.graphics.shapes import Polygon from reportlab.graphics.shapes import String from reportlab.lib import colors from ._AbstractDrawer import _stroke_and_fill_colors from ._AbstractDrawer import AbstractDrawer from ._AbstractDrawer import angle2trig from ._AbstractDrawer import deduplicate from ._AbstractDrawer import draw_arrow from ._AbstractDrawer import draw_box from ._AbstractDrawer import draw_cut_corner_box from ._AbstractDrawer import intermediate_points from ._FeatureSet import FeatureSet from ._GraphSet import GraphSet class LinearDrawer(AbstractDrawer): """Linear Drawer. Inherits from: - AbstractDrawer Attributes: - tracklines Boolean for whether to draw lines delineating tracks - pagesize Tuple describing the size of the page in pixels - x0 Float X co-ord for leftmost point of drawable area - xlim Float X co-ord for rightmost point of drawable area - y0 Float Y co-ord for lowest point of drawable area - ylim Float Y co-ord for topmost point of drawable area - pagewidth Float pixel width of drawable area - pageheight Float pixel height of drawable area - xcenter Float X co-ord of center of drawable area - ycenter Float Y co-ord of center of drawable area - start Int, base to start drawing from - end Int, base to stop drawing at - length Int, size of sequence to be drawn - fragments Int, number of fragments into which to divide the drawn sequence - fragment_size Float (0->1) the proportion of the fragment height to draw in - track_size Float (0->1) the proportion of the track height to draw in - drawing Drawing canvas - drawn_tracks List of ints denoting which tracks are to be drawn - current_track_level Int denoting which track is currently being drawn - fragment_height Float total fragment height in pixels - fragment_bases Int total fragment length in bases - fragment_lines Dictionary of top and bottom y-coords of fragment, keyed by fragment number - fragment_limits Dictionary of start and end bases of each fragment, keyed by fragment number - track_offsets Dictionary of number of pixels that each track top, center and bottom is offset from the base of a fragment, keyed by track - cross_track_links List of tuples each with four entries (track A, feature A, track B, feature B) to be linked. """ def __init__( self, parent=None, pagesize="A3", orientation="landscape", x=0.05, y=0.05, xl=None, xr=None, yt=None, yb=None, start=None, end=None, tracklines=0, fragments=10, fragment_size=None, track_size=0.75, cross_track_links=None, ): """Initialize. Arguments: - parent Diagram object containing the data that the drawer draws - pagesize String describing the ISO size of the image, or a tuple of pixels - orientation String describing the required orientation of the final drawing ('landscape' or 'portrait') - x Float (0->1) describing the relative size of the X margins to the page - y Float (0->1) describing the relative size of the Y margins to the page - xl Float (0->1) describing the relative size of the left X margin to the page (overrides x) - xl Float (0->1) describing the relative size of the left X margin to the page (overrides x) - xr Float (0->1) describing the relative size of the right X margin to the page (overrides x) - yt Float (0->1) describing the relative size of the top Y margin to the page (overrides y) - yb Float (0->1) describing the relative size of the lower Y margin to the page (overrides y) - start Int, the position to begin drawing the diagram at - end Int, the position to stop drawing the diagram at - tracklines Boolean flag to show (or not) lines delineating tracks on the diagram - fragments Int, the number of equal fragments into which the sequence should be divided for drawing - fragment_size Float(0->1) The proportion of the available height for the fragment that should be taken up in drawing - track_size The proportion of the available track height that should be taken up in drawing - cross_track_links List of tuples each with four entries (track A, feature A, track B, feature B) to be linked. """ # Use the superclass' instantiation method AbstractDrawer.__init__( self, parent, pagesize, orientation, x, y, xl, xr, yt, yb, start, end, tracklines, cross_track_links, ) # Useful measurements on the page self.fragments = fragments if fragment_size is not None: self.fragment_size = fragment_size else: if self.fragments == 1: # For single fragments, default to full height self.fragment_size = 1 else: # Otherwise keep a 10% gap between fragments self.fragment_size = 0.9 self.track_size = track_size def draw(self): """Draw a linear diagram of the data in the parent Diagram object.""" # Instantiate the drawing canvas self.drawing = Drawing(self.pagesize[0], self.pagesize[1]) feature_elements = [] # holds feature elements feature_labels = [] # holds feature labels greytrack_bgs = [] # holds track background greytrack_labels = [] # holds track foreground labels scale_axes = [] # holds scale axes scale_labels = [] # holds scale axis labels # Get the tracks to be drawn self.drawn_tracks = self._parent.get_drawn_levels() # Set fragment and track sizes self.init_fragments() self.set_track_heights() # Go through each track in the parent (if it is to be drawn) one by # one and collate the data as drawing elements for track_level in self.drawn_tracks: # only use tracks to be drawn self.current_track_level = track_level # establish track level track = self._parent[track_level] # get the track at that level gbgs, glabels = self.draw_greytrack(track) # get greytrack elements greytrack_bgs.append(gbgs) greytrack_labels.append(glabels) features, flabels = self.draw_track(track) # get feature and graph elements feature_elements.append(features) feature_labels.append(flabels) if track.scale: axes, slabels = self.draw_scale(track) # get scale elements scale_axes.append(axes) scale_labels.append(slabels) feature_cross_links = [] for cross_link_obj in self.cross_track_links: cross_link_elements = self.draw_cross_link(cross_link_obj) if cross_link_elements: feature_cross_links.append(cross_link_elements) # Groups listed in order of addition to page (from back to front) # Draw track backgrounds # Draw feature cross track links # Draw features and graphs # Draw scale axes # Draw scale labels # Draw feature labels # Draw track labels element_groups = [ greytrack_bgs, feature_cross_links, feature_elements, scale_axes, scale_labels, feature_labels, greytrack_labels, ] for element_group in element_groups: for element_list in element_group: [self.drawing.add(element) for element in element_list] if self.tracklines: # Draw test tracks over top of diagram self.draw_test_tracks() def init_fragments(self): """Initialize useful values for positioning diagram elements.""" # Set basic heights, lengths etc self.fragment_height = self.pageheight / self.fragments # total fragment height in pixels self.fragment_bases = ceil(self.length / self.fragments) # fragment length in bases # Key fragment base and top lines by fragment number # Holds bottom and top line locations of fragments, keyed by fragment number self.fragment_lines = {} # Number of pixels to crop the fragment: fragment_crop = (1 - self.fragment_size) / 2 fragy = self.ylim # Holder for current absolute fragment base for fragment in range(self.fragments): fragtop = fragy - fragment_crop * self.fragment_height # top - crop fragbtm = ( fragy - (1 - fragment_crop) * self.fragment_height ) # bottom + crop self.fragment_lines[fragment] = (fragbtm, fragtop) fragy -= self.fragment_height # next fragment base # Key base starts and ends for each fragment by fragment number self.fragment_limits = {} # Holds first and last base positions in a fragment fragment_step = self.fragment_bases # bases per fragment fragment_count = 0 # Add start and end positions for each fragment to dictionary for marker in range(int(self.start), int(self.end), int(fragment_step)): self.fragment_limits[fragment_count] = (marker, marker + fragment_step) fragment_count += 1 def set_track_heights(self): """Set track heights. Since tracks may not be of identical heights, the bottom and top offsets of each track relative to the fragment top and bottom is stored in a dictionary - self.track_offsets, keyed by track number. """ bot_track = min(min(self.drawn_tracks), 1) top_track = max(self.drawn_tracks) # The 'highest' track number to draw trackunit_sum = 0 # Total number of 'units' for the tracks trackunits = {} # The start and end units for each track, keyed by track number heightholder = 0 # placeholder variable for track in range(bot_track, top_track + 1): # for all track numbers to 'draw' try: trackheight = self._parent[track].height # Get track height except Exception: # TODO: IndexError? trackheight = 1 # ...or default to 1 trackunit_sum += trackheight # increment total track unit height trackunits[track] = (heightholder, heightholder + trackheight) heightholder += trackheight # move to next height trackunit_height = self.fragment_height * self.fragment_size / trackunit_sum # Calculate top and bottom offsets for each track, relative to fragment # base track_offsets = {} # The offsets from fragment base for each track track_crop = ( trackunit_height * (1 - self.track_size) / 2.0 ) # 'step back' in pixels assert track_crop >= 0 for track in trackunits: top = trackunits[track][1] * trackunit_height - track_crop # top offset btm = trackunits[track][0] * trackunit_height + track_crop # bottom offset ctr = btm + (top - btm) / 2.0 # center offset track_offsets[track] = (btm, ctr, top) self.track_offsets = track_offsets def draw_test_tracks(self): """Draw test tracks. Draw red lines indicating the top and bottom of each fragment, and blue ones indicating tracks to be drawn. """ # Add lines for each fragment for fbtm, ftop in self.fragment_lines.values(): self.drawing.add( Line(self.x0, ftop, self.xlim, ftop, strokeColor=colors.red) ) # top line self.drawing.add( Line(self.x0, fbtm, self.xlim, fbtm, strokeColor=colors.red) ) # bottom line # Add track lines for this fragment - but only for drawn tracks for track in self.drawn_tracks: trackbtm = fbtm + self.track_offsets[track][0] trackctr = fbtm + self.track_offsets[track][1] tracktop = fbtm + self.track_offsets[track][2] self.drawing.add( Line( self.x0, tracktop, self.xlim, tracktop, strokeColor=colors.blue ) ) # top line self.drawing.add( Line( self.x0, trackctr, self.xlim, trackctr, strokeColor=colors.green ) ) # center line self.drawing.add( Line( self.x0, trackbtm, self.xlim, trackbtm, strokeColor=colors.blue ) ) # bottom line def draw_track(self, track): """Draw track. Arguments: - track Track object Returns a tuple (list of elements in the track, list of labels in the track). """ track_elements = [] # Holds elements from features and graphs track_labels = [] # Holds labels from features and graphs # Distribution dictionary for dealing with different set types set_methods = {FeatureSet: self.draw_feature_set, GraphSet: self.draw_graph_set} for set in track.get_sets(): # Draw the feature or graph sets elements, labels = set_methods[set.__class__](set) track_elements += elements track_labels += labels return track_elements, track_labels def draw_tick(self, tickpos, ctr, ticklen, track, draw_label): """Draw tick. Arguments: - tickpos Int, position of the tick on the sequence - ctr Float, Y co-ord of the center of the track - ticklen How long to draw the tick - track Track, the track the tick is drawn on - draw_label Boolean, write the tick label? Returns a drawing element that is the tick on the scale """ if self.start >= tickpos and tickpos >= self.end: raise RuntimeError( "Tick at %i, but showing %i to %i" % (tickpos, self.start, self.end) ) if not ( (track.start is None or track.start <= tickpos) and (track.end is None or tickpos <= track.end) ): raise RuntimeError( "Tick at %i, but showing %r to %r for track" % (tickpos, track.start, track.end) ) fragment, tickx = self.canvas_location(tickpos) # Tick coordinates assert fragment >= 0, "Fragment %i, tickpos %i" % (fragment, tickpos) tctr = ctr + self.fragment_lines[fragment][0] # Center line of the track tickx += self.x0 # Tick X co-ord ticktop = tctr + ticklen # Y co-ord of tick top tick = Line(tickx, tctr, tickx, ticktop, strokeColor=track.scale_color) if draw_label: # Put tick position on as label if track.scale_format == "SInt": if tickpos >= 1000000: tickstring = str(tickpos // 1000000) + " Mbp" elif tickpos >= 1000: tickstring = str(tickpos // 1000) + " Kbp" else: tickstring = str(tickpos) else: tickstring = str(tickpos) label = String( 0, 0, tickstring, # Make label string fontName=track.scale_font, fontSize=track.scale_fontsize, fillColor=track.scale_color, ) labelgroup = Group(label) rotation = angle2trig(track.scale_fontangle) labelgroup.transform = ( rotation[0], rotation[1], rotation[2], rotation[3], tickx, ticktop, ) else: labelgroup = None return tick, labelgroup def draw_scale(self, track): """Draw scale. Argument: - track Track object Returns a tuple of (list of elements in the scale, list of labels in the scale). """ scale_elements = [] # Holds axes and ticks scale_labels = [] # Holds labels if not track.scale: # No scale required, exit early return [], [] # Get track location btm, ctr, top = self.track_offsets[self.current_track_level] trackheight = top - ctr # For each fragment, draw the scale for this track start, end = self._current_track_start_end() start_f, start_x = self.canvas_location(start) end_f, end_x = self.canvas_location(end) for fragment in range(start_f, end_f + 1): tbtm = btm + self.fragment_lines[fragment][0] tctr = ctr + self.fragment_lines[fragment][0] ttop = top + self.fragment_lines[fragment][0] # X-axis if fragment == start_f: x_left = start_x else: x_left = 0 if fragment == end_f: x_right = end_x # Y-axis end marker scale_elements.append( Line( self.x0 + x_right, tbtm, self.x0 + x_right, ttop, strokeColor=track.scale_color, ) ) else: x_right = self.xlim - self.x0 scale_elements.append( Line( self.x0 + x_left, tctr, self.x0 + x_right, tctr, strokeColor=track.scale_color, ) ) # Y-axis start marker scale_elements.append( Line( self.x0 + x_left, tbtm, self.x0 + x_left, ttop, strokeColor=track.scale_color, ) ) start, end = self._current_track_start_end() if track.scale_ticks: # Ticks are required on the scale # Draw large ticks # I want the ticks to be consistently positioned relative to # the start of the sequence (position 0), not relative to the # current viewpoint (self.start and self.end) ticklen = track.scale_largeticks * trackheight tickiterval = int(track.scale_largetick_interval) # Note that we could just start the list of ticks using # range(0,self.end,tickinterval) and the filter out the # ones before self.start - but this seems wasteful. # Using tickiterval * (self.start//tickiterval) is a shortcut. for tickpos in range( tickiterval * (self.start // tickiterval), int(self.end), tickiterval ): if tickpos <= start or end <= tickpos: continue tick, label = self.draw_tick( tickpos, ctr, ticklen, track, track.scale_largetick_labels ) scale_elements.append(tick) if label is not None: # If there's a label, add it scale_labels.append(label) # Draw small ticks ticklen = track.scale_smallticks * trackheight tickiterval = int(track.scale_smalltick_interval) for tickpos in range( tickiterval * (self.start // tickiterval), int(self.end), tickiterval ): if tickpos <= start or end <= tickpos: continue tick, label = self.draw_tick( tickpos, ctr, ticklen, track, track.scale_smalltick_labels ) scale_elements.append(tick) if label is not None: # If there's a label, add it scale_labels.append(label) # Check to see if the track contains a graph - if it does, get the # minimum and maximum values, and put them on the scale Y-axis if track.axis_labels: for set in track.get_sets(): # Check all sets... if set.__class__ is GraphSet: # ...for a graph set graph_label_min = [] graph_label_mid = [] graph_label_max = [] for graph in set.get_graphs(): quartiles = graph.quartiles() minval, maxval = quartiles[0], quartiles[4] if graph.center is None: midval = (maxval + minval) / 2.0 graph_label_min.append(f"{minval:.3f}") graph_label_max.append(f"{maxval:.3f}") else: diff = max((graph.center - minval), (maxval - graph.center)) minval = graph.center - diff maxval = graph.center + diff midval = graph.center graph_label_mid.append(f"{midval:.3f}") graph_label_min.append(f"{minval:.3f}") graph_label_max.append(f"{maxval:.3f}") for fragment in range( start_f, end_f + 1 ): # Add to all used fragment axes tbtm = btm + self.fragment_lines[fragment][0] tctr = ctr + self.fragment_lines[fragment][0] ttop = top + self.fragment_lines[fragment][0] if fragment == start_f: x_left = start_x else: x_left = 0 for val, pos in [ (";".join(graph_label_min), tbtm), (";".join(graph_label_max), ttop), (";".join(graph_label_mid), tctr), ]: label = String( 0, 0, val, fontName=track.scale_font, fontSize=track.scale_fontsize, fillColor=track.scale_color, ) labelgroup = Group(label) rotation = angle2trig(track.scale_fontangle) labelgroup.transform = ( rotation[0], rotation[1], rotation[2], rotation[3], self.x0 + x_left, pos, ) scale_labels.append(labelgroup) return scale_elements, scale_labels def draw_greytrack(self, track): """Draw greytrack. Arguments: - track Track object Put in a grey background to the current track in all fragments, if track specifies that we should. """ greytrack_bgs = [] # Holds grey track backgrounds greytrack_labels = [] # Holds grey foreground labels if not track.greytrack: # No greytrack required, return early return [], [] # Get track location btm, ctr, top = self.track_offsets[self.current_track_level] start, end = self._current_track_start_end() start_fragment, start_offset = self.canvas_location(start) end_fragment, end_offset = self.canvas_location(end) # Add greytrack to all fragments for this track for fragment in range(start_fragment, end_fragment + 1): tbtm = btm + self.fragment_lines[fragment][0] tctr = ctr + self.fragment_lines[fragment][0] ttop = top + self.fragment_lines[fragment][0] if fragment == start_fragment: x1 = self.x0 + start_offset else: x1 = self.x0 if fragment == end_fragment: x2 = self.x0 + end_offset else: x2 = self.xlim box = draw_box( (x1, tbtm), (x2, ttop), colors.Color(0.96, 0.96, 0.96), # Grey track bg ) # is just a box greytrack_bgs.append(box) if track.greytrack_labels: # If labels are required # # how far apart should they be? labelstep = self.pagewidth / track.greytrack_labels label = String( 0, 0, track.name, # label contents fontName=track.greytrack_font, fontSize=track.greytrack_fontsize, fillColor=track.greytrack_fontcolor, ) # Create a new labelgroup at each position the label is required for x in range(int(self.x0), int(self.xlim), int(labelstep)): if fragment == start_fragment and x < start_offset: continue if ( fragment == end_fragment and end_offset < x + label.getBounds()[2] ): continue labelgroup = Group(label) rotation = angle2trig(track.greytrack_font_rotation) labelgroup.transform = ( rotation[0], rotation[1], rotation[2], rotation[3], x, tbtm, ) if not self.xlim - x <= labelstep: # Don't overlap the end of the track greytrack_labels.append(labelgroup) return greytrack_bgs, greytrack_labels def draw_feature_set(self, set): """Draw feature set. Arguments: - set FeatureSet object Returns a tuple (list of elements describing features, list of labels for elements). """ # print("draw feature set") feature_elements = [] # Holds diagram elements belonging to the features label_elements = [] # Holds diagram elements belonging to feature labels # Collect all the elements for the feature set for feature in set.get_features(): if self.is_in_bounds(feature.start) or self.is_in_bounds(feature.end): features, labels = self.draw_feature(feature) # get elements and labels feature_elements += features label_elements += labels return feature_elements, label_elements def draw_feature(self, feature): """Draw feature. Arguments: - feature Feature containing location info Returns tuple of (list of elements describing single feature, list of labels for those elements). """ if feature.hide: # Feature hidden, don't draw it... return [], [] feature_elements = [] # Holds diagram elements belonging to the feature label_elements = [] # Holds labels belonging to the feature start, end = self._current_track_start_end() # A single feature may be split into subfeatures, so loop over them for locstart, locend in feature.locations: if locend < start: continue locstart = max(locstart, start) if end < locstart: continue locend = min(locend, end) feature_boxes = self.draw_feature_location(feature, locstart, locend) for box, label in feature_boxes: feature_elements.append(box) if label is not None: label_elements.append(label) return feature_elements, label_elements def draw_feature_location(self, feature, locstart, locend): """Draw feature location.""" feature_boxes = [] # Get start and end positions for feature/subfeatures start_fragment, start_offset = self.canvas_location(locstart) end_fragment, end_offset = self.canvas_location(locend) # print("start_fragment, start_offset", start_fragment, start_offset) # print("end_fragment, end_offset", end_fragment, end_offset) # print("start, end", locstart, locend) # Note that there is a strange situation where a feature may be in # several parts, and one or more of those parts may end up being # drawn on a non-existent fragment. So we check that the start and # end fragments do actually exist in terms of the drawing allowed_fragments = list(self.fragment_limits.keys()) if start_fragment in allowed_fragments and end_fragment in allowed_fragments: # print(feature.name, feature.start, feature.end, start_offset, end_offset) if start_fragment == end_fragment: # Feature is found on one fragment feature_box, label = self.get_feature_sigil( feature, start_offset, end_offset, start_fragment ) feature_boxes.append((feature_box, label)) # feature_elements.append(feature_box) # if label is not None: # There is a label for the feature # label_elements.append(label) else: # Feature is split over two or more fragments fragment = start_fragment start = start_offset # The bit that runs up to the end of the first fragment, # and any bits that subsequently span whole fragments while self.fragment_limits[fragment][1] < locend: # print(fragment, self.fragment_limits[fragment][1], locend) feature_box, label = self.get_feature_sigil( feature, start, self.pagewidth, fragment ) fragment += 1 # move to next fragment start = 0 # start next sigil from start of fragment feature_boxes.append((feature_box, label)) # feature_elements.append(feature_box) # if label is not None: # There's a label for the feature # label_elements.append(label) # The last bit of the feature # print(locend, self.end, fragment) # print(self.fragment_bases, self.length) feature_box, label = self.get_feature_sigil( feature, 0, end_offset, fragment ) feature_boxes.append((feature_box, label)) # if locstart > locend: # print(locstart, locend, feature.location.strand, feature_boxes, feature.name) return feature_boxes def draw_cross_link(self, cross_link): """Draw cross-link between two features.""" startA = cross_link.startA startB = cross_link.startB endA = cross_link.endA endB = cross_link.endB if not self.is_in_bounds(startA) and not self.is_in_bounds(endA): return None if not self.is_in_bounds(startB) and not self.is_in_bounds(endB): return None if startA < self.start: startA = self.start if startB < self.start: startB = self.start if self.end < endA: endA = self.end if self.end < endB: endB = self.end trackobjA = cross_link._trackA(list(self._parent.tracks.values())) trackobjB = cross_link._trackB(list(self._parent.tracks.values())) assert trackobjA is not None assert trackobjB is not None if trackobjA == trackobjB: raise NotImplementedError if trackobjA.start is not None: if endA < trackobjA.start: return startA = max(startA, trackobjA.start) if trackobjA.end is not None: if trackobjA.end < startA: return endA = min(endA, trackobjA.end) if trackobjB.start is not None: if endB < trackobjB.start: return startB = max(startB, trackobjB.start) if trackobjB.end is not None: if trackobjB.end < startB: return endB = min(endB, trackobjB.end) for track_level in self._parent.get_drawn_levels(): track = self._parent[track_level] if track == trackobjA: trackA = track_level if track == trackobjB: trackB = track_level if trackA == trackB: raise NotImplementedError strokecolor, fillcolor = _stroke_and_fill_colors( cross_link.color, cross_link.border ) allowed_fragments = list(self.fragment_limits.keys()) start_fragmentA, start_offsetA = self.canvas_location(startA) end_fragmentA, end_offsetA = self.canvas_location(endA) if ( start_fragmentA not in allowed_fragments or end_fragmentA not in allowed_fragments ): return start_fragmentB, start_offsetB = self.canvas_location(startB) end_fragmentB, end_offsetB = self.canvas_location(endB) if ( start_fragmentB not in allowed_fragments or end_fragmentB not in allowed_fragments ): return # TODO - Better drawing of flips when split between fragments answer = [] for fragment in range( min(start_fragmentA, start_fragmentB), max(end_fragmentA, end_fragmentB) + 1 ): btmA, ctrA, topA = self.track_offsets[trackA] btmA += self.fragment_lines[fragment][0] ctrA += self.fragment_lines[fragment][0] topA += self.fragment_lines[fragment][0] btmB, ctrB, topB = self.track_offsets[trackB] btmB += self.fragment_lines[fragment][0] ctrB += self.fragment_lines[fragment][0] topB += self.fragment_lines[fragment][0] if self.fragment_limits[fragment][1] < endA: xAe = self.x0 + self.pagewidth crop_rightA = True else: xAe = self.x0 + end_offsetA crop_rightA = False if self.fragment_limits[fragment][1] < endB: xBe = self.x0 + self.pagewidth crop_rightB = True else: xBe = self.x0 + end_offsetB crop_rightB = False if fragment < start_fragmentA: xAs = self.x0 + self.pagewidth xAe = xAs crop_leftA = False elif fragment == start_fragmentA: xAs = self.x0 + start_offsetA crop_leftA = False else: xAs = self.x0 crop_leftA = True if fragment < start_fragmentB: xBs = self.x0 + self.pagewidth xBe = xBs crop_leftB = False elif fragment == start_fragmentB: xBs = self.x0 + start_offsetB crop_leftB = False else: xBs = self.x0 crop_leftB = True if ctrA < ctrB: yA = topA yB = btmB else: yA = btmA yB = topB if fragment < start_fragmentB or end_fragmentB < fragment: if cross_link.flip: # Just draw A as a triangle to left/right if fragment < start_fragmentB: extra = [self.x0 + self.pagewidth, 0.5 * (yA + yB)] else: extra = [self.x0, 0.5 * (yA + yB)] else: if fragment < start_fragmentB: extra = [ self.x0 + self.pagewidth, 0.7 * yA + 0.3 * yB, self.x0 + self.pagewidth, 0.3 * yA + 0.7 * yB, ] else: extra = [ self.x0, 0.3 * yA + 0.7 * yB, self.x0, 0.7 * yA + 0.3 * yB, ] answer.append( Polygon( deduplicate([xAs, yA, xAe, yA] + extra), strokeColor=strokecolor, fillColor=fillcolor, # default is mitre/miter which can stick out too much: strokeLineJoin=1, # 1=round strokewidth=0, ) ) elif fragment < start_fragmentA or end_fragmentA < fragment: if cross_link.flip: # Just draw B as a triangle to left if fragment < start_fragmentA: extra = [self.x0 + self.pagewidth, 0.5 * (yA + yB)] else: extra = [self.x0, 0.5 * (yA + yB)] else: if fragment < start_fragmentA: extra = [ self.x0 + self.pagewidth, 0.3 * yA + 0.7 * yB, self.x0 + self.pagewidth, 0.7 * yA + 0.3 * yB, ] else: extra = [ self.x0, 0.7 * yA + 0.3 * yB, self.x0, 0.3 * yA + 0.7 * yB, ] answer.append( Polygon( deduplicate([xBs, yB, xBe, yB] + extra), strokeColor=strokecolor, fillColor=fillcolor, # default is mitre/miter which can stick out too much: strokeLineJoin=1, # 1=round strokewidth=0, ) ) elif cross_link.flip and ( (crop_leftA and not crop_rightA) or (crop_leftB and not crop_rightB) ): # On left end of fragment... force "crossing" to margin answer.append( Polygon( deduplicate( [ xAs, yA, xAe, yA, self.x0, 0.5 * (yA + yB), xBe, yB, xBs, yB, ] ), strokeColor=strokecolor, fillColor=fillcolor, # default is mitre/miter which can stick out too much: strokeLineJoin=1, # 1=round strokewidth=0, ) ) elif cross_link.flip and ( (crop_rightA and not crop_leftA) or (crop_rightB and not crop_leftB) ): # On right end... force "crossing" to margin answer.append( Polygon( deduplicate( [ xAs, yA, xAe, yA, xBe, yB, xBs, yB, self.x0 + self.pagewidth, 0.5 * (yA + yB), ] ), strokeColor=strokecolor, fillColor=fillcolor, # default is mitre/miter which can stick out too much: strokeLineJoin=1, # 1=round strokewidth=0, ) ) elif cross_link.flip: answer.append( Polygon( deduplicate([xAs, yA, xAe, yA, xBs, yB, xBe, yB]), strokeColor=strokecolor, fillColor=fillcolor, # default is mitre/miter which can stick out too much: strokeLineJoin=1, # 1=round strokewidth=0, ) ) else: answer.append( Polygon( deduplicate([xAs, yA, xAe, yA, xBe, yB, xBs, yB]), strokeColor=strokecolor, fillColor=fillcolor, # default is mitre/miter which can stick out too much: strokeLineJoin=1, # 1=round strokewidth=0, ) ) return answer def get_feature_sigil(self, feature, x0, x1, fragment, **kwargs): """Get feature sigil. Arguments: - feature Feature object - x0 Start X coordinate on diagram - x1 End X coordinate on diagram - fragment The fragment on which the feature appears Returns a drawable indicator of the feature, and any required label for it. """ # Establish coordinates for drawing x0, x1 = self.x0 + x0, self.x0 + x1 btm, ctr, top = self.track_offsets[self.current_track_level] try: btm += self.fragment_lines[fragment][0] ctr += self.fragment_lines[fragment][0] top += self.fragment_lines[fragment][0] except Exception: # Only called if the method screws up big time print("We've got a screw-up") print(f"{self.start} {self.end}") print(self.fragment_bases) print(f"{x0!r} {x1!r}") for locstart, locend in feature.locations: print(self.canvas_location(locstart)) print(self.canvas_location(locend)) print(f"FEATURE\n{feature}") raise # Distribution dictionary for various ways of drawing the feature draw_methods = { "BOX": self._draw_sigil_box, "ARROW": self._draw_sigil_arrow, "BIGARROW": self._draw_sigil_big_arrow, "OCTO": self._draw_sigil_octo, "JAGGY": self._draw_sigil_jaggy, } method = draw_methods[feature.sigil] kwargs["head_length_ratio"] = feature.arrowhead_length kwargs["shaft_height_ratio"] = feature.arrowshaft_height # Support for clickable links... needs ReportLab 2.4 or later # which added support for links in SVG output. if hasattr(feature, "url"): kwargs["hrefURL"] = feature.url kwargs["hrefTitle"] = feature.name # Get sigil for the feature, give it the bounding box straddling # the axis (it decides strand specific placement) sigil = method( btm, ctr, top, x0, x1, strand=feature.location.strand, color=feature.color, border=feature.border, **kwargs, ) if feature.label_strand: strand = feature.label_strand else: strand = feature.location.strand if feature.label: # Feature requires a label label = String( 0, 0, feature.name, fontName=feature.label_font, fontSize=feature.label_size, fillColor=feature.label_color, ) labelgroup = Group(label) # Feature is on top, or covers both strands (location affects # the height and rotation of the label) if strand != -1: rotation = angle2trig(feature.label_angle) if feature.label_position in ("end", "3'", "right"): pos = x1 elif feature.label_position in ("middle", "center", "centre"): pos = (x1 + x0) / 2.0 else: # Default to start, i.e. 'start', "5'", 'left' pos = x0 labelgroup.transform = ( rotation[0], rotation[1], rotation[2], rotation[3], pos, top, ) else: # Feature on bottom strand rotation = angle2trig(feature.label_angle + 180) if feature.label_position in ("end", "3'", "right"): pos = x0 elif feature.label_position in ("middle", "center", "centre"): pos = (x1 + x0) / 2.0 else: # Default to start, i.e. 'start', "5'", 'left' pos = x1 labelgroup.transform = ( rotation[0], rotation[1], rotation[2], rotation[3], pos, btm, ) else: labelgroup = None return sigil, labelgroup def draw_graph_set(self, set): """Draw graph set. Arguments: - set GraphSet object Returns tuple (list of graph elements, list of graph labels). """ # print('draw graph set') elements = [] # Holds graph elements # Distribution dictionary for how to draw the graph style_methods = { "line": self.draw_line_graph, "heat": self.draw_heat_graph, "bar": self.draw_bar_graph, } for graph in set.get_graphs(): elements += style_methods[graph.style](graph) return elements, [] def draw_line_graph(self, graph): """Return a line graph as a list of drawable elements. Arguments: - graph Graph object """ # print('\tdraw_line_graph') line_elements = [] # Holds drawable elements # Get graph data data_quartiles = graph.quartiles() minval, maxval = data_quartiles[0], data_quartiles[4] btm, ctr, top = self.track_offsets[self.current_track_level] trackheight = 0.5 * (top - btm) datarange = maxval - minval if datarange == 0: datarange = trackheight start, end = self._current_track_start_end() data = graph[start:end] # midval is the value at which the x-axis is plotted, and is the # central ring in the track if graph.center is None: midval = (maxval + minval) / 2.0 else: midval = graph.center # Whichever is the greatest difference: max-midval or min-midval, is # taken to specify the number of pixel units resolved along the # y-axis resolution = max((midval - minval), (maxval - midval)) # Start from first data point pos, val = data[0] lastfrag, lastx = self.canvas_location(pos) lastx += self.x0 # Start xy co-ords lasty = ( trackheight * (val - midval) / resolution + self.fragment_lines[lastfrag][0] + ctr ) lastval = val # Add a series of lines linking consecutive data points for pos, val in data: frag, x = self.canvas_location(pos) x += self.x0 # next xy co-ords y = ( trackheight * (val - midval) / resolution + self.fragment_lines[frag][0] + ctr ) if frag == lastfrag: # Points on the same fragment: draw the line line_elements.append( Line( lastx, lasty, x, y, strokeColor=graph.poscolor, strokeWidth=graph.linewidth, ) ) else: # Points not on the same fragment, so interpolate tempy = ( trackheight * (val - midval) / resolution + self.fragment_lines[lastfrag][0] + ctr ) line_elements.append( Line( lastx, lasty, self.xlim, tempy, strokeColor=graph.poscolor, strokeWidth=graph.linewidth, ) ) tempy = ( trackheight * (val - midval) / resolution + self.fragment_lines[frag][0] + ctr ) line_elements.append( Line( self.x0, tempy, x, y, strokeColor=graph.poscolor, strokeWidth=graph.linewidth, ) ) lastfrag, lastx, lasty, lastval = frag, x, y, val return line_elements def draw_heat_graph(self, graph): """Return a list of drawable elements for the heat graph.""" # print('\tdraw_heat_graph') # At each point contained in the graph data, we draw a box that is the # full height of the track, extending from the midpoint between the # previous and current data points to the midpoint between the current # and next data points heat_elements = [] # Holds drawable elements for the graph # Get graph data and information data_quartiles = graph.quartiles() minval, maxval = data_quartiles[0], data_quartiles[4] midval = (maxval + minval) / 2.0 # mid is the value at the X-axis btm, ctr, top = self.track_offsets[self.current_track_level] trackheight = top - btm start, end = self._current_track_start_end() data = intermediate_points(start, end, graph[start:end]) if not data: return [] # Create elements on the graph, indicating a large positive value by # the graph's poscolor, and a large negative value by the graph's # negcolor attributes for pos0, pos1, val in data: # assert start <= pos0 <= pos1 <= end fragment0, x0 = self.canvas_location(pos0) fragment1, x1 = self.canvas_location(pos1) x0, x1 = self.x0 + x0, self.x0 + x1 # account for margin # print('x1 before:', x1) # Calculate the heat color, based on the differential between # the value and the median value heat = colors.linearlyInterpolatedColor( graph.poscolor, graph.negcolor, maxval, minval, val ) # Draw heat box if fragment0 == fragment1: # Box is contiguous on one fragment if pos1 >= self.fragment_limits[fragment0][1]: x1 = self.xlim ttop = top + self.fragment_lines[fragment0][0] tbtm = btm + self.fragment_lines[fragment0][0] # print('equal', pos0, pos1, val) # print(pos0, pos1, fragment0, fragment1) heat_elements.append( draw_box((x0, tbtm), (x1, ttop), color=heat, border=None) ) else: # box is split over two or more fragments # if pos0 >= self.fragment_limits[fragment0][0]: # fragment0 += 1 fragment = fragment0 start_x = x0 while self.fragment_limits[fragment][1] <= pos1: # print(pos0, self.fragment_limits[fragment][1], pos1) ttop = top + self.fragment_lines[fragment][0] tbtm = btm + self.fragment_lines[fragment][0] heat_elements.append( draw_box( (start_x, tbtm), (self.xlim, ttop), color=heat, border=None ) ) fragment += 1 start_x = self.x0 ttop = top + self.fragment_lines[fragment][0] tbtm = btm + self.fragment_lines[fragment][0] # Add the last part of the bar # print('x1 after:', x1, '\n') heat_elements.append( draw_box((self.x0, tbtm), (x1, ttop), color=heat, border=None) ) return heat_elements def draw_bar_graph(self, graph): """Return list of drawable elements for a bar graph.""" # print('\tdraw_bar_graph') # At each point contained in the graph data, we draw a vertical bar # from the track center to the height of the datapoint value (positive # values go up in one color, negative go down in the alternative # color). bar_elements = [] # Holds drawable elements for the graph # Set the number of pixels per unit for the data data_quartiles = graph.quartiles() minval, maxval = data_quartiles[0], data_quartiles[4] btm, ctr, top = self.track_offsets[self.current_track_level] trackheight = 0.5 * (top - btm) datarange = maxval - minval if datarange == 0: datarange = trackheight data = graph[self.start : self.end] # midval is the value at which the x-axis is plotted, and is the # central ring in the track if graph.center is None: midval = (maxval + minval) / 2.0 else: midval = graph.center # Convert data into 'binned' blocks, covering half the distance to the # next data point on either side, accounting for the ends of fragments # and tracks start, end = self._current_track_start_end() data = intermediate_points(start, end, graph[start:end]) if not data: return [] # Whichever is the greatest difference: max-midval or min-midval, is # taken to specify the number of pixel units resolved along the # y-axis resolution = max((midval - minval), (maxval - midval)) if resolution == 0: resolution = trackheight # Create elements for the bar graph based on newdata for pos0, pos1, val in data: fragment0, x0 = self.canvas_location(pos0) fragment1, x1 = self.canvas_location(pos1) x0, x1 = self.x0 + x0, self.x0 + x1 # account for margin barval = trackheight * (val - midval) / resolution if barval >= 0: # Different colors for bars that extend above... barcolor = graph.poscolor else: # ...or below the axis barcolor = graph.negcolor # Draw bar if fragment0 == fragment1: # Box is contiguous if pos1 >= self.fragment_limits[fragment0][1]: x1 = self.xlim tctr = ctr + self.fragment_lines[fragment0][0] barval += tctr bar_elements.append(draw_box((x0, tctr), (x1, barval), color=barcolor)) else: # Box is split over two or more fragments fragment = fragment0 # if pos0 >= self.fragment_limits[fragment0][0]: # fragment += 1 start = x0 while self.fragment_limits[fragment][1] < pos1: tctr = ctr + self.fragment_lines[fragment][0] thisbarval = barval + tctr bar_elements.append( draw_box((start, tctr), (self.xlim, thisbarval), color=barcolor) ) fragment += 1 start = self.x0 tctr = ctr + self.fragment_lines[fragment1][0] barval += tctr # Add the last part of the bar bar_elements.append( draw_box((self.x0, tctr), (x1, barval), color=barcolor) ) return bar_elements def canvas_location(self, base): """Canvas location of a base on the genome. Arguments: - base The base number on the genome sequence Returns the x-coordinate and fragment number of a base on the genome sequence, in the context of the current drawing setup """ base = int(base - self.start) # number of bases we are from the start fragment = int(base / self.fragment_bases) if fragment < 1: # First fragment base_offset = base fragment = 0 elif fragment >= self.fragments: fragment = self.fragments - 1 base_offset = self.fragment_bases else: # Calculate number of bases from start of fragment base_offset = base % self.fragment_bases assert fragment < self.fragments, ( base, self.start, self.end, self.length, self.fragment_bases, ) # Calculate number of pixels from start of fragment x_offset = self.pagewidth * base_offset / self.fragment_bases return fragment, x_offset def _draw_sigil_box(self, bottom, center, top, x1, x2, strand, **kwargs): """Draw BOX sigil (PRIVATE).""" if strand == 1: y1 = center y2 = top elif strand == -1: y1 = bottom y2 = center else: y1 = bottom y2 = top return draw_box((x1, y1), (x2, y2), **kwargs) def _draw_sigil_octo(self, bottom, center, top, x1, x2, strand, **kwargs): """Draw OCTO sigil, a box with the corners cut off (PRIVATE).""" if strand == 1: y1 = center y2 = top elif strand == -1: y1 = bottom y2 = center else: y1 = bottom y2 = top return draw_cut_corner_box((x1, y1), (x2, y2), **kwargs) def _draw_sigil_jaggy( self, bottom, center, top, x1, x2, strand, color, border=None, **kwargs ): """Draw JAGGY sigil (PRIVATE). Although we may in future expose the head/tail jaggy lengths, for now both the left and right edges are drawn jagged. """ if strand == 1: y1 = center y2 = top teeth = 2 elif strand == -1: y1 = bottom y2 = center teeth = 2 else: y1 = bottom y2 = top teeth = 4 xmin = min(x1, x2) xmax = max(x1, x2) height = y2 - y1 boxwidth = x2 - x1 tooth_length = min(height / teeth, boxwidth * 0.5) headlength = tooth_length taillength = tooth_length strokecolor, color = _stroke_and_fill_colors(color, border) points = [] for i in range(teeth): points.extend( ( xmin, y1 + i * height / teeth, xmin + taillength, y1 + (i + 1) * height / teeth, ) ) for i in range(teeth): points.extend( ( xmax, y1 + (teeth - i) * height / teeth, xmax - headlength, y1 + (teeth - i - 1) * height / teeth, ) ) return Polygon( deduplicate(points), strokeColor=strokecolor, strokeWidth=1, strokeLineJoin=1, # 1=round fillColor=color, **kwargs, ) def _draw_sigil_arrow(self, bottom, center, top, x1, x2, strand, **kwargs): """Draw ARROW sigil (PRIVATE).""" if strand == 1: y1 = center y2 = top orientation = "right" elif strand == -1: y1 = bottom y2 = center orientation = "left" else: y1 = bottom y2 = top orientation = "right" # backward compatibility return draw_arrow((x1, y1), (x2, y2), orientation=orientation, **kwargs) def _draw_sigil_big_arrow(self, bottom, center, top, x1, x2, strand, **kwargs): """Draw BIGARROW sigil, like ARROW but straddles the axis (PRIVATE).""" if strand == -1: orientation = "left" else: orientation = "right" return draw_arrow((x1, bottom), (x2, top), orientation=orientation, **kwargs)