# Copyright 2003-2008 by Leighton Pritchard. All rights reserved. # Revisions copyright 2008-2017 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 ################################################################################ """CircularDrawer module for GenomeDiagram.""" from math import cos from math import pi from math import sin from reportlab.graphics.shapes import ArcPath from reportlab.graphics.shapes import Circle 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 draw_polygon from ._AbstractDrawer import intermediate_points from ._FeatureSet import FeatureSet from ._GraphSet import GraphSet class CircularDrawer(AbstractDrawer): """Object for drawing circular diagrams. Attributes: - tracklines Boolean for whether to draw lines dilineating 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 Size of sequence to be drawn - 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 - 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 - sweep Float (0->1) the proportion of the circle circumference to use for the diagram - 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, track_size=0.75, circular=1, circle_core=0.0, cross_track_links=None, ): """Create CircularDrawer object. 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 - track_size The proportion of the available track height that should be taken up in drawing - circular Boolean flaw to show whether the passed sequence is circular or not - circle_core The proportion of the available radius to leave empty at the center of a circular diagram (0 to 1). - 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.track_size = track_size self.circle_core = circle_core # Determine proportion of circumference around which information will be drawn if not circular: self.sweep = 0.9 else: self.sweep = 1.0 def set_track_heights(self): """Initialize track heights. Since tracks may not be of identical heights, the bottom and top radius for each track is stored in a dictionary - self.track_radii, keyed by track number """ bot_track = min(min(self.drawn_tracks), 1) top_track = max(self.drawn_tracks) # The 'highest' track to draw trackunit_sum = 0 # Total number of 'units' taken up by all tracks trackunits = {} # Start and & units for each track keyed by track number heightholder = 0 # placeholder variable for track in range(bot_track, top_track + 1): # track numbers to 'draw' try: trackheight = self._parent[track].height # Get track height except Exception: # TODO: ValueError? IndexError? trackheight = 1 trackunit_sum += trackheight # increment total track unit height trackunits[track] = (heightholder, heightholder + trackheight) heightholder += trackheight # move to next height max_radius = 0.5 * min(self.pagewidth, self.pageheight) trackunit_height = max_radius * (1 - self.circle_core) / trackunit_sum track_core = max_radius * self.circle_core # Calculate top and bottom radii for each track self.track_radii = {} # The inner, outer and center radii for each track track_crop = ( trackunit_height * (1 - self.track_size) / 2.0 ) # 'step back' in pixels for track in trackunits: top = trackunits[track][1] * trackunit_height - track_crop + track_core btm = trackunits[track][0] * trackunit_height + track_crop + track_core ctr = btm + (top - btm) / 2.0 self.track_radii[track] = (btm, ctr, top) def draw(self): """Draw a circular diagram of the stored data.""" # 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 tracks to be drawn and set track sizes self.drawn_tracks = self._parent.get_drawn_levels() 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._parent.get_drawn_levels(): self.current_track_level = track_level track = self._parent[track_level] gbgs, glabels = self.draw_greytrack(track) # Greytracks greytrack_bgs.append(gbgs) greytrack_labels.append(glabels) features, flabels = self.draw_track(track) # Features and graphs feature_elements.append(features) feature_labels.append(flabels) if track.scale: axes, slabels = self.draw_scale(track) # Scale axes 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 draw_track(self, track): """Return list of track elements and list of track labels.""" track_elements = [] # Holds elements for features and graphs track_labels = [] # Holds labels for 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_feature_set(self, set): """Return list of feature elements and list of labels for them.""" # 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) feature_elements += features label_elements += labels return feature_elements, label_elements def draw_feature(self, feature): """Return list of feature elements and list of labels for them.""" feature_elements = [] # Holds drawable elements for a single feature label_elements = [] # Holds labels for a single feature if feature.hide: # Don't show feature: return early return feature_elements, label_elements 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) # Get sigil for the feature/ each subfeature feature_sigil, label = self.get_feature_sigil(feature, locstart, locend) feature_elements.append(feature_sigil) if label is not None: # If there's a label label_elements.append(label) return feature_elements, label_elements def get_feature_sigil(self, feature, locstart, locend, **kwargs): """Return graphics for feature, and any required label for it. Arguments: - feature Feature object - locstart The start position of the feature - locend The end position of the feature """ # Establish the coordinates for the sigil btm, ctr, top = self.track_radii[self.current_track_level] startangle, startcos, startsin = self.canvas_angle(locstart) endangle, endcos, endsin = self.canvas_angle(locend) midangle, midcos, midsin = self.canvas_angle((locend + locstart) / 2) # Distribution dictionary for various ways of drawing the feature # Each method takes the inner and outer radii, the start and end angle # subtended at the diagram center, and the color as arguments draw_methods = { "BOX": self._draw_sigil_box, "OCTO": self._draw_sigil_cut_corner_box, "JAGGY": self._draw_sigil_jaggy, "ARROW": self._draw_sigil_arrow, "BIGARROW": self._draw_sigil_big_arrow, } # Get sigil for the feature, location dependent on the feature strand 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 sigil = method( btm, ctr, top, startangle, endangle, feature.location.strand, color=feature.color, border=feature.border, **kwargs, ) if feature.label: # Feature needs a label # The spaces are a hack to force a little space between the label # and the edge of the feature label = String( 0, 0, f" {feature.name.strip()} ", fontName=feature.label_font, fontSize=feature.label_size, fillColor=feature.label_color, ) labelgroup = Group(label) if feature.label_strand: strand = feature.label_strand else: strand = feature.location.strand if feature.label_position in ("start", "5'", "left"): # Position the label at the feature's start if strand != -1: label_angle = startangle + 0.5 * pi # Make text radial sinval, cosval = startsin, startcos else: label_angle = endangle + 0.5 * pi # Make text radial sinval, cosval = endsin, endcos elif feature.label_position in ("middle", "center", "centre"): # Position the label at the feature's midpoint label_angle = midangle + 0.5 * pi # Make text radial sinval, cosval = midsin, midcos elif feature.label_position in ("end", "3'", "right"): # Position the label at the feature's end if strand != -1: label_angle = endangle + 0.5 * pi # Make text radial sinval, cosval = endsin, endcos else: label_angle = startangle + 0.5 * pi # Make text radial sinval, cosval = startsin, startcos elif startangle < pi: # Default to placing the label the bottom of the feature # as drawn on the page, meaning feature end on left half label_angle = endangle + 0.5 * pi # Make text radial sinval, cosval = endsin, endcos else: # Default to placing the label on the bottom of the feature, # which means the feature end when on right hand half label_angle = startangle + 0.5 * pi # Make text radial sinval, cosval = startsin, startcos if strand != -1: # Feature label on top radius = top if startangle < pi: # Turn text round label_angle -= pi else: labelgroup.contents[0].textAnchor = "end" else: # Feature label on bottom radius = btm if startangle < pi: # Turn text round and anchor end label_angle -= pi labelgroup.contents[0].textAnchor = "end" x_pos = self.xcenter + radius * sinval y_pos = self.ycenter + radius * cosval coslabel = cos(label_angle) sinlabel = sin(label_angle) labelgroup.transform = ( coslabel, -sinlabel, sinlabel, coslabel, x_pos, y_pos, ) else: # No label required labelgroup = None # if locstart > locend: # print(locstart, locend, feature.location.strand, sigil, feature.name) # print(locstart, locend, feature.name) return sigil, labelgroup def draw_cross_link(self, cross_link): """Draw a cross-link between 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 startangleA, startcosA, startsinA = self.canvas_angle(startA) startangleB, startcosB, startsinB = self.canvas_angle(startB) endangleA, endcosA, endsinA = self.canvas_angle(endA) endangleB, endcosB, endsinB = self.canvas_angle(endB) btmA, ctrA, topA = self.track_radii[trackA] btmB, ctrB, topB = self.track_radii[trackB] if ctrA < ctrB: return [ self._draw_arc_poly( topA, btmB, startangleA, endangleA, startangleB, endangleB, cross_link.color, cross_link.border, cross_link.flip, ) ] else: return [ self._draw_arc_poly( btmA, topB, startangleA, endangleA, startangleB, endangleB, cross_link.color, cross_link.border, cross_link.flip, ) ] def draw_graph_set(self, set): """Return list of graph elements and list of their labels. Arguments: - set GraphSet object """ # 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 line graph as list of drawable elements. Arguments: - graph GraphData object """ 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_radii[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] if not data: return [] # 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] lastangle, lastcos, lastsin = self.canvas_angle(pos) # We calculate the track height posheight = trackheight * (val - midval) / resolution + ctr lastx = self.xcenter + posheight * lastsin # start xy coords lasty = self.ycenter + posheight * lastcos for pos, val in data: posangle, poscos, possin = self.canvas_angle(pos) posheight = trackheight * (val - midval) / resolution + ctr x = self.xcenter + posheight * possin # next xy coords y = self.ycenter + posheight * poscos line_elements.append( Line( lastx, lasty, x, y, strokeColor=graph.poscolor, strokeWidth=graph.linewidth, ) ) lastx, lasty = x, y return line_elements def draw_bar_graph(self, graph): """Return list of drawable elements for a bar graph. Arguments: - graph Graph object """ # 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 = [] # 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_radii[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: pos0angle, pos0cos, pos0sin = self.canvas_angle(pos0) pos1angle, pos1cos, pos1sin = self.canvas_angle(pos1) barval = trackheight * (val - midval) / resolution if barval >= 0: barcolor = graph.poscolor else: barcolor = graph.negcolor # Draw bar bar_elements.append( self._draw_arc(ctr, ctr + barval, pos0angle, pos1angle, barcolor) ) return bar_elements def draw_heat_graph(self, graph): """Return list of drawable elements for the heat graph. Arguments: - graph Graph object """ # 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 # Get graph data 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_radii[self.current_track_level] trackheight = top - btm start, end = self._current_track_start_end() data = intermediate_points(start, end, graph[start:end]) # 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: pos0angle, pos0cos, pos0sin = self.canvas_angle(pos0) pos1angle, pos1cos, pos1sin = self.canvas_angle(pos1) # 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 heat_elements.append( self._draw_arc(btm, top, pos0angle, pos1angle, heat, border=heat) ) return heat_elements def draw_scale(self, track): """Return list of elements in the scale and list of their labels. Arguments: - track Track object """ scale_elements = [] # holds axes and ticks scale_labels = [] # holds labels if not track.scale: # no scale required, exit early return [], [] # Get track locations btm, ctr, top = self.track_radii[self.current_track_level] trackheight = top - ctr # X-axis start, end = self._current_track_start_end() if track.start is not None or track.end is not None: # Draw an arc, leaving out the wedge p = ArcPath(strokeColor=track.scale_color, fillColor=None) startangle, startcos, startsin = self.canvas_angle(start) endangle, endcos, endsin = self.canvas_angle(end) p.addArc( self.xcenter, self.ycenter, ctr, 90 - (endangle * 180 / pi), 90 - (startangle * 180 / pi), ) scale_elements.append(p) del p # Y-axis start marker x0, y0 = self.xcenter + btm * startsin, self.ycenter + btm * startcos x1, y1 = self.xcenter + top * startsin, self.ycenter + top * startcos scale_elements.append(Line(x0, y0, x1, y1, strokeColor=track.scale_color)) # Y-axis end marker x0, y0 = self.xcenter + btm * endsin, self.ycenter + btm * endcos x1, y1 = self.xcenter + top * endsin, self.ycenter + top * endcos scale_elements.append(Line(x0, y0, x1, y1, strokeColor=track.scale_color)) elif self.sweep < 1: # Draw an arc, leaving out the wedge p = ArcPath(strokeColor=track.scale_color, fillColor=None) # Note reportlab counts angles anti-clockwise from the horizontal # (as in mathematics, e.g. complex numbers and polar coordinates) # in degrees. p.addArc( self.xcenter, self.ycenter, ctr, startangledegrees=90 - 360 * self.sweep, endangledegrees=90, ) scale_elements.append(p) del p # Y-axis start marker x0, y0 = self.xcenter, self.ycenter + btm x1, y1 = self.xcenter, self.ycenter + top scale_elements.append(Line(x0, y0, x1, y1, strokeColor=track.scale_color)) # Y-axis end marker alpha = 2 * pi * self.sweep x0, y0 = self.xcenter + btm * sin(alpha), self.ycenter + btm * cos(alpha) x1, y1 = self.xcenter + top * sin(alpha), self.ycenter + top * cos(alpha) scale_elements.append(Line(x0, y0, x1, y1, strokeColor=track.scale_color)) else: # Draw a full circle scale_elements.append( Circle( self.xcenter, self.ycenter, ctr, strokeColor=track.scale_color, fillColor=None, ) ) 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 # at 60 degree intervals, ordering the labels by graph_id startangle, startcos, startsin = self.canvas_angle(start) endangle, endcos, endsin = self.canvas_angle(end) if track.axis_labels: for set in track.get_sets(): if set.__class__ is GraphSet: # Y-axis for n in range(7): angle = n * 1.0471975511965976 if angle < startangle or endangle < angle: continue ticksin, tickcos = sin(angle), cos(angle) x0, y0 = ( self.xcenter + btm * ticksin, self.ycenter + btm * tickcos, ) x1, y1 = ( self.xcenter + top * ticksin, self.ycenter + top * tickcos, ) scale_elements.append( Line(x0, y0, x1, y1, strokeColor=track.scale_color) ) graph_label_min = [] graph_label_max = [] graph_label_mid = [] 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}") graph_label_mid.append(f"{midval:.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}") xmid, ymid = (x0 + x1) / 2.0, (y0 + y1) / 2.0 for limit, x, y in [ (graph_label_min, x0, y0), (graph_label_max, x1, y1), (graph_label_mid, xmid, ymid), ]: label = String( 0, 0, ";".join(limit), fontName=track.scale_font, fontSize=track.scale_fontsize, fillColor=track.scale_color, ) label.textAnchor = "middle" labelgroup = Group(label) labelgroup.transform = ( tickcos, -ticksin, ticksin, tickcos, x, y, ) scale_labels.append(labelgroup) return scale_elements, scale_labels def draw_tick(self, tickpos, ctr, ticklen, track, draw_label): """Return drawing element for a tick on the scale. 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? """ # Calculate tick coordinates tickangle, tickcos, ticksin = self.canvas_angle(tickpos) x0, y0 = self.xcenter + ctr * ticksin, self.ycenter + ctr * tickcos x1, y1 = ( self.xcenter + (ctr + ticklen) * ticksin, self.ycenter + (ctr + ticklen) * tickcos, ) # Calculate height of text label so it can be offset on lower half # of diagram # LP: not used, as not all fonts have ascent_descent data in reportlab.pdfbase._fontdata # label_offset = _fontdata.ascent_descent[track.scale_font][0]*\ # track.scale_fontsize/1000. tick = Line(x0, y0, x1, y1, 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, ) if tickangle > pi: label.textAnchor = "end" # LP: This label_offset depends on ascent_descent data, which is not available for all # fonts, so has been deprecated. # if 0.5*pi < tickangle < 1.5*pi: # y1 -= label_offset labelgroup = Group(label) labelgroup.transform = (1, 0, 0, 1, x1, y1) else: labelgroup = None return tick, labelgroup def draw_test_tracks(self): """Draw blue test tracks with grene line down their center.""" # Add lines only for drawn tracks for track in self.drawn_tracks: btm, ctr, top = self.track_radii[track] self.drawing.add( Circle( self.xcenter, self.ycenter, top, strokeColor=colors.blue, fillColor=None, ) ) # top line self.drawing.add( Circle( self.xcenter, self.ycenter, ctr, strokeColor=colors.green, fillColor=None, ) ) # middle line self.drawing.add( Circle( self.xcenter, self.ycenter, btm, strokeColor=colors.blue, fillColor=None, ) ) # bottom line def draw_greytrack(self, track): """Drawing element for grey background to passed Track object.""" greytrack_bgs = [] # Holds track backgrounds greytrack_labels = [] # Holds track foreground labels if not track.greytrack: # No greytrack required, return early return [], [] # Get track location btm, ctr, top = self.track_radii[self.current_track_level] start, end = self._current_track_start_end() startangle, startcos, startsin = self.canvas_angle(start) endangle, endcos, endsin = self.canvas_angle(end) # Make background if track.start is not None or track.end is not None: # Draw an arc, leaving out the wedge p = ArcPath(strokeColor=track.scale_color, fillColor=None) greytrack_bgs.append( self._draw_arc( btm, top, startangle, endangle, colors.Color(0.96, 0.96, 0.96) ) ) elif self.sweep < 1: # Make a partial circle, a large arc box # This method assumes the correct center for us. greytrack_bgs.append( self._draw_arc( btm, top, 0, 2 * pi * self.sweep, colors.Color(0.96, 0.96, 0.96) ) ) else: # Make a full circle (using a VERY thick linewidth) greytrack_bgs.append( Circle( self.xcenter, self.ycenter, ctr, strokeColor=colors.Color(0.96, 0.96, 0.96), fillColor=None, strokeWidth=top - btm, ) ) if track.greytrack_labels: # Labels are required for this track labelstep = self.length // track.greytrack_labels # label interval for pos in range(self.start, self.end, labelstep): label = String( 0, 0, track.name, # Add a new label at fontName=track.greytrack_font, # each interval fontSize=track.greytrack_fontsize, fillColor=track.greytrack_fontcolor, ) theta, costheta, sintheta = self.canvas_angle(pos) if theta < startangle or endangle < theta: continue x, y = ( self.xcenter + btm * sintheta, self.ycenter + btm * costheta, ) # start text halfway up marker labelgroup = Group(label) labelangle = ( self.sweep * 2 * pi * (pos - self.start) / self.length - pi / 2 ) if theta > pi: label.textAnchor = "end" # Anchor end of text to inner radius labelangle += pi # and reorient it cosA, sinA = cos(labelangle), sin(labelangle) labelgroup.transform = (cosA, -sinA, sinA, cosA, x, y) if not self.length - x <= labelstep: # Don't overrun the circle greytrack_labels.append(labelgroup) return greytrack_bgs, greytrack_labels def canvas_angle(self, base): """Given base-pair position, return (angle, cosine, sin) (PRIVATE).""" angle = self.sweep * 2 * pi * (base - self.start) / self.length return (angle, cos(angle), sin(angle)) def _draw_sigil_box( self, bottom, center, top, startangle, endangle, strand, **kwargs ): """Draw BOX sigil (PRIVATE).""" if strand == 1: inner_radius = center outer_radius = top elif strand == -1: inner_radius = bottom outer_radius = center else: inner_radius = bottom outer_radius = top return self._draw_arc( inner_radius, outer_radius, startangle, endangle, **kwargs ) def _draw_arc( self, inner_radius, outer_radius, startangle, endangle, color, border=None, colour=None, **kwargs, ): """Return closed path describing an arc box (PRIVATE). Arguments: - inner_radius Float distance of inside of arc from drawing center - outer_radius Float distance of outside of arc from drawing center - startangle Float angle subtended by start of arc at drawing center (in radians) - endangle Float angle subtended by end of arc at drawing center (in radians) - color colors.Color object for arc (overridden by backwards compatible argument with UK spelling, colour). Returns a closed path object describing an arced box corresponding to the passed values. For very small angles, a simple four sided polygon is used. """ # Let the UK spelling (colour) override the USA spelling (color) if colour is not None: color = colour strokecolor, color = _stroke_and_fill_colors(color, border) if abs(endangle - startangle) > 0.01: # Wide arc, must use full curves p = ArcPath(strokeColor=strokecolor, fillColor=color, strokewidth=0) # Note reportlab counts angles anti-clockwise from the horizontal # (as in mathematics, e.g. complex numbers and polar coordinates) # but we use clockwise from the vertical. Also reportlab uses # degrees, but we use radians. p.addArc( self.xcenter, self.ycenter, inner_radius, 90 - (endangle * 180 / pi), 90 - (startangle * 180 / pi), moveTo=True, ) p.addArc( self.xcenter, self.ycenter, outer_radius, 90 - (endangle * 180 / pi), 90 - (startangle * 180 / pi), reverse=True, ) p.closePath() return p else: # Cheat and just use a four sided polygon. # Calculate trig values for angle and coordinates startcos, startsin = cos(startangle), sin(startangle) endcos, endsin = cos(endangle), sin(endangle) x0, y0 = self.xcenter, self.ycenter # origin of the circle x1, y1 = (x0 + inner_radius * startsin, y0 + inner_radius * startcos) x2, y2 = (x0 + inner_radius * endsin, y0 + inner_radius * endcos) x3, y3 = (x0 + outer_radius * endsin, y0 + outer_radius * endcos) x4, y4 = (x0 + outer_radius * startsin, y0 + outer_radius * startcos) return draw_polygon([(x1, y1), (x2, y2), (x3, y3), (x4, y4)], color, border) def _draw_arc_line( self, path, start_radius, end_radius, start_angle, end_angle, move=False ): """Add a list of points to a path object (PRIVATE). Assumes angles given are in degrees! Represents what would be a straight line on a linear diagram. """ x0, y0 = self.xcenter, self.ycenter # origin of the circle radius_diff = end_radius - start_radius angle_diff = end_angle - start_angle dx = 0.01 # heuristic a = start_angle * pi / 180 if move: path.moveTo(x0 + start_radius * cos(a), y0 + start_radius * sin(a)) else: path.lineTo(x0 + start_radius * cos(a), y0 + start_radius * sin(a)) x = dx if 0.01 <= abs(dx): while x < 1: r = start_radius + x * radius_diff a = ( (start_angle + x * (angle_diff)) * pi / 180 ) # to radians for sin/cos # print(x0+r*cos(a), y0+r*sin(a)) path.lineTo(x0 + r * cos(a), y0 + r * sin(a)) x += dx a = end_angle * pi / 180 path.lineTo(x0 + end_radius * cos(a), y0 + end_radius * sin(a)) def _draw_arc_poly( self, inner_radius, outer_radius, inner_startangle, inner_endangle, outer_startangle, outer_endangle, color, border=None, flip=False, **kwargs, ): """Return polygon path describing an arc.""" strokecolor, color = _stroke_and_fill_colors(color, border) x0, y0 = self.xcenter, self.ycenter # origin of the circle if ( abs(inner_endangle - outer_startangle) > 0.01 or abs(outer_endangle - inner_startangle) > 0.01 or abs(inner_startangle - outer_startangle) > 0.01 or abs(outer_startangle - outer_startangle) > 0.01 ): # Wide arc, must use full curves p = ArcPath( strokeColor=strokecolor, fillColor=color, # default is mitre/miter which can stick out too much: strokeLineJoin=1, # 1=round strokewidth=0, ) # Note reportlab counts angles anti-clockwise from the horizontal # (as in mathematics, e.g. complex numbers and polar coordinates) # but we use clockwise from the vertical. Also reportlab uses # degrees, but we use radians. i_start = 90 - (inner_startangle * 180 / pi) i_end = 90 - (inner_endangle * 180 / pi) o_start = 90 - (outer_startangle * 180 / pi) o_end = 90 - (outer_endangle * 180 / pi) p.addArc(x0, y0, inner_radius, i_end, i_start, moveTo=True, reverse=True) if flip: # Flipped, join end to start, self._draw_arc_line(p, inner_radius, outer_radius, i_end, o_start) p.addArc(x0, y0, outer_radius, o_end, o_start, reverse=True) self._draw_arc_line(p, outer_radius, inner_radius, o_end, i_start) else: # Not flipped, join start to start, end to end self._draw_arc_line(p, inner_radius, outer_radius, i_end, o_end) p.addArc(x0, y0, outer_radius, o_end, o_start, reverse=False) self._draw_arc_line(p, outer_radius, inner_radius, o_start, i_start) p.closePath() return p else: # Cheat and just use a four sided polygon. # Calculate trig values for angle and coordinates inner_startcos, inner_startsin = ( cos(inner_startangle), sin(inner_startangle), ) inner_endcos, inner_endsin = cos(inner_endangle), sin(inner_endangle) outer_startcos, outer_startsin = ( cos(outer_startangle), sin(outer_startangle), ) outer_endcos, outer_endsin = cos(outer_endangle), sin(outer_endangle) x1, y1 = ( x0 + inner_radius * inner_startsin, y0 + inner_radius * inner_startcos, ) x2, y2 = ( x0 + inner_radius * inner_endsin, y0 + inner_radius * inner_endcos, ) x3, y3 = ( x0 + outer_radius * outer_endsin, y0 + outer_radius * outer_endcos, ) x4, y4 = ( x0 + outer_radius * outer_startsin, y0 + outer_radius * outer_startcos, ) return draw_polygon( [(x1, y1), (x2, y2), (x3, y3), (x4, y4)], color, border, # default is mitre/miter which can stick out too much: strokeLineJoin=1, # 1=round ) def _draw_sigil_cut_corner_box( self, bottom, center, top, startangle, endangle, strand, color, border=None, corner=0.5, **kwargs, ): """Draw OCTO sigil, box with corners cut off (PRIVATE).""" if strand == 1: inner_radius = center outer_radius = top elif strand == -1: inner_radius = bottom outer_radius = center else: inner_radius = bottom outer_radius = top strokecolor, color = _stroke_and_fill_colors(color, border) startangle, endangle = min(startangle, endangle), max(startangle, endangle) angle = endangle - startangle middle_radius = 0.5 * (inner_radius + outer_radius) boxheight = outer_radius - inner_radius corner_len = min(0.5 * boxheight, 0.5 * boxheight * corner) shaft_inner_radius = inner_radius + corner_len shaft_outer_radius = outer_radius - corner_len cornerangle_delta = max( 0.0, min(abs(boxheight) * 0.5 * corner / middle_radius, abs(angle * 0.5)) ) if angle < 0: cornerangle_delta *= -1 # reverse it # Calculate trig values for angle and coordinates startcos, startsin = cos(startangle), sin(startangle) endcos, endsin = cos(endangle), sin(endangle) x0, y0 = self.xcenter, self.ycenter # origin of the circle p = ArcPath( strokeColor=strokecolor, fillColor=color, strokeLineJoin=1, # 1=round strokewidth=0, **kwargs, ) # Inner curved edge p.addArc( self.xcenter, self.ycenter, inner_radius, 90 - ((endangle - cornerangle_delta) * 180 / pi), 90 - ((startangle + cornerangle_delta) * 180 / pi), moveTo=True, ) # Corner edge - straight lines assumes small angle! # TODO - Use self._draw_arc_line(p, ...) here if we expose corner setting p.lineTo(x0 + shaft_inner_radius * startsin, y0 + shaft_inner_radius * startcos) p.lineTo(x0 + shaft_outer_radius * startsin, y0 + shaft_outer_radius * startcos) # Outer curved edge p.addArc( self.xcenter, self.ycenter, outer_radius, 90 - ((endangle - cornerangle_delta) * 180 / pi), 90 - ((startangle + cornerangle_delta) * 180 / pi), reverse=True, ) # Corner edges p.lineTo(x0 + shaft_outer_radius * endsin, y0 + shaft_outer_radius * endcos) p.lineTo(x0 + shaft_inner_radius * endsin, y0 + shaft_inner_radius * endcos) p.closePath() return p def _draw_sigil_arrow( self, bottom, center, top, startangle, endangle, strand, **kwargs ): """Draw ARROW sigil (PRIVATE).""" if strand == 1: inner_radius = center outer_radius = top orientation = "right" elif strand == -1: inner_radius = bottom outer_radius = center orientation = "left" else: inner_radius = bottom outer_radius = top orientation = "right" # backwards compatibility return self._draw_arc_arrow( inner_radius, outer_radius, startangle, endangle, orientation=orientation, **kwargs, ) def _draw_sigil_big_arrow( self, bottom, center, top, startangle, endangle, strand, **kwargs ): """Draw BIGARROW sigil, like ARROW but straddles the axis (PRIVATE).""" if strand == -1: orientation = "left" else: orientation = "right" return self._draw_arc_arrow( bottom, top, startangle, endangle, orientation=orientation, **kwargs ) def _draw_arc_arrow( self, inner_radius, outer_radius, startangle, endangle, color, border=None, shaft_height_ratio=0.4, head_length_ratio=0.5, orientation="right", colour=None, **kwargs, ): """Draw an arrow along an arc (PRIVATE).""" # Let the UK spelling (colour) override the USA spelling (color) if colour is not None: color = colour strokecolor, color = _stroke_and_fill_colors(color, border) # if orientation == 'right': # startangle, endangle = min(startangle, endangle), max(startangle, endangle) # elif orientation == 'left': # startangle, endangle = max(startangle, endangle), min(startangle, endangle) # else: startangle, endangle = min(startangle, endangle), max(startangle, endangle) if orientation != "left" and orientation != "right": raise ValueError( f"Invalid orientation {orientation!r}, should be 'left' or 'right'" ) angle = endangle - startangle # angle subtended by arc middle_radius = 0.5 * (inner_radius + outer_radius) boxheight = outer_radius - inner_radius shaft_height = boxheight * shaft_height_ratio shaft_inner_radius = middle_radius - 0.5 * shaft_height shaft_outer_radius = middle_radius + 0.5 * shaft_height headangle_delta = max( 0.0, min(abs(boxheight) * head_length_ratio / middle_radius, abs(angle)) ) if angle < 0: headangle_delta *= -1 # reverse it if orientation == "right": headangle = endangle - headangle_delta else: headangle = startangle + headangle_delta if startangle <= endangle: headangle = max(min(headangle, endangle), startangle) else: headangle = max(min(headangle, startangle), endangle) if not ( startangle <= headangle <= endangle or endangle <= headangle <= startangle ): raise RuntimeError( "Problem drawing arrow, invalid positions. " "Start angle: %s, Head angle: %s, " "End angle: %s, Angle: %s" % (startangle, headangle, endangle, angle) ) # Calculate trig values for angle and coordinates startcos, startsin = cos(startangle), sin(startangle) headcos, headsin = cos(headangle), sin(headangle) endcos, endsin = cos(endangle), sin(endangle) x0, y0 = self.xcenter, self.ycenter # origin of the circle if 0.5 >= abs(angle) and abs(headangle_delta) >= abs(angle): # If the angle is small, and the arrow is all head, # cheat and just use a triangle. if orientation == "right": x1, y1 = (x0 + inner_radius * startsin, y0 + inner_radius * startcos) x2, y2 = (x0 + outer_radius * startsin, y0 + outer_radius * startcos) x3, y3 = (x0 + middle_radius * endsin, y0 + middle_radius * endcos) else: x1, y1 = (x0 + inner_radius * endsin, y0 + inner_radius * endcos) x2, y2 = (x0 + outer_radius * endsin, y0 + outer_radius * endcos) x3, y3 = (x0 + middle_radius * startsin, y0 + middle_radius * startcos) # return draw_polygon([(x1,y1),(x2,y2),(x3,y3)], color, border, # stroke_line_join=1) return Polygon( [x1, y1, x2, y2, x3, y3], strokeColor=border or color, fillColor=color, strokeLineJoin=1, # 1=round, not mitre! strokewidth=0, ) elif orientation == "right": p = ArcPath( strokeColor=strokecolor, fillColor=color, # default is mitre/miter which can stick out too much: strokeLineJoin=1, # 1=round strokewidth=0, **kwargs, ) # Note reportlab counts angles anti-clockwise from the horizontal # (as in mathematics, e.g. complex numbers and polar coordinates) # but we use clockwise from the vertical. Also reportlab uses # degrees, but we use radians. p.addArc( self.xcenter, self.ycenter, shaft_inner_radius, 90 - (headangle * 180 / pi), 90 - (startangle * 180 / pi), moveTo=True, ) p.addArc( self.xcenter, self.ycenter, shaft_outer_radius, 90 - (headangle * 180 / pi), 90 - (startangle * 180 / pi), reverse=True, ) if abs(angle) < 0.5: p.lineTo(x0 + outer_radius * headsin, y0 + outer_radius * headcos) p.lineTo(x0 + middle_radius * endsin, y0 + middle_radius * endcos) p.lineTo(x0 + inner_radius * headsin, y0 + inner_radius * headcos) else: self._draw_arc_line( p, outer_radius, middle_radius, 90 - (headangle * 180 / pi), 90 - (endangle * 180 / pi), ) self._draw_arc_line( p, middle_radius, inner_radius, 90 - (endangle * 180 / pi), 90 - (headangle * 180 / pi), ) p.closePath() return p else: p = ArcPath( strokeColor=strokecolor, fillColor=color, # default is mitre/miter which can stick out too much: strokeLineJoin=1, # 1=round strokewidth=0, **kwargs, ) # Note reportlab counts angles anti-clockwise from the horizontal # (as in mathematics, e.g. complex numbers and polar coordinates) # but we use clockwise from the vertical. Also reportlab uses # degrees, but we use radians. p.addArc( self.xcenter, self.ycenter, shaft_inner_radius, 90 - (endangle * 180 / pi), 90 - (headangle * 180 / pi), moveTo=True, reverse=True, ) p.addArc( self.xcenter, self.ycenter, shaft_outer_radius, 90 - (endangle * 180 / pi), 90 - (headangle * 180 / pi), reverse=False, ) # Note - two staight lines is only a good approximation for small # head angle, in general will need to curved lines here: if abs(angle) < 0.5: p.lineTo(x0 + outer_radius * headsin, y0 + outer_radius * headcos) p.lineTo(x0 + middle_radius * startsin, y0 + middle_radius * startcos) p.lineTo(x0 + inner_radius * headsin, y0 + inner_radius * headcos) else: self._draw_arc_line( p, outer_radius, middle_radius, 90 - (headangle * 180 / pi), 90 - (startangle * 180 / pi), ) self._draw_arc_line( p, middle_radius, inner_radius, 90 - (startangle * 180 / pi), 90 - (headangle * 180 / pi), ) p.closePath() return p def _draw_sigil_jaggy( self, bottom, center, top, startangle, endangle, 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: inner_radius = center outer_radius = top teeth = 2 elif strand == -1: inner_radius = bottom outer_radius = center teeth = 2 else: inner_radius = bottom outer_radius = top teeth = 4 # TODO, expose these settings? tail_length_ratio = 1.0 head_length_ratio = 1.0 strokecolor, color = _stroke_and_fill_colors(color, border) startangle, endangle = min(startangle, endangle), max(startangle, endangle) angle = endangle - startangle # angle subtended by arc height = outer_radius - inner_radius assert startangle <= endangle and angle >= 0 if head_length_ratio and tail_length_ratio: headangle = max( endangle - min(height * head_length_ratio / (center * teeth), angle * 0.5), startangle, ) tailangle = min( startangle + min(height * tail_length_ratio / (center * teeth), angle * 0.5), endangle, ) # With very small features, can due to floating point calculations # violate the assertion below that start <= tail <= head <= end tailangle = min(tailangle, headangle) elif head_length_ratio: headangle = max( endangle - min(height * head_length_ratio / (center * teeth), angle), startangle, ) tailangle = startangle else: headangle = endangle tailangle = min( startangle + min(height * tail_length_ratio / (center * teeth), angle), endangle, ) if not startangle <= tailangle <= headangle <= endangle: raise RuntimeError( "Problem drawing jaggy sigil, invalid " "positions. Start angle: %s, " "Tail angle: %s, Head angle: %s, End angle %s, " "Angle: %s" % (startangle, tailangle, headangle, endangle, angle) ) # Calculate trig values for angle and coordinates startcos, startsin = cos(startangle), sin(startangle) headcos, headsin = cos(headangle), sin(headangle) endcos, endsin = cos(endangle), sin(endangle) x0, y0 = self.xcenter, self.ycenter # origin of the circle p = ArcPath( strokeColor=strokecolor, fillColor=color, # default is mitre/miter which can stick out too much: strokeLineJoin=1, # 1=round strokewidth=0, **kwargs, ) # Note reportlab counts angles anti-clockwise from the horizontal # (as in mathematics, e.g. complex numbers and polar coordinates) # but we use clockwise from the vertical. Also reportlab uses # degrees, but we use radians. p.addArc( self.xcenter, self.ycenter, inner_radius, 90 - (headangle * 180 / pi), 90 - (tailangle * 180 / pi), moveTo=True, ) for i in range(teeth): p.addArc( self.xcenter, self.ycenter, inner_radius + i * height / teeth, 90 - (tailangle * 180 / pi), 90 - (startangle * 180 / pi), ) # Curved line needed when drawing long jaggies self._draw_arc_line( p, inner_radius + i * height / teeth, inner_radius + (i + 1) * height / teeth, 90 - (startangle * 180 / pi), 90 - (tailangle * 180 / pi), ) p.addArc( self.xcenter, self.ycenter, outer_radius, 90 - (headangle * 180 / pi), 90 - (tailangle * 180 / pi), reverse=True, ) for i in range(teeth): p.addArc( self.xcenter, self.ycenter, outer_radius - i * height / teeth, 90 - (endangle * 180 / pi), 90 - (headangle * 180 / pi), reverse=True, ) # Curved line needed when drawing long jaggies self._draw_arc_line( p, outer_radius - i * height / teeth, outer_radius - (i + 1) * height / teeth, 90 - (endangle * 180 / pi), 90 - (headangle * 180 / pi), ) p.closePath() return p