bio-svgenes 0.1.1

data/examples/example_config.json

@@ -0,0 +1,49 @@
+{
+	"Page":{"width":800, "height":800, "intervals":15},
+	"Tracks": [ 
+			 {
+			  "glyph":"generic",
+	          "name":"Genes",
+			  "label":true,
+			  "file":"gene.gff",
+			  "file_type":"gff",
+			  "fill_color":"red", 
+              "stroke_width":1, 
+              "x_round":4,
+			  "y_round":4
+			 },
+		     {
+			  "glyph":"transcript",
+	          "name":"Transcripts",
+			  "label":true,
+			  "file":"transcripts.gff",
+			  "file_type":"gff",
+			  "exon_fill_color":"green_white_radial",
+			  "utr_fill_color":"blue_white_radial", 
+              "stroke_width":1,
+			  "gap_marker":"angled"
+			 },
+			{
+			  "glyph":"histogram",
+	          "name":"Data",
+			  "label":true,
+			  "file":"data.txt",
+			  "file_type":"data",
+			  "track_height":100,
+			  "fill_color":"yellow_white_radial",
+              "stroke_width":1
+			 },
+			{
+			  "glyph":"histogram",
+	          "name":"Data with maxed-out scale",
+			  "label":true,
+			  "file":"data.txt",
+			  "file_type":"data",
+			  "track_height":100,
+			  "fill_color":"red_white_radial",
+              "stroke_width":1,
+			  "max_y":1000
+			 }
+			]
+}
+

data/examples/gene.gff

@@ -0,0 +1,4 @@
+##gff-version	3
+##sequence-region	ctg123 1 1497228       
+ctg123	.	gene	900	9900	.	+	.	ID=gene00001;Name=EDEN
+ctg123	.	gene	10900	19900	.	-	.	ID=gene00002;Name=EDEN2

data/examples/get_coverage_in_windows.rb

@@ -0,0 +1,176 @@
+#!/usr/bin/env ruby
+#
+#  get_coverage_in_windows.rb
+#
+#  Created by Dan MacLean (TSL) on 2012-10-05.
+#  Copyright (c)  . All rights reserved.
+###################################################
+require 'optparse'
+require 'pp'
+options = {}
+optparse = OptionParser.new do|opts|
+
+  opts.on( '-b', '--bam FILE', ' name of sorrted BAM file' ) do |b|
+    options[:bam] = b
+
+  end
+  opts.on( '-f', '--reference_file STRING', 'name of the reference sequence fasta file' ) do |f|
+    options[:fasta] = f
+ 
+  end
+  opts.on( '-c', '--chromosome STRING', 'name of the chromosome / contig in the fasta file' ) do |c|
+    options[:chrom] = c
+
+  end
+  opts.on( '-s', '--start INT', 'start position)' ) do |s|
+    options[:start] = s.to_i
+
+  end
+  opts.on( '-e', '--stop INT', 'stop position' ) do |e|
+    options[:stop] = e.to_i
+
+  end  
+  opts.on( '-w', '--step INT', 'window size to use' ) do |w|
+    options[:step] = w.to_i
+
+  end  
+  opts.on( '-o', '--bam_opts INT', 'bio-samtools BAM opts' ) do |o|
+    options[:bam_opts] = o ||= {:min_mapping_quality => 20, :min_base_quality => 30}
+
+  end 
+  # This displays the help screen, all programs are
+  # assumed to have this option.
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    puts opts
+    puts %{Example:  ruby get_coverage_in_windows.rb --bam my_bam.bam --reference_file ref.fasta --chromosome contig1 --start 2000 --stop 3000 --step 100 --bam_opts {:min_mapping_quality => 20, :min_base_quality => 20}}
+    exit
+  end
+end
+optparse.parse!
+
+options[:bam_opts] = {:min_mapping_quality => 20}
+
+
+###Actual script --- 
+require 'rubygems'
+require 'bio-samtools'
+require 'enumerator'
+bam = Bio::DB::Sam.new({:bam=>options[:bam], :fasta=>options[:fasta]} )
+bam.open
+
+def passes_quality(aln, options)
+  if aln.mapq > options[:bam_opts][:min_mapping_quality] && aln.is_mapped
+    true
+  else 
+    false
+  end
+end
+
+def actually_modify(cigar_arr, bases_to_ignore_at_start)
+  result = []
+  bases_ditched = 0
+  cigar_arr.each do |arr|
+    if arr[0] < bases_to_ignore_at_start - bases_ditched
+      bases_ditched += arr[0]
+    elsif arr[0] + bases_ditched >= bases_to_ignore_at_start && bases_ditched < bases_to_ignore_at_start
+      remainder = arr[0] - (bases_to_ignore_at_start - bases_ditched)
+      bases_ditched += (bases_to_ignore_at_start - bases_ditched)
+      result << [remainder, arr[1]] unless remainder == 0
+    elsif bases_ditched >= bases_to_ignore_at_start
+      result << [arr[0],arr[1]]
+    else
+      raise "Shouldn't ever happen. Did though... Panic. Alarums. Etc."
+      exit
+    end
+  end
+  result
+end
+
+def correct_cigar_for_overlaps(cigar_arr, bases_to_ignore_at_start, bases_to_ignore_at_end)
+  #takes the end off the cigar arr if the bases it describes are outside the window
+  return cigar_arr if bases_to_ignore_at_start == 0 && bases_to_ignore_at_end == 0
+  result = actually_modify(cigar_arr,bases_to_ignore_at_start)
+  actually_modify(result.reverse, bases_to_ignore_at_end).reverse
+end
+
+(options[:start]..options[:stop]).step(options[:step]) do |start|
+  positions = Array.new(options[:step], 0.0)
+
+  bam.fetch(options[:chrom], start, start + options[:step]).each do |aln|
+    next unless passes_quality(aln, options)
+    
+    #update start and end for overhanging clipped bases
+    a = aln.cigar.split(/([A-Z])/)
+    cigar_arr = a.enum_for(:each_slice, 2).to_a #convert to array of arrays
+    cigar_arr.collect!{|a| [a.first.to_i, a.last] } #convert numbers to ints
+    if cigar_arr.first.last == "S" or cigar_arr.first.last == "H"
+      aln.pos = aln.pos - cigar_arr.first.first
+      aln.pos = 1 if aln.pos < 1 #ignore negative overhangs...
+    end
+    
+    if cigar_arr.last.last == "S" or cigar_arr.last.last == "H" 
+      aln.calend = aln.calend - cigar_arr.last.first
+      aln.calend = 1 if aln.calend < 1
+    end
+    
+    ##remove any padding operations, we're only concerned with alignments relative to the reference, not other reads.. 
+    cigar_arr.delete_if {|b| b.last == "P"}
+    #need to know whether start outside window ...
+    bases_to_ignore_at_start = 0
+    bases_to_ignore_at_end = 0
+    
+    if aln.pos < start
+      bases_to_ignore_at_start = start - aln.pos
+    end
+    
+    if aln.calend >= start + options[:step] ## left hand border is included in window, right hand border excluded
+      bases_to_ignore_at_end = aln.calend - (start + options[:step]) + 1
+    end
+    
+    cigar_arr = correct_cigar_for_overlaps(cigar_arr.dup, bases_to_ignore_at_start, bases_to_ignore_at_end)
+    #puts "start ignore = #{bases_to_ignore_at_start}"
+    #puts "end ignore = #{bases_to_ignore_at_end}"
+    #modify the read objects start and stop positions to keep only the bit in the window
+    #ignore soft clipping at the start and end
+    if bases_to_ignore_at_start >0
+      aln.pos = aln.pos + bases_to_ignore_at_start
+    end
+    if bases_to_ignore_at_end > 0
+      aln.calend = aln.calend - bases_to_ignore_at_end
+    end
+    
+     begin
+       raise "aln start >= aln end" if aln.pos > aln.calend 
+     rescue
+       next
+     else
+      read_start_corrected = aln.pos - start
+      read_end_corrected = aln.calend - start
+      range_start = read_start_corrected
+      range_stop =  read_end_corrected
+      positions[range_start..range_stop] = positions.slice(range_start..range_stop).collect! {|a| a += 1}
+      ranges_to_decrement = []
+      dist_through_read = 0
+      cigar_arr.each_with_index do |cigar,i|
+      #use the corrected cigar array to correct the coverage post-hoc
+       if cigar.last == "D" or cigar.last == "N"
+         ranges_to_decrement << Range.new(read_start_corrected + dist_through_read, read_start_corrected + dist_through_read + cigar.first - 1)
+       end
+       dist_through_read += cigar.first
+      end #end cigar_arr each
+      #pp ranges_to_decrement unless ranges_to_decrement.empty?
+      ranges_to_decrement.each do |range|
+        begin
+          positions[range] = positions.slice(range).collect! {|b| b -= 1}
+        rescue
+          puts "Error: positions array likely  out of range ... this error affects one read only ... so we'll skip it. Panic if you get lots of this"
+        end
+      end
+     end
+  end #end fetch
+  average = positions.inject(0) {|r,e|  r + e} / positions.length.to_f
+  puts [start, start + options[:step], average].join("\t")
+
+end
+
+bam.close

data/examples/transcripts.gff

@@ -0,0 +1,16 @@
+##gff-version	3
+##sequence-region	ctg123	1	1497228	
+ctg123	.	mRNA	900	9200	.	+	.	ID=mRNA00001;Name=EDEN.1
+ctg123	.	utr	900	1000	.	+	.	ID=utr00001;Parent=mRNA00001
+ctg123	.	exon	1050	1500	.	+	.	ID=exon00002;Parent=mRNA00001
+ctg123	.	exon	3000	3902	.	+	.	ID=exon00003;Parent=mRNA00001
+ctg123	.	exon	5000	5500	.	+	.	ID=exon00004;Parent=mRNA00001
+ctg123	.	exon	7000	9000	.	+	.	ID=exon00005;Parent=mRNA00001
+ctg123	.	utr	9100	9200	.	+	.	ID=utr00002;Parent=mRNA00001
+ctg123	.	mRNA	10900	19200	.	-	.	ID=mRNA00002;Name=EDEN2.1
+ctg123	.	utr	10900	11000	.	-	.	ID=utr00003;Parent=mRNA00002
+ctg123	.	exon	11050	11500	.	-	.	ID=exon00006;Parent=mRNA00002
+ctg123	.	exon	13000	13902	.	-	.	ID=exon00007;Parent=mRNA00002
+ctg123	.	exon	15000	15500	.	-	.	ID=exon00008;Parent=mRNA00002
+ctg123	.	exon	17000	19000	.	-	.	ID=exon00009;Parent=mRNA00002
+ctg123	.	utr	19100	19200	.	-	.	ID=utr00004;Parent=mRNA00002

data/lib/bio-svgenes.rb

@@ -0,0 +1,17 @@
+# Please require your code below, respecting the bioruby directory tree. 
+# For instance, perhaps the only uncommented line in this file might 
+# be something like this:
+#
+#   require 'bio/sequence/awesome_sequence_plugin_thingy'
+#
+# and then create the ruby file 'lib/bio/sequence/awesome_sequence_thingy.rb'
+# and put your plugin's code there. It is bad practice to write other code 
+# directly into this file, because doing so causes confusion if this biogem 
+# was ever to get merged into the main bioruby tree.
+
+require 'bio/graphics/svgee'
+require 'bio/graphics/glyph'
+require 'bio/graphics/page'
+require 'bio/graphics/track'
+require 'bio/graphics/mini_feature'
+require 'bio/graphics/primitive'

data/lib/bio/graphics/glyph.rb

@@ -0,0 +1,241 @@
+class Glyph
+  attr_reader :glyphs
+  #holds a load of definitions for glyphs .. a glyph is an array of primitives... 
+  @glyphs = [:generic, :directed, :transcript, :scale, :label, :histogram]
+  
+  def self.generic(args) #:x, :y, :width :fill, :stroke :stroke_width, :style, :height, 
+    args = { 
+      :height => 10, 
+      :fill_color => 'red', 
+      :stroke => "black", 
+      :stroke_width => 1, 
+      :x_round => 1, 
+      :y_round => 1, 
+      :style => "fill-opacity:0.4;"}.merge!(args)
+    [Primitive.new(:rectangle, args)]
+  end 
+  
+  def self.directed(args) #:x, :y, :width :fill, :stroke :stroke_width, :style, :height
+    args = {
+      
+      :height => 10, 
+      :fill_color => 'red', 
+      :stroke => "black", 
+      :stroke_width => 1, 
+      :style => "fill-opacity:0.4;"}.merge!(args)
+      
+      if args[:strand] == '-'
+        args[:points] = "#{args[:x]},#{args[:y]} #{args[:x] + args[:width]},#{args[:y]} #{args[:x] + args[:width]},#{args[:y] + args[:height] } #{args[:x]},#{args[:y] + (args[:height])} #{args[:x] - (args[:height] * 0.2)},#{args[:y] + (args[:height]/2)}"
+      else
+        args[:points] = "#{args[:x]},#{args[:y]} #{args[:x] + args[:width] - (args[:height] * 0.2)},#{args[:y]} #{args[:x] + args[:width]},#{args[:y] + (args[:height]/2) } #{args[:x] + args[:width] - (args[:height] * 0.2)},#{args[:y] + args[:height]} #{args[:x]},#{args[:y] + args[:height]}"      
+      end
+    [Primitive.new(:polygon, args)]
+  end
+  
+  def self.transcript(args)
+      args = {
+      :height => 10, 
+      :utr_fill_color => 'black', 
+      :utr_stroke => "black", 
+      :utr_stroke_width => 1, 
+      :exon_fill_color => 'red', 
+      :exon_stroke => "black", 
+      :exon_stroke_width => 1, 
+      :line_color => 'black',
+      :line_width => 1, 
+      :exon_style => "fill-opacity:0.4;",
+      :utr_style => "",
+      :line_style => "",
+      :block_gaps => "",
+      :gap_marker => ""
+      }.merge!(args)
+      
+      composite = []
+
+      if not args[:utrs].empty?  ##draw the utr as terminal element...##terminal utr is the one with the point on...
+        x,width =  args[:strand] == '-' ? args[:utrs].shift : args[:utrs].pop 
+        composite += Glyph.directed(:x => x, 
+                                    :y => args[:y], 
+                                    :width => width, 
+                                    :strand => args[:strand], 
+                                    :height => args[:height], 
+                                    :fill_color => args[:utr_fill_color], 
+                                    :stroke =>args[:utr_stroke], 
+                                    :stroke_width => args[:utr_stroke_width], 
+                                    :style => args[:utr_style] )
+        ##draw the other(s!) 
+        args[:utrs].each do |utr|
+          composite <<  Primitive.new(:rectangle, {
+                                                    :x => utr.first, 
+                                                    :width => utr.last, 
+                                                    :y => args[:y], 
+                                                    :height => args[:height], 
+                                                    :fill_color => args[:utr_fill_color], 
+                                                    :stroke =>args[:utr_stroke], 
+                                                    :stroke_width => args[:utr_stroke_width], 
+                                                    :style => args[:utr_style]} )
+        end
+      else ## draw the terminal exon as terminal element  
+        points = nil      
+        x,width =  args[:strand] == '-' ? args[:exons].shift : args[:exons].pop 
+        composite += Glyph.directed(:x => x, 
+                                    :y => args[:y], 
+                                    :width => width, 
+                                    :strand => args[:strand], 
+                                    :height => args[:height], 
+                                    :fill_color => args[:exon_fill_color], 
+                                    :stroke =>args[:exon_stroke], 
+                                    :stroke_width => args[:exon_stroke_width], 
+                                    :style => args[:exon_style] )
+      end
+      #draw any remaining exons
+      args[:exons].each do |exon|
+          composite <<  Primitive.new(:rectangle, {
+                                                    :x => exon[0], 
+                                                    :width => exon[1], 
+                                                    :y => args[:y], 
+                                                    :height => args[:height], 
+                                                    :fill_color => args[:exon_fill_color], 
+                                                    :stroke =>args[:exon_stroke], 
+                                                    :stroke_width => args[:exon_stroke_width], 
+                                                    :style => args[:exon_style]} )
+      end
+      if args[:gap_marker] == "angled" and not args[:block_gaps].empty?
+        args[:block_gaps].each do |gap|
+          points = "#{gap.first},#{args[:y] + (args[:height]/2) } #{gap.first + (gap.last/2)},#{args[:y]} #{gap.first + gap.last},#{args[:y] + (args[:height]/2)}"
+          composite << Primitive.new(:polyline, {
+                                                 :points => points, 
+                                                 :stroke => args[:line_color], 
+                                                 :stroke_width => args[:line_width], 
+                                                 :fill => "none", 
+                                                 :line_style => args[:line_style]})
+        end
+      else
+        #add line
+        composite << Primitive.new(:line, {
+                                            :x1 => args[:x], 
+                                            :x2 => "#{args[:x] + args[:width]}", 
+                                            :y1 => args[:y] + (args[:height]/2), 
+                                            :y2 => args[:y] + (args[:height]/2), 
+                                            :stroke => args[:line_color], 
+                                            :stroke_width => args[:line_width], 
+                                            :line_style => args[:line_style]})
+
+      end
+      composite
+  end
+  
+  def self.scale(args)
+    
+    
+    first_mark = args[:start]
+    last_mark = args[:stop]  
+    #(num.to_f / @nt_per_px_x.to_f)
+    full_dist = last_mark - first_mark
+    interval_width =  full_dist / args[:number_of_intervals] 
+
+
+    a = [Primitive.new(:line, 
+                               :stroke => 'black', 
+                               :stroke_width => 1, 
+                               :x1 => 1, :x2 => args[:page_width] * 1.1, 
+                               :y1 => "20", :y2 => "20"  )]
+
+
+    marks = (first_mark..last_mark).step(interval_width).to_a
+    px_per_nt = full_dist / args[:page_width]
+    marks.each do |mark|
+      x = (mark.to_f - first_mark )/ px_per_nt
+      a << Primitive.new(:rectangle, 
+                         :x => x, 
+                         :y => 20, 
+                         :stroke => 'black', 
+                         :stroke_width => 1, 
+                         :width => 1, 
+                         :height => 5 )
+                         
+      a << Primitive.new(:text, 
+                         :x => x, 
+                         :y => 40, :fill => 'black', 
+                         :text => mark, 
+                         :style => "font-family:Arial;font-style:italic")
+    end
+    return a
+  end
+  
+  def self.label(args)
+    [Primitive.new(:text, 
+                   :text => args[:text], 
+                   :x => args[:x], 
+                   :y => args[:y], 
+                   :fill => "black", 
+                   :style => "font-family:monospace;")]
+  end
+  
+  def self.gradients #needs to know which of its gradients are predefined
+    [:red_white_h, :green_white_h, :blue_white_h, :yellow_white_h, :red_white_radial, :green_white_radial, :blue_white_radial, :yellow_white_radial ]
+  end
+  
+  def self.gradient(gradient)
+    type, color = case gradient
+    when :red_white_h
+      [:linear, "red"]
+    when :green_white_h
+      [:linear, "green"]
+    when :blue_white_h
+      [:linear, "blue"]
+    when :yellow_white_h
+      [:linear, "yellow"]
+    when :red_white_radial
+      [:radial, "red"]
+    when :green_white_radial
+      [:radial, "green"]
+    when :blue_white_radial
+      [:radial, "blue"]
+    when :yellow_white_radial
+      [:radial, "yellow"]
+    end
+    
+    case type
+    when :linear
+            {:type => :linear, 
+       :id => gradient, 
+       :x1 => 0, :y1 => 0, 
+       :x2 => 0, :y2 => 100, 
+       :stops => [
+         {
+          :color => color, 
+          :offset => 0, 
+          :opacity=> 1
+          },
+          {
+           :color => "white", 
+           :offset => 100, 
+           :opacity=> 1 
+           }
+          ]
+        }
+    when :radial
+      {
+       :type => :radial, 
+       :id => gradient, 
+       :cx => 50, :cy => 50, 
+       :r => 50, :fx => 50, :fy => 50, 
+       :stops => [ 
+         {:offset => 0, 
+          :color => "white", 
+          :opacity => 0
+          },  
+          {
+          :offset => 100, 
+          :color => color, 
+          :opacity => 1
+          }
+        ]
+      }
+    end
+    
+  end
+  
+  
+end