Standalone test case originally Biopython for resting ReportLab under Python 2 and 3. Currently seeing a segmentation fault under Python 2.7, and a TypeError under Python 3.3 when testing on Mac OS X - see http://two.pairlist.net/pipermail/reportlab-users/2014-January/010972.html
| from reportlab.pdfgen import canvas | |
| from reportlab.lib.pagesizes import letter | |
| from reportlab.lib.units import inch | |
| from reportlab.lib import colors | |
| from reportlab.pdfbase.pdfmetrics import stringWidth | |
| from reportlab.graphics.shapes import Drawing, String, Line, Rect, Wedge, ArcPath | |
| from reportlab.graphics import renderPDF, renderPS | |
| from reportlab.graphics.widgetbase import Widget | |
| # The following code is to allow all the Bio.Graphics | |
| # code to deal with the different ReportLab renderers | |
| # and the API quirks consistently. | |
| def _write(drawing, output_file, format, dpi=72): | |
| """Helper function to standardize output to files (PRIVATE). | |
| Writes the provided drawing out to a file in a prescribed format. | |
| drawing - suitable ReportLab drawing object. | |
| output_file - a handle to write to, or a filename to write to. | |
| format - String indicating output format, one of PS, PDF, SVG, | |
| or provided the ReportLab renderPM module is installed, | |
| one of the bitmap formats JPG, BMP, GIF, PNG, TIFF or TIFF. | |
| The format can be given in any case. | |
| dpi - Resolution (dots per inch) for bitmap formats. | |
| No return value. | |
| """ | |
| from reportlab.graphics import renderPS, renderPDF, renderSVG | |
| try: | |
| from reportlab.graphics import renderPM | |
| except ImportError: | |
| #This is an optional part of ReportLab, so may not be installed. | |
| #We'll raise a missing dependency error if rendering to a | |
| #bitmap format is attempted. | |
| renderPM=None | |
| formatdict = {'PS': renderPS, 'EPS': renderPS, | |
| # not sure which you actually get, PS or EPS, but | |
| # GenomeDiagram used PS while other modules used EPS. | |
| 'PDF': renderPDF, | |
| 'SVG': renderSVG, | |
| 'JPG': renderPM, | |
| 'BMP': renderPM, | |
| 'GIF': renderPM, | |
| 'PNG': renderPM, | |
| 'TIFF': renderPM, | |
| 'TIF': renderPM | |
| } | |
| try: | |
| #If output is not a string, then .upper() will trigger | |
| #an attribute error... | |
| drawmethod = formatdict[format.upper()] # select drawing method | |
| except (KeyError, AttributeError): | |
| raise ValueError("Output format should be one of %s" | |
| % ", ".join(formatdict)) | |
| if drawmethod is None: | |
| #i.e. We wanted renderPM but it isn't installed | |
| #See the import at the top of the function. | |
| from Bio import MissingPythonDependencyError | |
| raise MissingPythonDependencyError( | |
| "Please install ReportLab's renderPM module") | |
| if drawmethod == renderPM: | |
| #This has a different API to the other render objects | |
| return drawmethod.drawToFile(drawing, output_file, | |
| format, dpi=dpi) | |
| else: | |
| return drawmethod.drawToFile(drawing, output_file) | |
| class _ChromosomeComponent(Widget): | |
| """Base class specifying the interface for a component of the system. | |
| This class should not be instantiated directly, but should be used | |
| from derived classes. | |
| """ | |
| def __init__(self): | |
| """Initialize a chromosome component. | |
| Attributes: | |
| o _sub_components -- Any components which are contained under | |
| this parent component. This attribute should be accessed through | |
| the add() and remove() functions. | |
| """ | |
| self._sub_components = [] | |
| def add(self, component): | |
| """Add a sub_component to the list of components under this item. | |
| """ | |
| assert isinstance(component, _ChromosomeComponent), \ | |
| "Expected a _ChromosomeComponent object, got %s" % component | |
| self._sub_components.append(component) | |
| def remove(self, component): | |
| """Remove the specified component from the subcomponents. | |
| Raises a ValueError if the component is not registered as a | |
| sub_component. | |
| """ | |
| try: | |
| self._sub_components.remove(component) | |
| except ValueError: | |
| raise ValueError("Component %s not found in sub_components." % | |
| component) | |
| def draw(self): | |
| """Draw the specified component. | |
| """ | |
| raise AssertionError("Subclasses must implement.") | |
| class Organism(_ChromosomeComponent): | |
| """Top level class for drawing chromosomes. | |
| This class holds information about an organism and all of it's | |
| chromosomes, and provides the top level object which could be used | |
| for drawing a chromosome representation of an organism. | |
| Chromosomes should be added and removed from the Organism via the | |
| add and remove functions. | |
| """ | |
| def __init__(self, output_format = 'pdf'): | |
| _ChromosomeComponent.__init__(self) | |
| # customizable attributes | |
| self.page_size = letter | |
| self.title_size = 20 | |
| #Do we need this given we don't draw a legend? | |
| #If so, should be a public API... | |
| self._legend_height = 0 # 2 * inch | |
| self.output_format = output_format | |
| def draw(self, output_file, title): | |
| """Draw out the information for the Organism. | |
| Arguments: | |
| o output_file -- The name of a file specifying where the | |
| document should be saved, or a handle to be written to. | |
| The output format is set when creating the Organism object. | |
| Alternatively, output_file=None will return the drawing using | |
| the low-level ReportLab objects (for further processing, such | |
| as adding additional graphics, before writing). | |
| o title -- The output title of the produced document. | |
| """ | |
| width, height = self.page_size | |
| cur_drawing = Drawing(width, height) | |
| self._draw_title(cur_drawing, title, width, height) | |
| cur_x_pos = inch * .5 | |
| if len(self._sub_components) > 0: | |
| x_pos_change = (width - inch) / len(self._sub_components) | |
| # no sub_components | |
| else: | |
| pass | |
| for sub_component in self._sub_components: | |
| # set the drawing location of the chromosome | |
| sub_component.start_x_position = cur_x_pos + 0.05 * x_pos_change | |
| sub_component.end_x_position = cur_x_pos + 0.95 * x_pos_change | |
| sub_component.start_y_position = height - 1.5 * inch | |
| sub_component.end_y_position = self._legend_height + 1 * inch | |
| # do the drawing | |
| sub_component.draw(cur_drawing) | |
| # update the locations for the next chromosome | |
| cur_x_pos += x_pos_change | |
| self._draw_legend(cur_drawing, self._legend_height + 0.5 * inch, width) | |
| if output_file is None: | |
| #Let the user take care of writing to the file... | |
| return cur_drawing | |
| return _write(cur_drawing, output_file, self.output_format) | |
| def _draw_title(self, cur_drawing, title, width, height): | |
| """Write out the title of the organism figure. | |
| """ | |
| title_string = String(width / 2, height - inch, title) | |
| title_string.fontName = 'Helvetica-Bold' | |
| title_string.fontSize = self.title_size | |
| title_string.textAnchor = "middle" | |
| cur_drawing.add(title_string) | |
| def _draw_legend(self, cur_drawing, start_y, width): | |
| """Draw a legend for the figure. | |
| Subclasses should implement this (see also self._legend_height) to | |
| provide specialized legends. | |
| """ | |
| pass | |
| class Chromosome(_ChromosomeComponent): | |
| """Class for drawing a chromosome of an organism. | |
| This organizes the drawing of a single organisms chromosome. This | |
| class can be instantiated directly, but the draw method makes the | |
| most sense to be called in the context of an organism. | |
| """ | |
| def __init__(self, chromosome_name): | |
| """Initialize a Chromosome for drawing. | |
| Arguments: | |
| o chromosome_name - The label for the chromosome. | |
| Attributes: | |
| o start_x_position, end_x_position - The x positions on the page | |
| where the chromosome should be drawn. This allows multiple | |
| chromosomes to be drawn on a single page. | |
| o start_y_position, end_y_position - The y positions on the page | |
| where the chromosome should be contained. | |
| Configuration Attributes: | |
| o title_size - The size of the chromosome title. | |
| o scale_num - A number of scale the drawing by. This is useful if | |
| you want to draw multiple chromosomes of different sizes at the | |
| same scale. If this is not set, then the chromosome drawing will | |
| be scaled by the number of segements in the chromosome (so each | |
| chromosome will be the exact same final size). | |
| """ | |
| _ChromosomeComponent.__init__(self) | |
| self._name = chromosome_name | |
| self.start_x_position = -1 | |
| self.end_x_position = -1 | |
| self.start_y_position = -1 | |
| self.end_y_position = -1 | |
| self.title_size = 20 | |
| self.scale_num = None | |
| self.label_size = 6 | |
| self.chr_percent = 0.25 | |
| self.label_sep_percent = self.chr_percent * 0.5 | |
| self._color_labels = False | |
| def subcomponent_size(self): | |
| """Return the scaled size of all subcomponents of this component. | |
| """ | |
| total_sub = 0 | |
| for sub_component in self._sub_components: | |
| total_sub += sub_component.scale | |
| return total_sub | |
| def draw(self, cur_drawing): | |
| """Draw a chromosome on the specified template. | |
| Ideally, the x_position and y_*_position attributes should be | |
| set prior to drawing -- otherwise we're going to have some problems. | |
| """ | |
| for position in (self.start_x_position, self.end_x_position, | |
| self.start_y_position, self.end_y_position): | |
| assert position != -1, "Need to set drawing coordinates." | |
| # first draw all of the sub-sections of the chromosome -- this | |
| # will actually be the picture of the chromosome | |
| cur_y_pos = self.start_y_position | |
| if self.scale_num: | |
| y_pos_change = ((self.start_y_position * .95 - self.end_y_position) | |
| / self.scale_num) | |
| elif len(self._sub_components) > 0: | |
| y_pos_change = ((self.start_y_position * .95 - self.end_y_position) | |
| / self.subcomponent_size()) | |
| # no sub_components to draw | |
| else: | |
| pass | |
| left_labels = [] | |
| right_labels = [] | |
| for sub_component in self._sub_components: | |
| this_y_pos_change = sub_component.scale * y_pos_change | |
| # set the location of the component to draw | |
| sub_component.start_x_position = self.start_x_position | |
| sub_component.end_x_position = self.end_x_position | |
| sub_component.start_y_position = cur_y_pos | |
| sub_component.end_y_position = cur_y_pos - this_y_pos_change | |
| # draw the sub component | |
| sub_component._left_labels = [] | |
| sub_component._right_labels = [] | |
| sub_component.draw(cur_drawing) | |
| left_labels += sub_component._left_labels | |
| right_labels += sub_component._right_labels | |
| # update the position for the next component | |
| cur_y_pos -= this_y_pos_change | |
| self._draw_labels(cur_drawing, left_labels, right_labels) | |
| self._draw_label(cur_drawing, self._name) | |
| def _draw_label(self, cur_drawing, label_name): | |
| """Draw a label for the chromosome. | |
| """ | |
| x_position = 0.5 * (self.start_x_position + self.end_x_position) | |
| y_position = self.end_y_position | |
| label_string = String(x_position, y_position, label_name) | |
| label_string.fontName = 'Times-BoldItalic' | |
| label_string.fontSize = self.title_size | |
| label_string.textAnchor = 'middle' | |
| cur_drawing.add(label_string) | |
| def _draw_labels(self, cur_drawing, left_labels, right_labels): | |
| """Layout and draw sub-feature labels for the chromosome.""" | |
| if not self._sub_components: | |
| return | |
| color_label = self._color_labels | |
| segment_width = (self.end_x_position - self.start_x_position) \ | |
| * self.chr_percent | |
| label_sep = (self.end_x_position - self.start_x_position) \ | |
| * self.label_sep_percent | |
| segment_x = self.start_x_position \ | |
| + 0.5 * (self.end_x_position - self.start_x_position - segment_width) | |
| y_limits = [] | |
| for sub_component in self._sub_components: | |
| y_limits.extend((sub_component.start_y_position, sub_component.end_y_position)) | |
| y_min = min(y_limits) | |
| y_max = max(y_limits) | |
| del y_limits | |
| #Now do some label placement magic... | |
| #from reportlab.pdfbase import pdfmetrics | |
| #font = pdfmetrics.getFont('Helvetica') | |
| #h = (font.face.ascent + font.face.descent) * 0.90 | |
| h = self.label_size | |
| for x1, x2, labels, anchor in [ | |
| (segment_x, | |
| segment_x - label_sep, | |
| _place_labels(left_labels, y_min, y_max, h), | |
| "end"), | |
| (segment_x + segment_width, | |
| segment_x + segment_width + label_sep, | |
| _place_labels(right_labels, y_min, y_max, h), | |
| "start"), | |
| ]: | |
| for (y1, y2, color, back_color, name) in labels: | |
| cur_drawing.add(Line(x1, y1, x2, y2, | |
| strokeColor = color, | |
| strokeWidth = 0.25)) | |
| label_string = String(x2, y2, name, | |
| textAnchor=anchor) | |
| label_string.fontName = 'Helvetica' | |
| label_string.fontSize = h | |
| if color_label: | |
| label_string.fillColor = color | |
| if back_color: | |
| w = stringWidth(name, label_string.fontName, label_string.fontSize) | |
| if x1 > x2: | |
| w = w * -1.0 | |
| cur_drawing.add(Rect(x2, y2 - 0.1*h, w, h, | |
| strokeColor=back_color, | |
| fillColor=back_color)) | |
| cur_drawing.add(label_string) | |
| class ChromosomeSegment(_ChromosomeComponent): | |
| """Draw a segment of a chromosome. | |
| This class provides the important configurable functionality of drawing | |
| a Chromosome. Each segment has some customization available here, or can | |
| be subclassed to define additional functionality. Most of the interesting | |
| drawing stuff is likely to happen at the ChromosomeSegment level. | |
| """ | |
| def __init__(self): | |
| """Initialize a ChromosomeSegment. | |
| Attributes: | |
| o start_x_position, end_x_position - Defines the x range we have | |
| to draw things in. | |
| o start_y_position, end_y_position - Defines the y range we have | |
| to draw things in. | |
| Configuration Attributes: | |
| o scale - A scaling value for the component. By default this is | |
| set at 1 (ie -- has the same scale as everything else). Higher | |
| values give more size to the component, smaller values give less. | |
| o fill_color - A color to fill in the segment with. Colors are | |
| available in reportlab.lib.colors | |
| o label - A label to place on the chromosome segment. This should | |
| be a text string specifying what is to be included in the label. | |
| o label_size - The size of the label. | |
| o chr_percent - The percentage of area that the chromosome | |
| segment takes up. | |
| """ | |
| _ChromosomeComponent.__init__(self) | |
| self.start_x_position = -1 | |
| self.end_x_position = -1 | |
| self.start_y_position = -1 | |
| self.end_y_position = -1 | |
| # --- attributes for configuration | |
| self.scale = 1 | |
| self.fill_color = None | |
| self.label = None | |
| self.label_size = 6 | |
| self.chr_percent = .25 | |
| def draw(self, cur_drawing): | |
| """Draw a chromosome segment. | |
| Before drawing, the range we are drawing in needs to be set. | |
| """ | |
| for position in (self.start_x_position, self.end_x_position, | |
| self.start_y_position, self.end_y_position): | |
| assert position != -1, "Need to set drawing coordinates." | |
| self._draw_subcomponents(cur_drawing) # Anything behind | |
| self._draw_segment(cur_drawing) | |
| self._overdraw_subcomponents(cur_drawing) # Anything on top | |
| self._draw_label(cur_drawing) | |
| def _draw_subcomponents(self, cur_drawing): | |
| """Draw any subcomponents of the chromosome segment. | |
| This should be overridden in derived classes if there are | |
| subcomponents to be drawn. | |
| """ | |
| pass | |
| def _draw_segment(self, cur_drawing): | |
| """Draw the current chromosome segment. | |
| """ | |
| # set the coordinates of the segment -- it'll take up the MIDDLE part | |
| # of the space we have. | |
| segment_y = self.end_y_position | |
| segment_width = (self.end_x_position - self.start_x_position) \ | |
| * self.chr_percent | |
| segment_height = self.start_y_position - self.end_y_position | |
| segment_x = self.start_x_position \ | |
| + 0.5 * (self.end_x_position - self.start_x_position - segment_width) | |
| # first draw the sides of the segment | |
| right_line = Line(segment_x, segment_y, | |
| segment_x, segment_y + segment_height) | |
| left_line = Line(segment_x + segment_width, segment_y, | |
| segment_x + segment_width, segment_y + segment_height) | |
| cur_drawing.add(right_line) | |
| cur_drawing.add(left_line) | |
| # now draw the box, if it is filled in | |
| if self.fill_color is not None: | |
| fill_rectangle = Rect(segment_x, segment_y, | |
| segment_width, segment_height) | |
| fill_rectangle.fillColor = self.fill_color | |
| fill_rectangle.strokeColor = None | |
| cur_drawing.add(fill_rectangle) | |
| def _overdraw_subcomponents(self, cur_drawing): | |
| """Draw any subcomponents of the chromosome segment over the main part. | |
| This should be overridden in derived classes if there are | |
| subcomponents to be drawn. | |
| """ | |
| pass | |
| def _draw_label(self, cur_drawing): | |
| """Add a label to the chromosome segment. | |
| The label will be applied to the right of the segment. | |
| This may be overlapped by any sub-feature labels on other segments! | |
| """ | |
| if self.label is not None: | |
| label_x = 0.5 * (self.start_x_position + self.end_x_position) + \ | |
| (self.chr_percent + 0.05) * (self.end_x_position - | |
| self.start_x_position) | |
| label_y = ((self.start_y_position - self.end_y_position) / 2 + | |
| self.end_y_position) | |
| label_string = String(label_x, label_y, self.label) | |
| label_string.fontName = 'Helvetica' | |
| label_string.fontSize = self.label_size | |
| cur_drawing.add(label_string) | |
| def _place_labels(desired_etc, minimum, maximum, gap=0): | |
| #Simified implemetation: | |
| return sorted(desired_etc) | |
| # hold the chromosome info for testing | |
| # the info is structured as (label, color, scale) | |
| chr1_info = (("", None, 1), | |
| ("AC30001", None, 1), | |
| ("", colors.blue, 2), | |
| ("", colors.blue, 1.5), | |
| ("", colors.red, 2), | |
| ("AC12345", colors.blue, 1), | |
| ("", colors.blue, 1), | |
| ("", colors.blue, 1), | |
| ("", None, 1)) | |
| def load_chromosome(chr_name, chr_segment_info): | |
| """Load a chromosome and all of its segments.""" | |
| cur_chromosome = Chromosome(chr_name) | |
| for label, fill_color, scale in chr_segment_info: | |
| cur_segment = ChromosomeSegment() | |
| if label != "": | |
| cur_segment.label = label | |
| if fill_color is not None: | |
| cur_segment.fill_color = fill_color | |
| cur_segment.scale = scale | |
| cur_chromosome.add(cur_segment) | |
| return cur_chromosome | |
| def simple_organism(filename, format): | |
| """Output a simple organism to given format.""" | |
| test_organism = Organism(format) | |
| test_organism.add(load_chromosome("I", chr1_info)) | |
| test_organism.draw(filename, "Test organism") | |
| simple_organism("organism.eps", "ps") |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment