bio-graphics 1.2 → 1.4

data/lib/bio/graphics/ruler.rb

@@ -1,96 +1,95 @@
-# 
-# = bio/graphics/ruler - ruler class
-#
-# Copyright::   Copyright (C) 2007
-#               Jan Aerts <jan.aerts@bbsrc.ac.uk>
-# License::     The Ruby License
-#
-module Bio
-  module Graphics
-    class Panel
-      # The Bio::Graphics::Ruler class describes the ruler to be drawn on the
-      # graph. This is created automatically when creating the picture by using
-      # Bio::Graphics::Panel.to_svg. See BioExt::Graphics documentation for
-      # explanation of interplay between different classes.
-      #--
-      # TODO: the ruler might be implemented as a special case of a track, so
-      # it would inherit from it (class Ruler < Bio::Graphics::Panel::Track).
-      # But I haven't really thought this through yet.
-      #++
-      class Ruler
-        # Creates a new Bio::Graphics::Panel::Ruler object.
-        # ---
-        # *Arguments*:
-        # * _panel_ (required) :: Bio::Graphics::Panel object that this ruler
-        #   belongs to
-        # * _colour_ :: colour of the ruler. Default = 'black'
-        # *Returns*:: Bio::Graphics::Ruler object
-        def initialize(panel, colour = [0,0,0])
-          @panel = panel
-          @name = 'ruler'
-          @colour = colour
-        end
-        attr_accessor :panel, :name, :colour, :height, :minor_tick_distance, :major_tick_distance
-
-        def calculate_tick_distance
-          min_tick_distance_requirement_met = false
-          self.minor_tick_distance = 1 # in basepairs.
-          while ! min_tick_distance_requirement_met
-            if self.minor_tick_distance/panel.rescale_factor >= RULER_MIN_DISTANCE_TICKS_PIXEL
-              min_tick_distance_requirement_met = true
-            else
-              self.minor_tick_distance = self.minor_tick_distance*5
-            end
-          end
-
-          self.major_tick_distance = self.minor_tick_distance * 10
-        end
-
-        def draw(panel_drawing, vertical_offset)
-          ruler_drawing = Cairo::Context.new(panel_drawing)
-
-          self.calculate_tick_distance
-
-          # Draw line
-          ruler_drawing.move_to(0,10)
-          ruler_drawing.line_to(panel.width, 10)
-          ruler_drawing.stroke
-
-          # Draw ticks
-          #  * Find position of first tick.
-          #    Most of the time, we don't want the first tick on the very first
-          #    basepair of the view. Suppose that would be position 333 in the
-          #    sequence. Then the numbers under the major tickmarks would be:
-          #    343, 353, 363, 373 and so on. Instead, we want 350, 360, 370, 380.
-          #    So we want to find the position of the first tick.
-          first_tick_position = panel.display_start
-          while first_tick_position.modulo(minor_tick_distance) != 0
-            first_tick_position += 1
-          end
-          
-          #  * And start drawing the rest.
-          first_tick_position.step(panel.display_stop, minor_tick_distance) do |tick|
-            tick_pixel_position = (tick - panel.display_start) / panel.rescale_factor
-            ruler_drawing.move_to(tick_pixel_position.floor, 5)
-            if tick.modulo(major_tick_distance) == 0
-              ruler_drawing.rel_line_to(0, 15)
-              
-              # Draw tick number
-              ruler_drawing.select_font_face(*(FONT))
-              ruler_drawing.set_font_size(RULER_TEXT_HEIGHT)
-              ruler_drawing.move_to(tick_pixel_position.floor, 20 + RULER_TEXT_HEIGHT)
-              ruler_drawing.show_text(tick.to_i.to_s)
-            else
-              ruler_drawing.rel_line_to(0, 5)
-              
-            end
-            ruler_drawing.stroke
-          end
-          
-
-          @height = 25 + RULER_TEXT_HEIGHT
-        end
-      end #Ruler
-    end #Panel
-  end #Graphics
-end #Bio
+# 
+# = bio/graphics/ruler - ruler class
+#
+# Copyright::   Copyright (C) 2007
+#               Jan Aerts <jan.aerts@bbsrc.ac.uk>
+#               Charles Comstock <dgtized@gmail.com>
+# License::     The Ruby License
+#
+
+# The Bio::Graphics::Ruler class describes the ruler to be drawn on the
+# graph. This is created automatically when creating the picture by using
+# Bio::Graphics::Panel.to_svg. See BioExt::Graphics documentation for
+# explanation of interplay between different classes.
+#--
+# TODO: the ruler might be implemented as a special case of a track, so
+# it would inherit from it (class Ruler < Bio::Graphics::Track).
+# But I haven't really thought this through yet.
+#++
+class Bio::Graphics::Ruler        
+  # Creates a new Bio::Graphics::Ruler object.
+  # ---
+  # *Arguments*:
+  # * _panel_ (required) :: Bio::Graphics::Panel object that this ruler
+  #   belongs to
+  # * _colour_ :: colour of the ruler. Default = 'black'
+  # *Returns*:: Bio::Graphics::Ruler object
+  def initialize(panel, colour = [0,0,0])
+    @panel = panel
+    @name = 'ruler'
+    @colour = colour
+    
+    # Number of pixels between each tick, used to calculate tick spacing
+    @min_pixels_per_tick = 5
+    # The base height of minor ticks in pixels
+    @tick_height = 5
+    # The height of the text in pixels
+    @tick_text_height = 10
+
+    @minor_tick_distance = @min_pixels_per_tick ** self.scaling_factor
+    @major_tick_distance = @minor_tick_distance * 10       
+  end
+  attr_accessor(:panel, :name, :colour, :height,
+                :minor_tick_distance, :major_tick_distance,
+                :min_pixels_per_tick, :tick_height, :tick_text_height)
+
+  def scaling_factor(min_pixels_per_tick = @min_pixels_per_tick,
+                          rescale_factor = @panel.rescale_factor)
+    (Math.log(min_pixels_per_tick * rescale_factor) /
+     Math.log(min_pixels_per_tick)).ceil 
+  end
+
+  def first_tick_position(start = @panel.display_start,
+                          minor_tick = @minor_tick_distance)
+    #  * Find position of first tick.
+    #    Most of the time, we don't want the first tick on the very first
+    #    basepair of the view. Suppose that would be position 333 in the
+    #    sequence. Then the numbers under the major tickmarks would be:
+    #    343, 353, 363, 373 and so on. Instead, we want 350, 360, 370, 380.
+    #    So we want to find the position of the first tick.
+    modulo_from_tick = (start % minor_tick)
+    start + (modulo_from_tick > 0 ? (minor_tick - modulo_from_tick + 1) : 0)
+  end
+  
+  def draw(panel_drawing)
+    ruler_drawing = Cairo::Context.new(panel_drawing)
+
+    # Draw line
+    ruler_drawing.move_to(0,10)
+    ruler_drawing.line_to(panel.width, 10)
+    ruler_drawing.stroke
+
+    # Draw ticks
+    #  * And start drawing the rest.
+    first_tick_position.step(@panel.display_stop, @minor_tick_distance) do |tick|
+      tick_pixel_position = (tick - panel.display_start) / @panel.rescale_factor
+      ruler_drawing.move_to(tick_pixel_position.floor, @min_pixels_per_tick)
+      if tick.modulo(@major_tick_distance) == 0
+        ruler_drawing.rel_line_to(0, 3*@tick_height)
+        
+        # Draw tick number
+        ruler_drawing.select_font_face(*Bio::Graphics::FONT)
+        ruler_drawing.set_font_size(@tick_text_height)
+        ruler_drawing.move_to(tick_pixel_position.floor, 4*@tick_height + @tick_text_height)
+        ruler_drawing.show_text(tick.to_i.to_s)
+      else
+        ruler_drawing.rel_line_to(0, @tick_height)
+        
+      end
+      ruler_drawing.stroke
+    end
+
+    @height = 5*@tick_height + @tick_text_height          
+  end
+end
+

data/lib/bio/graphics/subfeature.rb

@@ -0,0 +1,187 @@
+# 
+# = bio/graphics/subfeature.rb - subfeature class
+#
+# Copyright::   Copyright (C) 2007, 2008
+#               Jan Aerts <jan.aerts@bbsrc.ac.uk>
+#               Charles Comstock <dgtized@gmail.com>
+# License::     The Ruby License
+# 
+
+# TODO: Documentation for SubFeature
+class Bio::Graphics::SubFeature
+  # !!Not to be used directly.
+  # ---
+  # *Arguments*:
+  # * _feature_ (required) :: Bio::Graphics::Feature
+  #   object that this subfeature belongs to
+  # * _feature_ _object_ (required) :: A Bio::Feature object (see bioruby)
+  # * :glyph :: Glyph to use. Default = glyph of the track
+  # * :colour :: Colour. Default = colour of the track
+  # *Returns*:: Bio::Graphics::SubFeature object
+  def initialize(feature, feature_object, opts = {})
+    @feature = feature
+    @feature_object = feature_object
+    opts = {
+      :glyph => @feature.glyph,
+      :colour => @feature.colour
+    }.merge(opts)
+    
+    @glyph = opts[:glyph]
+    @colour = opts[:colour]
+
+    @locations = @feature_object.locations
+
+    @start = @locations.collect{|l| l.from}.min.to_i
+    @stop = @locations.collect{|l| l.to}.max.to_i
+    @strand = @locations[0].strand.to_i
+    @pixel_range_collection = Array.new
+    @chopped_at_start = false
+    @chopped_at_stop = false
+    @hidden_subfeatures_at_start = false
+    @hidden_subfeatures_at_stop = false
+
+    # Get all pixel ranges for the subfeatures
+    @locations.each do |l|
+      #   xxxxxx  [          ]
+      if l.to < @feature.track.panel.display_start
+        @hidden_subfeatures_at_start = true
+        next
+      #           [          ]   xxxxx
+      elsif l.from > @feature.track.panel.display_stop
+        @hidden_subfeatures_at_stop = true
+        next
+      #      xxxx[xxx       ]
+      elsif l.from < @feature.track.panel.display_start and l.to > @feature.track.panel.display_start
+        start_pixel = 1
+        stop_pixel = ( l.to - @feature.track.panel.display_start ).to_f / @feature.track.panel.rescale_factor
+        @chopped_at_start = true
+      #          [      xxxx]xxxx
+      elsif l.from < @feature.track.panel.display_stop and l.to > @feature.track.panel.display_stop
+        start_pixel = ( l.from - @feature.track.panel.display_start ).to_f / @feature.track.panel.rescale_factor
+        stop_pixel = @feature.track.panel.width
+        @chopped_at_stop = true
+      #      xxxx[xxxxxxxxxx]xxxx
+      elsif l.from < @feature.track.panel.display_start and l.to > @feature.track.panel.display_stop
+        start_pixel = 1
+        stop_pixel = @feature.track.panel.width
+        @chopped_at_start = true
+        @chopped_at_stop = true
+      #          [   xxxxx  ]
+      else
+        start_pixel = ( l.from - @feature.track.panel.display_start ).to_f / @feature.track.panel.rescale_factor
+        stop_pixel = ( l.to - @feature.track.panel.display_start ).to_f / @feature.track.panel.rescale_factor
+      end
+
+      @pixel_range_collection.push(Range.new(start_pixel, stop_pixel))
+
+    end
+  end
+
+  # The bioruby Bio::Feature object
+  attr_accessor :feature_object
+
+  # The feature that this subfeature belongs to
+  attr_accessor :feature
+
+  # The label of the feature
+  attr_accessor :label
+  alias :name :label
+
+  # The locations of the feature (which is a Bio::Locations object)
+  attr_accessor :locations
+  alias :location :locations
+
+  # The start position of the feature (in bp)
+  attr_accessor :start
+
+  # The stop position of the feature (in bp)
+  attr_accessor :stop
+
+  # The strand of the feature
+  attr_accessor :strand
+
+  # The glyph to use to draw this (sub)feature
+  attr_accessor :glyph
+
+  # The colour to use to draw this (sub)feature
+  attr_accessor :colour
+
+  # The array keeping the pixel ranges for the sub-features. Unspliced
+  # features will just have one element, while spliced features will
+  # have more than one.
+  attr_accessor :pixel_range_collection
+
+  # Is the first subfeature incomplete?
+  attr_accessor :chopped_at_start
+
+  # Is the last subfeature incomplete?
+  attr_accessor :chopped_at_stop
+
+  # Are there subfeatures out of view at the left side of the picture?
+  attr_accessor :hidden_subfeatures_at_start
+
+  # Are there subfeatures out of view at the right side of the picture?
+  attr_accessor :hidden_subfeatures_at_stop
+
+  # Adds the subfeature to the track cairo context. This method should not 
+  # be used directly by the user, but is called by
+  # Bio::Graphics::Feature::SubFeature.draw
+  # ---
+  # *Arguments*:
+  # * _track_drawing_ (required) :: the track cairo object
+  # *Returns*:: FIXME: I don't know
+  def draw(feature_context)
+    # Set the glyph to be used. The glyph can be set as a symbol (e.g. :generic)
+    # or as a hash (e.g. {'utr' => :line, 'cds' => :directed_spliced}).
+    if @feature.glyph.class == Hash
+      @glyph = @feature.glyph[@feature_object.feature]
+    else
+      @glyph = @feature.glyph
+    end
+
+    # We have to check if we want to change the glyph type from directed to
+    #    undirected
+    # There are 2 cases where we don't want to draw arrows on
+    # features:
+    # (a) when the picture is really zoomed out, features are
+    #     so small that the arrow itself is too big
+    # (b) if a directed feature on the fw strand extends beyond
+    #     the end of the picture, the arrow is out of view. This
+    #     is the same as considering the feature as undirected.
+    #     The same obviously goes for features on the reverse
+    #     strand that extend beyond the left side of the image.
+    #
+    # (a) Zoomed out
+    replace_directed_with_undirected = false
+    if (@stop - @start).to_f/@feature.track.panel.rescale_factor.to_f < 2
+      replace_directed_with_undirected = true
+    end
+    # (b) Extending beyond borders picture
+    if ( @chopped_at_stop and @strand = 1 ) or ( @chopped_at_start and @strand = -1 )
+      replace_directed_with_undirected = true
+    end
+
+    local_feature_glyph = nil
+    if @glyph == :directed_generic and replace_directed_with_undirected
+      local_feature_glyph = :generic
+    elsif @glyph == :directed_spliced and replace_directed_with_undirected
+      local_feature_glyph = :spliced
+    elsif @glyph == :directed_box and replace_directed_with_undirected
+      local_feature_glyph = :box
+    else
+      local_feature_glyph = @glyph
+    end
+
+    # And draw the thing.
+
+    feature_context.set_source_rgb(@colour)
+
+    glyph = ("Bio::Graphics::Glyph::" + local_feature_glyph.to_s.camel_case).to_class.new(self, feature_context)
+    glyph.draw
+
+    @feature.left_pixel_of_subfeatures.push(glyph.left_pixel)
+    @feature.right_pixel_of_subfeatures.push(glyph.right_pixel)
+
+      
+  end        
+end #SubFeature

data/lib/bio/graphics/track.rb

@@ -1,156 +1,155 @@
-# 
-# = bio/graphics/track - track class
-#
-# Copyright::   Copyright (C) 2007
-#               Jan Aerts <jan.aerts@bbsrc.ac.uk>
-# License::     The Ruby License
-#
-module Bio
-  module Graphics
-    class Panel
-      # The Bio::Graphics::Track class describes the container for features of
-      # the same type. See Bio::Graphics documentation for explanation of
-      # interplay between different classes.
-      class Track
-        # !!Not to be used directly. Use Bio::Graphics::Panel.add_track instead!!
-        # A track can not exist except within the confines of a
-        # Bio::Graphics::Panel object.
-        #
-        #--
-        # This is necessary because the track needs to know the rescale_factor
-        # and width of the picture, both of which are defined within the panel.
-        #++
-        #
-        # ---
-        # *Arguments*:
-        # * _panel_ (required) :: Bio::Graphics::Panel object that this track
-        #   belongs to
-        # * _name_ (required) :: Name of the track to be displayed (e.g. 'genes')
-        # * _label_ :: Boolean: should the label for each feature be drawn or not
-        # * _colour_ :: Colour to be used to draw the features within the track.
-        #   Default = 'blue'
-        # * _glyph_ :: Glyph to use for drawing the features. Options are:
-        #   :generic, :directed_generic, :spliced, :directed_spliced, :line and
-        #   :triangle. Triangles can be used
-        #   for features whose start and stop positions are the same (e.g. SNPs).
-        #   If you try to draw a feature that is longer with triangles, an error
-        #   will be shown.
-        # *Returns*:: Bio::Graphics::Track object
-        def initialize(panel, name, label = true, colour = [0,0,1], glyph = :generic)
-          @panel = panel
-          @name = name
-          @show_label = label
-          @colour = colour
-          @glyph = glyph
-          @features = Array.new
-          @number_of_feature_rows = 0
-          @vertical_offset = 0
-          @grid = Hash.new
-        end
-        attr_accessor :panel, :name, :show_label, :colour, :glyph, :features, :number_of_feature_rows, :height, :vertical_offset, :grid
-
-        # Adds a Bio::Graphics::Panel::Track::Feature to this track. A track contains
-        # features of the same type, e.g. (for sequence annotation:) genes,
-        # polymorphisms, ESTs, etc.
-        #
-        #  est_track.add_feature('EST1','50..60')
-        #  est_track.add_feature('EST2','52..73')
-        #  est_track.add_feature('EST3','41..69')
-        #  gene_track.add_feature('gene2','39..73')
-        #
-        # For spliced features:
-        #  est_track.add_feature('EST4','join(34..53,153..191)')
-        #
-        # Or on the complement strand:
-        #  est_track.add_feature('EST5','complement(join(34..53,153..191))')
-        #
-        # See the documentation in Bio::Locations for a full description of
-        # how locations can be defined.
-        #
-        # Features are only added if they are at least partly in the displayed
-        # region. If a feature is completely outside of the region, it's not
-        # added. If it should be only partly visible, it is added completely.
-        #
-        # ---
-        # *Arguments*:
-        # * _name_ (required) :: Name of the feature
-        # * _location_ :: String. Default: whole of panel, forward strand.
-        # * _link_ :: URL to link to for this glyph
-        # *Returns*:: Bio::Graphics::Track::Feature object that was created or nil
-        def add_feature(name, location_string = '1..' + @panel.length.to_s, link = nil)
-          if link == ''
-            link = nil
-          end
-          
-          # Calculate the ultimate start and stop of the feature: the start
-          # of the first subfeature (e.g. exon) and the stop of the last one.
-          # The only reason we want to know these positions, is because we want
-          # to determine if the feature falls within the view of the image or
-          # not (see below).
-          location_object = Bio::Locations.new(location_string)
-          start = location_object.collect{|l| l.from}.min.to_i
-          stop = location_object.collect{|l| l.to}.max.to_i
-
-          # If the feature wouldn't show because it's not in the region we're
-          # looking at, don't bother storing the stuff. I think this makes huge
-          # speed and memory differences if you've got a chromosome with
-          # thousands of features.
-          if stop <= self.panel.display_start or start >= self.panel.display_stop
-            return nil
-          else #elsif start >= panel.display_start and stop <= panel.display_stop
-            @features.push(Bio::Graphics::Panel::Track::Feature.new(self, name, location_object, link))
-            return @features[-1]
-          end
-          
-          return self
-        end
-
-
-        # Adds the track to a cairo drawing. This method should not be used
-        # directly by the user, but is called by Bio::Graphics::Panel.draw
-        # ---
-        # *Arguments*:
-        # * _paneldrawing_ (required) :: the panel cairo object
-        # *Returns*:: FIXME: I don't know
-        def draw(panel_drawing)
-          track_drawing = Cairo::Context.new(panel_drawing)
-
-          # Draw thin line above title
-          track_drawing.set_source_rgb(0.75,0.75,0.75)
-          track_drawing.move_to(0, self.vertical_offset)
-          track_drawing.line_to(self.panel.width, self.vertical_offset)
-          track_drawing.stroke
-
-          # Draw track title
-          track_drawing.set_source_rgb(0,0,0)
-#          track_drawing.select_font_face('Georgia',1,1)
-          track_drawing.select_font_face(*(FONT))
-          track_drawing.set_font_size(TRACK_HEADER_HEIGHT)
-          track_drawing.move_to(0,TRACK_HEADER_HEIGHT + self.vertical_offset + 10)
-          track_drawing.show_text(self.name)
-
-          # Draw the features
-          track_drawing.save do
-            track_drawing.translate(0, self.vertical_offset + TRACK_HEADER_HEIGHT)
-            track_drawing.set_source_rgb(@colour)
-
-            @features.sort_by{|f| f.start}.each do |feature|
-              # Don't even bother if the feature is not in the view
-              if feature.stop <= self.panel.display_start or feature.start >= self.panel.display_stop
-                next
-              else
-                feature.draw(track_drawing)
-              end
-            end
-
-          end
-
-          @number_of_feature_rows = ( @grid.keys.length == 0 ) ? 1 : @grid.keys.max + 1
-
-          return panel_drawing
-        end
-
-      end #Track
-    end #Panel
-  end #Graphics
-end #Bio
+# 
+# = bio/graphics/track - track class
+#
+# Copyright::   Copyright (C) 2007, 2008
+#               Jan Aerts <jan.aerts@bbsrc.ac.uk>
+#               Charles Comstock <dgtized@gmail.com>
+# License::     The Ruby License
+#
+
+# The Bio::Graphics::Track class describes the container for features of
+# the same type. See Bio::Graphics documentation for explanation of
+# interplay between different classes.
+class Bio::Graphics::Track
+  # !!Not to be used directly. Use Bio::Graphics::Panel.add_track instead!!
+  # A track can not exist except within the confines of a
+  # Bio::Graphics::Panel object.
+  #
+  #--
+  # This is necessary because the track needs to know the rescale_factor
+  # and width of the picture, both of which are defined within the panel.
+  #++
+  #
+  # ---
+  # *Arguments*:
+  # * _panel_ (required) :: Bio::Graphics::Panel object that this track
+  #   belongs to
+  # * _name_ (required) :: Name of the track to be displayed (e.g. 'genes')
+  # * _:label_ :: Boolean: should the label for each feature be drawn or not
+  #   Default = true
+  # * _:glyph_ :: Glyph to use for drawing the features. Options are:
+  #   :generic, :directed_generic, :box, directed_box, :spliced,
+  #   :directed_spliced, :dot, :triangle, :line and :line_with_handles.
+  #   Default = :generic
+  # * _colour_ :: Colour to be used to draw the features within the track (in 
+  #   RGB) Default = [0,0,1] (i.e. blue)
+  # *Returns*:: Bio::Graphics::Track object
+  def initialize(panel, name, opts = {})
+    @panel = panel
+    @name = name
+    opts = {
+      :label => true,
+      :glyph => :generic,
+      :colour => [0,0,1]
+    }.merge(opts)
+    
+    @show_label = opts[:label]
+    @glyph = opts[:glyph]
+    @colour = opts[:colour]
+
+    # As far as I know, I can't do this in the glyph file for transcript, so we
+    # have to do it here instead.
+    if @glyph == :transcript
+      @glyph = { 'utr5' => :box, 'utr3' => :directed_box, 'cds' => :spliced }
+    end
+    
+    @features = Array.new
+    @number_of_feature_rows = 0
+    @vertical_offset = 0
+    @grid = Hash.new
+  end
+  attr_accessor :panel, :name, :show_label, :colour, :glyph, :features, :number_of_feature_rows, :height, :vertical_offset, :grid
+
+  # Takes a Bio::Feature and adds it as a Bio::Graphics::Feature to this track. 
+  # A track contains features of the same type, e.g. (for sequence annotation:) 
+  # genes, polymorphisms, ESTs, etc.
+  #
+  #  est_track.add_feature(Bio::Feature.new('EST1','50..60'))
+  #  est_track.add_feature(Bio::Feature.new('EST2','52..73'))
+  #  est_track.add_feature(Bio::Feature.new('EST3','41..69'))
+  #  gene_track.add_feature(Bio::Feature.new('gene2','39..73'))
+  #
+  # For spliced features:
+  #  est_track.add_feature('EST4','join(34..53,153..191)')
+  #
+  # Or on the complement strand:
+  #  est_track.add_feature('EST5','complement(join(34..53,153..191))')
+  #
+  # See the documentation in Bio::Locations for a full description of
+  # how locations can be defined.
+  #
+  # Features are only added if they are at least partly in the displayed
+  # region. If a feature is completely outside of the region, it's not
+  # added. If it should be only partly visible, it is added completely.
+  #
+  # ---
+  # *Arguments*:
+  # * _feature_ _object_ (required) :: A Bio::Feature object
+  # * _label_ :: Label for the feature. Default = 'anonymous'
+  # * _link_ :: URL to link to for this glyph. Default = nil
+  # * _glyph_ :: Glyph for the feature. Default = glyph of the track
+  # * _colour_ :: Colour for the feature. Default = colour of the track
+  # *Returns*:: Bio::Graphics::Feature object that was created or nil
+  def add_feature(feature_object, opts = {})
+    # Calculate the ultimate start and stop of the feature: the start
+    # of the first subfeature (e.g. exon) and the stop of the last one.
+    # The only reason we want to know these positions, is because we want
+    # to determine if the feature falls within the view of the image or
+    # not (see below).
+    start = feature_object.locations.collect{|l| l.from}.min.to_i
+    stop = feature_object.locations.collect{|l| l.to}.max.to_i
+
+    # If the feature wouldn't show because it's not in the region we're
+    # looking at, don't bother storing the stuff. I think this makes huge
+    # speed and memory differences if you've got a chromosome with
+    # thousands of features.
+    if stop <= self.panel.display_start or start >= self.panel.display_stop
+      return nil
+    else #elsif start >= panel.display_start and stop <= panel.display_stop
+      @features.push(Bio::Graphics::Feature.new(self, feature_object, opts))
+      return @features[-1]
+    end
+
+    return self
+  end
+
+
+  # Adds the track to a cairo drawing. This method should not be used
+  # directly by the user, but is called by Bio::Graphics::Panel.draw
+  # ---
+  # *Arguments*:
+  # * _panel__drawing_ (required) :: the panel cairo object
+  # *Returns*:: FIXME: I don't know
+  def draw(panel_destination)
+    track_context = Cairo::Context.new(panel_destination)
+
+    # Draw thin line above title
+    track_context.set_source_rgb(0.75,0.75,0.75)
+    track_context.move_to(0, self.vertical_offset)
+    track_context.line_to(self.panel.width, self.vertical_offset)
+    track_context.stroke
+
+    # Draw track title
+    track_context.set_source_rgb(0,0,0)
+    track_context.select_font_face(*(Bio::Graphics::FONT))
+    track_context.set_font_size(Bio::Graphics::TRACK_HEADER_HEIGHT)
+    track_context.move_to(0,Bio::Graphics::TRACK_HEADER_HEIGHT + self.vertical_offset + 10)
+    track_context.show_text(self.name)
+
+    # Draw the features
+    @features.sort_by{|f| f.start}.each do |feature|
+      # Don't even bother if the feature is not in the view
+      if feature.stop <= self.panel.display_start or feature.start >= self.panel.display_stop
+        next
+      else
+        feature.draw(panel_destination)
+      end
+    end
+
+    @number_of_feature_rows = ( @grid.keys.length == 0 ) ? 1 : @grid.keys.max + 1
+
+    return panel_destination
+  end
+
+end #Track
+