bio-graphics 1.0 → 1.2

data/lib/bio-graphics.rb

@@ -8,7 +8,8 @@
 begin
   require 'bio'
   require 'cairo'
-  rescue nil
+  require 'pango'
+  require 'stringio'
 end
 
 require File.dirname(__FILE__) + '/bio/graphics/image_map.rb'

data/lib/bio/graphics/feature.rb

@@ -1,3 +1,4 @@
+require 'yaml'
 # 
 # = bio/graphics/feature.rb - feature class
 #
@@ -123,6 +124,309 @@ module Bio
           # Are there subfeatures out of view at the right side of the picture?
           attr_accessor :hidden_subfeatures_at_stop
 
+          # Method to draw the arrows of directed glyphs. Not to be used
+          # directly, but called by Feature#draw.
+          def arrow(track,direction,x,y,size)
+            case direction
+            when :right
+              track.move_to(x,y)
+              track.rel_line_to(size,size)
+              track.rel_line_to(-size,size)
+              track.close_path.fill
+            when :left
+              track.move_to(x,y)
+              track.rel_line_to(-size,size)
+              track.rel_line_to(size,size)
+              track.close_path.fill
+            when :north
+              track.move_to(x-size,y+size)
+              track.rel_line_to(size,-size)
+              track.rel_line_to(size,size)
+              track.close_path.fill
+            when :south
+              track.move_to(x-size,y-size)
+              track.rel_line_to(size,size)
+              track.rel_line_to(size,-size)
+              track.close_path.fill
+            end
+          end
+
+          # Method to draw the connections (introns) of spliced glyphs. Not to
+          # be used directly, but called by Feature#draw.
+          def connector(track,from,to,top, color)
+            line_width = track.line_width
+            track.set_source_rgb([0,0,0])
+            track.set_line_width(0.5)
+            middle = from + ((to - from)/2)
+            track.move_to(from, top+2)
+            track.line_to(middle, top+7)
+            track.line_to(to, top+2)
+            track.stroke
+            track.set_line_width(line_width)
+            track.set_source_rgb(color)
+          end
+          
+          # Adds the feature to the track cairo context. This method should not 
+          # be used directly by the user, but is called by
+          # Bio::Graphics::Panel::Track.draw
+          # ---
+          # *Arguments*:
+          # * _trackdrawing_ (required) :: the track cairo object
+          # * _row_ (required) :: row within the track that this feature has 
+          #                       been bumped to
+          # *Returns*:: FIXME: I don't know
+          def draw(track_drawing)
+            # 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 (self.stop - self.start).to_f/self.track.panel.rescale_factor.to_f < 2
+              replace_directed_with_undirected = true
+            end
+            # (b) Extending beyond borders picture
+            if ( self.chopped_at_stop and self.strand = 1 ) or ( self.chopped_at_start and self.strand = -1 )
+              replace_directed_with_undirected = true
+            end
+
+            local_feature_glyph = nil
+            if self.track.glyph == :directed_generic and replace_directed_with_undirected
+              local_feature_glyph = :generic
+            elsif self.track.glyph == :directed_spliced and replace_directed_with_undirected
+              local_feature_glyph = :spliced
+            else
+              local_feature_glyph = self.track.glyph
+            end
+
+            # And draw the thing.
+            row = self.find_row
+            top_pixel_of_feature = FEATURE_V_DISTANCE + (FEATURE_HEIGHT+FEATURE_V_DISTANCE)*row
+            bottom_pixel_of_feature = top_pixel_of_feature + FEATURE_HEIGHT
+
+            case local_feature_glyph
+              # triangles are typical for features which have a 1 bp position (start == stop)
+              when :triangle
+                raise "Start and stop are not the same (necessary if you want triangle glyphs)" if self.start != self.stop
+ 
+                # Need to get this for the imagemap
+                left_pixel_of_feature = self.pixel_range_collection[0].start_pixel - FEATURE_ARROW_LENGTH
+                right_pixel_of_feature = self.pixel_range_collection[0].stop_pixel + FEATURE_ARROW_LENGTH
+                arrow(track_drawing,:north,left_pixel_of_feature + FEATURE_ARROW_LENGTH, top_pixel_of_feature, FEATURE_ARROW_LENGTH)
+                track_drawing.close_path.stroke
+              when :line
+                left_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
+                right_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
+                track_drawing.move_to(left_pixel_of_feature,top_pixel_of_feature+FEATURE_ARROW_LENGTH)               
+                track_drawing.line_to(right_pixel_of_feature,top_pixel_of_feature+FEATURE_ARROW_LENGTH)
+                track_drawing.stroke
+
+                track_drawing.set_source_rgb([0,0,0])
+                arrow(track_drawing,:right,left_pixel_of_feature,top_pixel_of_feature,FEATURE_ARROW_LENGTH)
+                track_drawing.close_path.stroke              
+                arrow(track_drawing,:left,right_pixel_of_feature,top_pixel_of_feature,FEATURE_ARROW_LENGTH)
+                track_drawing.close_path.stroke
+
+                track_drawing.set_source_rgb(self.track.colour)
+            when :directed_generic
+                # Need to get this for the imagemap
+                left_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
+                right_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
+                if self.strand == -1 # Reverse strand
+                  track_drawing.rectangle(left_pixel_of_feature+FEATURE_ARROW_LENGTH, top_pixel_of_feature, right_pixel_of_feature - left_pixel_of_feature - FEATURE_ARROW_LENGTH, FEATURE_HEIGHT).fill
+                  arrow(track_drawing,:left,left_pixel_of_feature+FEATURE_ARROW_LENGTH,top_pixel_of_feature,FEATURE_ARROW_LENGTH)
+                  track_drawing.close_path.fill
+                else #default is forward strand
+                  track_drawing.rectangle(left_pixel_of_feature, top_pixel_of_feature, right_pixel_of_feature - left_pixel_of_feature - FEATURE_ARROW_LENGTH, FEATURE_HEIGHT).fill
+                  arrow(track_drawing,:right,right_pixel_of_feature-FEATURE_ARROW_LENGTH,top_pixel_of_feature,FEATURE_ARROW_LENGTH)
+                  track_drawing.close_path.fill
+                end
+              when :spliced
+                gap_starts = Array.new
+                gap_stops = Array.new
+
+                # Need to get this for the imagemap
+                left_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
+                right_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
+
+                # First draw the parts
+                self.pixel_range_collection.sort_by{|pr| pr.start_pixel}.each do |pr|
+                  track_drawing.rectangle(pr.start_pixel, top_pixel_of_feature, (pr.stop_pixel - pr.start_pixel), FEATURE_HEIGHT).fill
+                  gap_starts.push(pr.stop_pixel)
+                  gap_stops.push(pr.start_pixel)
+                end
+
+                # And then draw the connections in the gaps
+                # Start with removing the very first start and the very last stop.
+                gap_starts.sort!.pop
+                gap_stops.sort!.shift
+
+                gap_starts.length.times do |gap_number|
+                  connector(track_drawing,gap_starts[gap_number].to_f,gap_stops[gap_number].to_f,top_pixel_of_feature,track.colour)
+                end
+
+                if self.hidden_subfeatures_at_stop
+                  from = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
+                  to = self.track.panel.width
+                  track_drawing.move_to(from, top_pixel_of_feature+5)
+                  track_drawing.line_to(to, top_pixel_of_feature+5)
+                  track_drawing.stroke
+                end
+
+                if self.hidden_subfeatures_at_start
+                  from = 1
+                  to = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
+                  track_drawing.move_to(from, top_pixel_of_feature+5)
+                  track_drawing.line_to(to, top_pixel_of_feature+5)
+                  track_drawing.stroke
+                end
+
+              when :directed_spliced
+                gap_starts = Array.new
+                gap_stops = Array.new
+                # First draw the parts
+                locations = self.location.sort_by{|l| l.from}
+
+                # Need to get this for the imagemap
+                left_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
+                right_pixel_of_feature = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
+
+                #   Start with the one with the arrow
+                pixel_ranges = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}
+                range_with_arrow = nil
+                if self.strand == -1 # reverse strand => box with arrow is first one
+                  range_with_arrow = pixel_ranges.shift
+                  track_drawing.rectangle((range_with_arrow.start_pixel)+FEATURE_ARROW_LENGTH, top_pixel_of_feature, range_with_arrow.stop_pixel - range_with_arrow.start_pixel - FEATURE_ARROW_LENGTH, FEATURE_HEIGHT).fill
+                  arrow(track_drawing,:left,range_with_arrow.start_pixel+FEATURE_ARROW_LENGTH, top_pixel_of_feature,FEATURE_ARROW_LENGTH)
+                  track_drawing.close_path.fill
+                else # forward strand => box with arrow is last one
+                  range_with_arrow = pixel_ranges.pop
+                  track_drawing.rectangle(range_with_arrow.start_pixel, top_pixel_of_feature, range_with_arrow.stop_pixel - range_with_arrow.start_pixel - FEATURE_ARROW_LENGTH, FEATURE_HEIGHT).fill
+                  arrow(track_drawing,:right,range_with_arrow.stop_pixel-FEATURE_ARROW_LENGTH, top_pixel_of_feature,FEATURE_ARROW_LENGTH)
+                  track_drawing.close_path.fill
+                end
+                gap_starts.push(range_with_arrow.stop_pixel)
+                gap_stops.push(range_with_arrow.start_pixel)
+
+                #   And then add the others
+                pixel_ranges.each do |range|
+                  track_drawing.rectangle(range.start_pixel, top_pixel_of_feature, range.stop_pixel - range.start_pixel, FEATURE_HEIGHT).fill
+                  gap_starts.push(range.stop_pixel)
+                  gap_stops.push(range.start_pixel)
+                end
+
+                # And then draw the connections in the gaps
+                # Start with removing the very first start and the very last stop.
+                gap_starts.sort!.pop
+                gap_stops.sort!.shift
+
+                gap_starts.length.times do |gap_number|
+                  connector(track_drawing,gap_starts[gap_number].to_f,gap_stops[gap_number].to_f,top_pixel_of_feature,track.colour)
+                end
+
+                if self.hidden_subfeatures_at_stop
+                  from = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
+                  to = self.track.panel.width
+                  track_drawing.move_to(from, top_pixel_of_feature+FEATURE_ARROW_LENGTH)
+                  track_drawing.line_to(to, top_pixel_of_feature+FEATURE_ARROW_LENGTH)
+                  track_drawing.stroke
+                end
+
+                if self.hidden_subfeatures_at_start
+                  from = 1
+                  to = self.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
+                  track_drawing.move_to(from, top_pixel_of_feature+FEATURE_ARROW_LENGTH)
+                  track_drawing.line_to(to, top_pixel_of_feature+FEATURE_ARROW_LENGTH)
+                  track_drawing.stroke
+                end
+
+              else #treat as 'generic'
+                left_pixel_of_feature, right_pixel_of_feature = self.pixel_range_collection[0].start_pixel, self.pixel_range_collection[0].stop_pixel
+                track_drawing.rectangle(left_pixel_of_feature, top_pixel_of_feature, (right_pixel_of_feature - left_pixel_of_feature), FEATURE_HEIGHT).fill
+            end
+
+            # Add the label for the feature
+            if self.track.show_label
+              pango_layout = track_drawing.create_pango_layout
+              pango_layout.text = self.name
+              fdesc = Pango::FontDescription.new('Sans Serif')
+              fdesc.set_size(8 * Pango::SCALE)
+              pango_layout.font_description = fdesc
+  
+              text_range = self.start.floor..(self.start.floor + pango_layout.pixel_size[0]*self.track.panel.rescale_factor)
+              if self.track.grid[row+1].nil?
+                self.track.grid[row+1] = Array.new
+              end
+              self.track.grid[row].push(text_range)
+              self.track.grid[row+1].push(text_range)
+              track_drawing.move_to(left_pixel_of_feature, top_pixel_of_feature + TRACK_HEADER_HEIGHT)
+              track_drawing.set_source_rgb(0,0,0)
+              track_drawing.show_pango_layout(pango_layout)
+              track_drawing.set_source_rgb(self.track.colour)
+            end
+            
+            
+            # And add the region to the image map
+            if self.track.panel.clickable
+              # Comment: we have to add the vertical_offset and TRACK_HEADER_HEIGHT!
+              self.track.panel.image_map.elements.push(ImageMap::ImageMapElement.new(left_pixel_of_feature,
+                                                                                     top_pixel_of_feature + self.track.vertical_offset + TRACK_HEADER_HEIGHT,
+                                                                                     right_pixel_of_feature,
+                                                                                     bottom_pixel_of_feature + self.track.vertical_offset + TRACK_HEADER_HEIGHT,
+                                                                                     self.link
+                                                                                    ))
+            end
+          end
+          
+          # Calculates the row within the track where this feature should be
+          # drawn. This method should not 
+          # be used directly by the user, but is called by
+          # Bio::Graphics::Panel::Track::Feature.draw
+          # ---
+          # *Arguments*:: none
+          # *Returns*:: row number
+          def find_row
+            row_found = false
+            
+            # We've got to find out what row to draw the feature on. If two 
+            # features overlap, one of them has to be 'bumped' down. So we'll
+            # first try to draw a new feature at the top of the track. If
+            # it however would overlap with another one, we'll bump it down
+            # to the next row.
+            feature_range = (self.start.floor..self.stop.ceil)
+            row = 1
+            row_available = true
+            until row_found
+              if ! self.track.grid[row].nil?
+                self.track.grid[row].each do |covered|
+                  if feature_range.include?(covered.first) or covered.include?(feature_range.first)
+                    row_available = false
+                  end
+                end
+              end
+  
+              if ! row_available
+                row += 1
+                row_available = true
+              else # We've found the place where to draw the feature.
+                if self.track.grid[row].nil?
+                  self.track.grid[row] = Array.new
+                end
+                self.track.grid[row].push(feature_range)
+                row_found = true
+              end
+            end
+            return row
+          end
+
           class PixelRange
             def initialize(start_pixel, stop_pixel)
               @start_pixel, @stop_pixel = start_pixel, stop_pixel

data/lib/bio/graphics/panel.rb

@@ -43,7 +43,7 @@ module Bio
   #   track1.add_feature('gene3',100,500)
   #
   #   # Add a second track (e.g. 'polymorphisms')
-  #   track2 = g.add_track('polymorphisms','red','triangle')
+  #   track2 = g.add_track('polymorphisms',, false, 'red','triangle')
   #
   #   # And put features on this one
   #   track2.add_feature('polymorphism 1',56,56)
@@ -69,10 +69,12 @@ module Bio
     RULER_MIN_DISTANCE_TICKS_PIXEL = 5  # There should be at least 5 pixels between
                                         #   consecutive ticks. This is used for the
                                         #   calculation of tick distance.
+    FONT = ['Georgia', 1, 1]
 
     # The Bio::Graphics::Panel class describes the complete graph and contains
     # all tracks. See Bio::Graphics documentation for explanation of interplay
     # between different classes.
+    
     class Panel
       # Create a new Bio::Graphics::Panel object
       #
@@ -102,17 +104,17 @@ module Bio
         @length = length.to_i
         @width = width.to_i
         @tracks = Array.new
-        @number_of_times_bumped = 0
+        @number_of_feature_rows = 0
         @clickable = clickable
         @image_map = ( clickable ) ? ImageMap.new : nil
-        @display_start = ( display_start.nil? ) ? 0 : display_start
-        @display_stop = ( display_stop.nil? ) ? @length : display_stop
+        @display_start = ( display_start.nil? or display_start < 0 ) ? 0 : display_start
+        @display_stop = ( display_stop.nil? or display_stop > @length ) ? @length : display_stop
         if @display_stop <= @display_start
           raise "[ERROR] Start coordinate to be displayed has to be smaller than stop coordinate."
         end
         @rescale_factor = (@display_stop - @display_start).to_f / @width
       end
-      attr_accessor :length, :width, :height, :rescale_factor, :tracks, :number_of_times_bumped, :clickable, :image_map, :display_start, :display_stop
+      attr_accessor :length, :width, :height, :rescale_factor, :tracks, :number_of_feature_rows, :clickable, :image_map, :display_start, :display_stop
 
       # Adds a Bio::Graphics::Track container to this panel. A panel contains a
       # logical grouping of features, e.g. (for sequence annotation:) genes,
@@ -124,6 +126,7 @@ module Bio
       # ---
       # *Arguments*:
       # * _name_ (required) :: Name of the track to be displayed (e.g. 'genes')
+      # * _label) :: Whether the feature labels should be displayed 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:
@@ -133,8 +136,8 @@ module Bio
       #   If you try to draw a feature that is longer with triangles, an error
       #   will be shown.
       # *Returns*:: Bio::Graphics::Track object that has just been created
-      def add_track(name, feature_colour = [0,0,1], feature_glyph = 'generic')
-        @tracks.push(Bio::Graphics::Panel::Track.new(self, name, feature_colour, feature_glyph))
+      def add_track(name, label = true, feature_colour = [0,0,1], feature_glyph = 'generic')
+        @tracks.push(Bio::Graphics::Panel::Track.new(self, name, label, feature_colour, feature_glyph))
         return @tracks[-1]
       end
 
@@ -164,14 +167,15 @@ module Bio
 
         # Add tracks
         @tracks.each do |track|
-          track.draw(huge_panel_drawing, vertical_offset)
-          @number_of_times_bumped += track.number_of_times_bumped
-          vertical_offset += ( track.number_of_times_bumped*(FEATURE_HEIGHT+FEATURE_V_DISTANCE+5)) + 10 # '10' is for the header
+          track.vertical_offset = vertical_offset
+          track.draw(huge_panel_drawing)
+          @number_of_feature_rows += track.number_of_feature_rows
+          vertical_offset += ( track.number_of_feature_rows*(FEATURE_HEIGHT+FEATURE_V_DISTANCE+5)) + 10 # '10' is for the header
         end
 
         # And create a smaller version of the panel
         height = ruler.height
-        @number_of_times_bumped.times do
+        @number_of_feature_rows.times do
           height += 20
         end
         @tracks.length.times do #To correct for the track headers

data/lib/bio/graphics/ruler.rb

@@ -76,7 +76,7 @@ module Bio
               ruler_drawing.rel_line_to(0, 15)
               
               # Draw tick number
-              ruler_drawing.select_font_face('Georgia', 1, 1)
+              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)

data/lib/bio/graphics/track.rb

@@ -26,24 +26,28 @@ module Bio
         # * _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' and
-        #   'triangle'. Triangles can be used
+        #   :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, feature_colour = [0,0,1], feature_glyph = 'generic')
+        def initialize(panel, name, label = true, colour = [0,0,1], glyph = :generic)
           @panel = panel
           @name = name
-          @feature_colour = feature_colour
-          @feature_glyph = feature_glyph
+          @show_label = label
+          @colour = colour
+          @glyph = glyph
           @features = Array.new
-          @number_of_times_bumped = 0
+          @number_of_feature_rows = 0
+          @vertical_offset = 0
+          @grid = Hash.new
         end
-        attr_accessor :panel, :name, :feature_colour, :feature_glyph, :features, :number_of_times_bumped, :height
+        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,
@@ -91,7 +95,7 @@ module Bio
           # 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 <= panel.display_start or start >= panel.display_stop
+          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))
@@ -107,276 +111,41 @@ module Bio
         # ---
         # *Arguments*:
         # * _paneldrawing_ (required) :: the panel cairo object
-        # * _verticaloffset_ (required) :: number of pixels to offset the track downwards,
-        #   based on the height of other tracks that were drawn above it
         # *Returns*:: FIXME: I don't know
-        def draw(panel_drawing, vertical_offset)
+        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, vertical_offset)
-          track_drawing.line_to(panel.width, vertical_offset)
+          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('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 + vertical_offset + 10)
+          track_drawing.move_to(0,TRACK_HEADER_HEIGHT + self.vertical_offset + 10)
           track_drawing.show_text(self.name)
 
           # Draw the features
-          grid = Hash.new
-
           track_drawing.save do
-            track_drawing.translate(0, vertical_offset + TRACK_HEADER_HEIGHT)
-            track_drawing.set_source_rgb(@feature_colour)
+            track_drawing.translate(0, self.vertical_offset + TRACK_HEADER_HEIGHT)
+            track_drawing.set_source_rgb(@colour)
 
-            # Now draw the features
-            # These are the basic steps:
-            #   A. find out what row to draw it on
-            #   B. see if we want to change the glyph type from directed to
-            #      undirected
-            #   C. draw the thing
-            @features.each do |feature|
+            @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_drawn = false
-                
-                # A. find out what row to draw it on
-                feature_range = (feature.start.floor..feature.stop.ceil)
-                row = 1
-                row_available = true
-                until feature_drawn
-                  if ! grid[row].nil?
-                    grid[row].each do |covered|
-                      if feature_range.include?(covered.first) or covered.include?(feature_range.first)
-                        row_available = false
-                      end
-                    end
-                  end
-  
-                  if ! row_available
-                    row += 1
-                    row_available = true
-                  else
-                    if grid[row].nil?
-                      grid[row] = Array.new
-                    end
-                    grid[row].push(feature_range)
-
-                    # B. see 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 (feature.stop - feature.start).to_f/panel.rescale_factor.to_f < 2
-                      replace_directed_with_undirected = true
-                    end
-                    # (b) Extending beyond borders picture
-                    if ( feature.chopped_at_stop and feature.strand = 1 ) or ( feature.chopped_at_start and feature.strand = -1 )
-                      replace_directed_with_undirected = true
-                    end
-
-                    local_feature_glyph = nil
-                    if feature_glyph == 'directed_generic' and replace_directed_with_undirected
-                      local_feature_glyph = 'generic'
-                    elsif feature_glyph == 'directed_spliced' and replace_directed_with_undirected
-                      local_feature_glyph = 'spliced'
-                    else
-                      local_feature_glyph = feature_glyph
-                    end
-  
-                    # C. And draw the thing.
-                    top_pixel_of_feature = FEATURE_V_DISTANCE + (FEATURE_HEIGHT+FEATURE_V_DISTANCE)*row
-                    bottom_pixel_of_feature = top_pixel_of_feature + FEATURE_HEIGHT
-
-                    case local_feature_glyph
-                      # triangles are typical for features which have a 1 bp position (start == stop)
-                      when 'triangle'
-                        raise "Start and stop are not the same (necessary if you want triangle glyphs)" if feature.start != feature.stop
-  
-                        # Need to get this for the imagemap
-                        left_pixel_of_feature = feature.pixel_range_collection[0].start_pixel - 3
-                        right_pixel_of_feature = feature.pixel_range_collection[0].stop_pixel + 3
-                        track_drawing.move_to(left_pixel_of_feature + 3, top_pixel_of_feature)
-                        track_drawing.rel_line_to(-3, FEATURE_HEIGHT)
-                        track_drawing.rel_line_to(6, 0)
-                        track_drawing.close_path.fill
-  
-                      when 'directed_generic'
-                        # Need to get this for the imagemap
-                        left_pixel_of_feature = feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
-                        right_pixel_of_feature = feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
-                        if feature.strand == -1 # Reverse strand
-                          # Draw main box
-                          track_drawing.rectangle(left_pixel_of_feature+FEATURE_ARROW_LENGTH, top_pixel_of_feature, right_pixel_of_feature - left_pixel_of_feature - FEATURE_ARROW_LENGTH, FEATURE_HEIGHT).fill
-  
-                          # Draw arrow
-                          track_drawing.move_to(left_pixel_of_feature+FEATURE_ARROW_LENGTH, top_pixel_of_feature)
-                          track_drawing.rel_line_to(-FEATURE_ARROW_LENGTH, FEATURE_HEIGHT/2)
-                          track_drawing.rel_line_to(FEATURE_ARROW_LENGTH, FEATURE_HEIGHT/2)
-                          track_drawing.close_path.fill
-  
-                        else #default is forward strand
-                          track_drawing.rectangle(left_pixel_of_feature, top_pixel_of_feature, right_pixel_of_feature - left_pixel_of_feature - FEATURE_ARROW_LENGTH, FEATURE_HEIGHT).fill
-                          track_drawing.move_to(right_pixel_of_feature - FEATURE_ARROW_LENGTH, top_pixel_of_feature)
-                          track_drawing.rel_line_to(FEATURE_ARROW_LENGTH, FEATURE_HEIGHT/2)
-                          track_drawing.rel_line_to(-FEATURE_ARROW_LENGTH, FEATURE_HEIGHT/2)
-                          track_drawing.close_path.fill
-                        end
-                      when 'spliced'
-                        gap_starts = Array.new
-                        gap_stops = Array.new
-  
-                        # Need to get this for the imagemap
-                        left_pixel_of_feature = feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
-                        right_pixel_of_feature = feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
-  
-                        # First draw the parts
-                        feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}.each do |pr|
-                          track_drawing.rectangle(pr.start_pixel, top_pixel_of_feature, (pr.stop_pixel - pr.start_pixel), FEATURE_HEIGHT).fill
-                          gap_starts.push(pr.stop_pixel)
-                          gap_stops.push(pr.start_pixel)
-                        end
-  
-                        # And then draw the connections in the gaps
-                        # Start with removing the very first start and the very last stop.
-                        gap_starts.sort!.pop
-                        gap_stops.sort!.shift
-  
-                        gap_starts.length.times do |gap_number|
-                          from = gap_starts[gap_number].to_f
-                          to = gap_stops[gap_number].to_f
-                          middle = from + ((to - from)/2)
-                          track_drawing.move_to(from, top_pixel_of_feature+2)
-                          track_drawing.line_to(middle, top_pixel_of_feature+7)
-                          track_drawing.line_to(to, top_pixel_of_feature+2)
-                          track_drawing.stroke
-                        end
-                        
-                        if feature.hidden_subfeatures_at_stop
-                          from = feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
-                          to = panel.width
-                          track_drawing.move_to(from, top_pixel_of_feature+5)
-                          track_drawing.line_to(to, top_pixel_of_feature+5)
-                          track_drawing.stroke
-                        end
-                        
-                        if feature.hidden_subfeatures_at_start
-                          from = 1
-                          to = feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
-                          track_drawing.move_to(from, top_pixel_of_feature+5)
-                          track_drawing.line_to(to, top_pixel_of_feature+5)
-                          track_drawing.stroke
-                        end
-  
-                      when 'directed_spliced'
-                        gap_starts = Array.new
-                        gap_stops = Array.new
-                        # First draw the parts
-                        locations = feature.location.sort_by{|l| l.from}
-  
-                        # Need to get this for the imagemap
-                        left_pixel_of_feature = feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
-                        right_pixel_of_feature = feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
-  
-                        #   Start with the one with the arrow
-                        pixel_ranges = feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}
-                        range_with_arrow = nil
-                        if feature.strand == -1 # reverse strand => box with arrow is first one
-                          range_with_arrow = pixel_ranges.shift
-                          track_drawing.rectangle((range_with_arrow.start_pixel)+FEATURE_ARROW_LENGTH, top_pixel_of_feature, range_with_arrow.stop_pixel - range_with_arrow.start_pixel, FEATURE_HEIGHT).fill
-                          track_drawing.move_to(range_with_arrow.start_pixel+FEATURE_ARROW_LENGTH, top_pixel_of_feature)
-                          track_drawing.rel_line_to(-FEATURE_ARROW_LENGTH, FEATURE_HEIGHT/2)
-                          track_drawing.rel_line_to(FEATURE_ARROW_LENGTH, FEATURE_HEIGHT/2)
-                          track_drawing.close_path.fill
-                        else # forward strand => box with arrow is last one
-                          range_with_arrow = pixel_ranges.pop
-                          track_drawing.rectangle(range_with_arrow.start_pixel-FEATURE_ARROW_LENGTH, top_pixel_of_feature, range_with_arrow.stop_pixel - range_with_arrow.start_pixel, FEATURE_HEIGHT).fill
-                          track_drawing.move_to(range_with_arrow.stop_pixel-FEATURE_ARROW_LENGTH, top_pixel_of_feature)
-                          track_drawing.rel_line_to(FEATURE_ARROW_LENGTH, FEATURE_HEIGHT/2)
-                          track_drawing.rel_line_to(-FEATURE_ARROW_LENGTH, FEATURE_HEIGHT/2)
-                        end
-                        gap_starts.push(range_with_arrow.stop_pixel)
-                        gap_stops.push(range_with_arrow.start_pixel)
-  
-                        #   And then add the others
-                        pixel_ranges.each do |range|
-                          track_drawing.rectangle(range.start_pixel, top_pixel_of_feature, range.stop_pixel - range.start_pixel, FEATURE_HEIGHT).fill
-                          gap_starts.push(range.stop_pixel)
-                          gap_stops.push(range.start_pixel)
-                        end
-  
-                        # And then draw the connections in the gaps
-                        # Start with removing the very first start and the very last stop.
-                        gap_starts.sort!.pop
-                        gap_stops.sort!.shift
-  
-                        gap_starts.length.times do |gap_number|
-                          from = gap_starts[gap_number].to_f
-                          to = gap_stops[gap_number].to_f
-                          middle = from + ((to - from)/2)
-                          track_drawing.move_to(from, top_pixel_of_feature+2)
-                          track_drawing.line_to(middle, top_pixel_of_feature+7)
-                          track_drawing.line_to(to, top_pixel_of_feature+2)
-                          track_drawing.stroke
-                        end
-
-                        if feature.hidden_subfeatures_at_stop
-                          from = feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}[-1].stop_pixel
-                          to = panel.width
-                          track_drawing.move_to(from, top_pixel_of_feature+5)
-                          track_drawing.line_to(to, top_pixel_of_feature+5)
-                          track_drawing.stroke
-                        end
-                        
-                        if feature.hidden_subfeatures_at_start
-                          from = 1
-                          to = feature.pixel_range_collection.sort_by{|pr| pr.start_pixel}[0].start_pixel
-                          track_drawing.move_to(from, top_pixel_of_feature+5)
-                          track_drawing.line_to(to, top_pixel_of_feature+5)
-                          track_drawing.stroke
-                        end
-
-                      else #treat as 'generic'
-                        left_pixel_of_feature, right_pixel_of_feature = feature.pixel_range_collection[0].start_pixel, feature.pixel_range_collection[0].stop_pixel
-                        track_drawing.rectangle(left_pixel_of_feature, top_pixel_of_feature, (right_pixel_of_feature - left_pixel_of_feature), FEATURE_HEIGHT).fill
-                    end
-  
-                    # And add the region to the image map
-                    if panel.clickable
-                      # Comment: we have to add the vertical_offset and TRACK_HEADER_HEIGHT!
-                      panel.image_map.elements.push(ImageMap::ImageMapElement.new(left_pixel_of_feature,
-                                                                                  top_pixel_of_feature + vertical_offset + TRACK_HEADER_HEIGHT,
-                                                                                  right_pixel_of_feature,
-                                                                                  bottom_pixel_of_feature + vertical_offset + TRACK_HEADER_HEIGHT,
-                                                                                  feature.link
-                                                                                  ))
-                    end
-  
-  
-                    feature_drawn = true
-                  end
-                end
+                feature.draw(track_drawing)
               end
             end
 
           end
 
-          @number_of_times_bumped = ( grid.keys.length == 0 ) ? 1 : grid.keys.max + 1
+          @number_of_feature_rows = ( @grid.keys.length == 0 ) ? 1 : @grid.keys.max + 1
 
           return panel_drawing
         end