sequence_logo 1.0.6 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 885b0f25932abe6a453fcbfb48eaae9e5227383a
-  data.tar.gz: fc7ca0ff71c311e8d7301d086ed3b4d153f0493f
+  metadata.gz: 4ed1b2f635b68cfa6d69d47f1e122c81f917e286
+  data.tar.gz: 493c1d3b807804a5f9ee670df8d7fbc5f6fe883f
 SHA512:
-  metadata.gz: c47be1cb8060cd2ed305d4d21862b86db24d6b24b7b5989fbe86a4fb245c2b8db6a07595a2719c922d0a32bdd10d59f8e916c87c23610911c1a18ca547148ce8
-  data.tar.gz: cfc2df9b0029a19f17070a9937e6a5c61ccebee6ff0c1e65dac5da573c8e5e23de23b23ae240f00dcfc06b525f8e748c35ebfdd006765e2cd608e820450dc72f
+  metadata.gz: b6f56777b12c9dd26c0f3523f3762246baa42a070b045126fabb1b3250b9bba5baa4ff8685a80d06c2b8fabdd095a0c5512a3c0c7096016dd65f1983b24f12e8
+  data.tar.gz: d8bed3b3cab1287681a440b020166f8a5012f02ffb61bfb87ddb7437d23b07298c85cd68fc8a0713020ec8470362d7ea0ae4ad2738140553dfc595f7e5d00752

data/README.md

@@ -38,16 +38,17 @@ SequenceLogo consists of two tools:
 
 * Tool **glue_logos** generates a single image of aligned motifs.
 
-      `glue_logos <output file> <file with alignment infos>`
-    
+      ```glue_logos <output file> <file with alignment infos>```
+
   or
       
-      `<alignment infos> | glue_logos <output file>`
+      <alignment infos> | glue_logos <output file>
+
+  Input data comes either from file with alignments or from stdin. *glue_logos* is designated to work fine with macroape *align_motifs* tool and has input format the same as output format of *align_motifs* tool:
 
-  Input data comes either from file with alignments or from stdin. *glue_logos* is designated to work fine with macroape *align_motifs* tool and has input format the same as output format of *align_motifs* tool:  
-      pcm_file_1  shift_1  orientation_1  
-      pcm_file_2  shift_2  orientation_2        
-      pcm_file_3  shift_3  orientation_3  
+      pcm_file_1  shift_1  orientation_1  [motif_name_1]
+      pcm_file_2  shift_2  orientation_2  [motif_name_2]
+      pcm_file_3  shift_3  orientation_3  [motif_name_3]
       
   So it's simple to run
   

data/lib/sequence_logo/alignment.rb

@@ -0,0 +1,70 @@
+require_relative 'canvases'
+
+module SequenceLogo
+  class Alignment
+    # object to be aligned should respond to #name, #render, #revcomp
+    class Item
+      attr_reader :object, :shift
+
+      def initialize(object, shift)
+        @object, @shift = object, shift
+      end
+
+      def length
+        @object.length
+      end
+
+      def name
+        @object.name
+      end
+
+      def render(canvas_factory)
+        object_image = object.render(canvas_factory)
+        shifted_image = canvas_factory.shifted_logo(object_image, shift)
+        canvas_factory.logo_with_name(shifted_image, name)
+      end
+    end
+
+  ####################
+
+    def initialize(items = [])
+      @alignable_items = items
+    end
+
+    def +(item)
+      Alignment.new(@alignable_items + [item])
+    end
+
+    def revcomp
+      items_reversed = @alignable_items.map{|item|
+        shift_reversed = rightmost_position - item.shift - item.length
+        Item.new(item.object.revcomp, shift_reversed)
+      }
+      Alignment.new(items_reversed)
+    end
+
+    def render(canvas_factory)
+      canvas = VerticalGluingCanvas.new
+      items_normalized.each do |item|
+        canvas.add_image item.render(canvas_factory)
+      end
+      canvas.background(Magick::HatchFill.new('white', 'white'))
+      canvas.image
+    end
+
+  private
+
+    # return list of items shifted altogether such that minimal shift is zero
+    def items_normalized
+      @alignable_items.map{|item| Item.new(item.object, item.shift - leftmost_shift) }
+    end
+
+    def leftmost_shift
+      @alignable_items.map(&:shift).min
+    end
+
+    def rightmost_position
+      @alignable_items.map{|item| item.shift + item.length  }.max
+    end
+  end
+end

data/lib/sequence_logo/canvas_factory.rb

@@ -0,0 +1,96 @@
+require_relative 'magick_support'
+require_relative 'canvases'
+
+module SequenceLogo
+  class CanvasFactory
+    attr_reader :x_unit, :y_unit, :text_size, :logo_shift
+    attr_reader :letter_images
+
+    def initialize(letter_images, options = {})
+      @letter_images = letter_images # .map{|letter_image| letter_image.dup.resize(x_size, y_size) }
+      @logo_shift = options[:logo_shift] || 300
+      @x_unit = options[:x_unit] || 30
+      @y_unit = options[:y_unit] || 60
+      @text_size = options[:text_size] || 24
+    end
+
+    def text_image(text, img_height = y_unit)
+      text_img = Magick::Image.new(logo_shift, img_height){ self.background_color = 'transparent' }
+      annotation = Magick::Draw.new
+      annotation.pointsize(text_size)
+      annotation.text(10, img_height / 2, text)
+      annotation.draw(text_img)
+      text_img
+    end
+
+    def shifted_logo(image, shift)
+      canvas = HorizontalGluingCanvas.new
+      canvas.add_image Magick::Image.new(shift * x_unit, image.rows){ self.background_color = 'transparent' }
+      canvas.add_image image
+      canvas.image
+    end
+
+    def logo_with_name(image, name)
+      canvas = HorizontalGluingCanvas.new
+      canvas.add_image text_image(name, image.rows)
+      canvas.add_image image
+      canvas.image
+    end
+
+    def logo_canvas
+      LogoCanvas.new(letter_images, x_unit: x_unit, y_unit: y_unit)
+    end
+
+    # Takes an enumerable with relative (0 to 1) heights of letters and draws them scaled appropriately
+    def logo_for_ordered_letters(letters_with_heights)
+      logo_for_ordered_letters_nonscaling(rescale_letters(letters_with_heights))
+    end
+
+    # Takes an enumerable with height=>letter pairs draws a logo position with letters in order of enumeration
+    # It's a basic logo-block.
+    def logo_for_ordered_letters_nonscaling(letters_with_heights)
+      y_pos = 0
+      position_logo = Magick::ImageList.new
+      position_logo.set_minimal_size(x_unit, y_unit)
+      letters_with_heights.each do |height, letter|
+        y_pos += height
+        position_logo.put_image_at(letter_image(letter, x_unit, height), 0, y_unit - y_pos)
+      end
+      position_logo.flatten_images
+    end
+
+    def rescale_letters(letters_with_heights)
+      letters_with_heights
+        .reject{|part_of_height, letter| y_unit * part_of_height <= 1 }
+        .map{|part_of_height, letter| [(y_unit * part_of_height), letter] }
+    end
+    private :logo_for_ordered_letters_nonscaling, :rescale_letters
+
+    def letter_image(letter, x_size = x_unit, y_size = y_unit)
+      case letter
+      when Numeric
+        index = letter
+      else
+        index = letter_index(letter)
+      end
+      letter_images[index].dup.resize(x_size, y_size)
+    end
+
+    def letter_index(letter)
+      {'A' => 0 ,'C' => 1,'G' => 2 ,'T' => 3}[letter.to_s.upcase]
+    end
+
+    def self.letter_images(scheme_dir)
+      if File.exist?(File.join(scheme_dir,'a.png'))
+        extension = 'png'
+      elsif File.exist?(File.join(scheme_dir,'a.gif'))
+        extension = 'gif'
+      else
+        raise "Scheme not exists in folder #{scheme_dir}"
+      end
+
+      letter_files = %w[a c g t].collect{|letter| File.join(scheme_dir, "#{letter}.#{extension}") }
+      Magick::ImageList.new(*letter_files)
+    end
+  end
+end

data/lib/sequence_logo/canvases.rb

@@ -0,0 +1,4 @@
+require_relative 'canvases/gluing_canvas'
+require_relative 'canvases/vertical_gluing_canvas'
+require_relative 'canvases/horizontal_gluing_canvas'
+require_relative 'canvases/logo_canvas'

data/lib/sequence_logo/canvases/gluing_canvas.rb

@@ -0,0 +1,35 @@
+require_relative '../magick_support'
+
+module SequenceLogo
+  class GluingCanvas
+    attr_reader :i_logo, :size
+    def initialize
+      @i_logo = Magick::ImageList.new
+      @size = 0
+      @rendering_callbacks = []
+      @rendering_callbacks << method(:render_background)
+    end
+
+    def image
+      @rendering_callbacks.each(&:call)
+      @i_logo.flatten_images
+    end
+
+    def background(fill)
+      @background_fill = fill
+    end
+
+    def render_background
+      if @background_fill
+        @i_logo.unshift Magick::Image.new(x_size, y_size, @background_fill)
+      else
+        @i_logo.set_minimal_size(x_size, y_size)
+      end
+    end
+    private :render_background
+
+    def add_image(item)
+      @size += 1
+    end
+  end
+end

data/lib/sequence_logo/canvases/horizontal_gluing_canvas.rb

@@ -0,0 +1,20 @@
+require_relative 'gluing_canvas'
+
+module SequenceLogo
+  class HorizontalGluingCanvas < GluingCanvas
+    alias_method :length, :size
+
+    def add_image(image)
+      super
+      @i_logo.put_image_at(image, x_size, 0)
+    end
+
+    def x_size
+      @i_logo.to_a.map(&:columns).inject(0, :+)
+    end
+
+    def y_size
+      @i_logo.to_a.map(&:rows).max || 0
+    end
+  end
+end

data/lib/sequence_logo/canvases/logo_canvas.rb

@@ -0,0 +1,40 @@
+require 'RMagick'
+require_relative '../magick_support'
+require_relative 'horizontal_gluing_canvas'
+
+module SequenceLogo
+  class LogoCanvas < HorizontalGluingCanvas
+    attr_reader :canvas_factory
+    def initialize(canvas_factory)
+      super()
+      @canvas_factory = canvas_factory
+    end
+
+    def draw_threshold_line(threshold_level)
+      # stores threshold levels but doesn't render them because full length of canvas is not known yet,
+      # so instantly rendered line would be too short
+      @rendering_callbacks.push ->{ render_threshold_line(threshold_level) }
+    end
+
+    def render_threshold_line(threshold_level)
+      y_coord = y_size - threshold_level * y_size
+      dr = Magick::Draw.new
+      dr.fill('transparent')
+
+      dr.stroke_width(y_size / 200.0)
+      dr.stroke_dasharray(7,7)
+
+      dr.stroke('silver')
+      dr.line(0, y_coord, x_size, y_coord)
+      dr.draw(@i_logo)
+    end
+
+    def add_letter(letter)
+      add_image( canvas_factory.letter_image(letter) )
+    end
+
+    def add_position_ordered(ordered_letter_heights)
+      add_image( canvas_factory.logo_for_ordered_letters(ordered_letter_heights) )
+    end
+  end
+end

data/lib/sequence_logo/canvases/vertical_gluing_canvas.rb

@@ -0,0 +1,18 @@
+require_relative 'gluing_canvas'
+
+module SequenceLogo
+  class VerticalGluingCanvas < GluingCanvas
+    def add_image(image)
+      super
+      @i_logo.put_image_at(image, 0, y_size)
+    end
+
+    def x_size
+      @i_logo.to_a.map(&:columns).max || 0
+    end
+
+    def y_size
+      @i_logo.to_a.map(&:rows).inject(0, :+)
+    end
+  end
+end

data/lib/sequence_logo/cli.rb

@@ -1,5 +1,7 @@
 require 'fileutils'
 require 'optparse'
+require_relative 'support'
+
 module SequenceLogo
   class CLI
     attr_reader :options
@@ -34,4 +36,4 @@ module SequenceLogo
       end
     end
   end
-end
+end

data/lib/sequence_logo/data_models.rb

@@ -0,0 +1,4 @@
+require_relative 'data_models/sequence'
+require_relative 'data_models/sequence_with_snp'
+require_relative 'data_models/ppm_logo'
+require_relative 'data_models/predefined_logo'

data/lib/sequence_logo/data_models/ppm_logo.rb

@@ -0,0 +1,63 @@
+require_relative '../canvases'
+
+module SequenceLogo
+  # wrapper around PPM to make it possible to configure rendering in a flexible way
+  class PPMLogo
+    attr_reader :ppm, :words_count, :icd_mode, :enable_threshold_lines
+
+    def initialize(ppm, options = {})
+      @ppm = ppm
+      @words_count = options[:words_count]
+      @icd_mode = options[:icd_mode]
+      @enable_threshold_lines = options[:enable_threshold_lines]
+
+      @ppm.words_count = @words_count  if @words_count
+      unless ppm.words_count
+        report "words count for PPM is undefined, assuming weblogo mode"
+        @icd_mode = :weblogo
+      end
+    end
+
+    def length
+      ppm.length
+    end
+
+    def name
+      ppm.name
+    end
+
+    def revcomp
+      PPMLogo.new(ppm.revcomp, words_count: words_count, icd_mode: icd_mode, enable_threshold_lines: enable_threshold_lines)
+    end
+
+    def logo_matrix
+      ppm.get_logo(icd_mode)
+    end
+
+    def render(canvas_factory)
+      canvas = LogoCanvas.new(canvas_factory)
+      if icd_mode == :discrete
+        canvas.background(Magick::HatchFill.new('white', 'white'))
+        if enable_threshold_lines
+          canvas.draw_threshold_line(ppm.get_line(ppm.icd2of4))
+          canvas.draw_threshold_line(ppm.get_line(ppm.icdThc))
+          canvas.draw_threshold_line(ppm.get_line(ppm.icdTlc))
+        end
+      else
+        canvas.background(Magick::HatchFill.new('white', 'bisque'))
+      end
+
+      logo_matrix.each do |position|
+        canvas.add_position_ordered( position_sorted_by_height(position) )
+      end
+      canvas.image
+    end
+
+    # [3,1,1,2] ==> [[3, 0],[2, 3],[1, 1],[1, 2]] (derived from [[3, 'A'],[2,'T'],[1,'C'],[1,'G']])
+    def position_sorted_by_height(position)
+      # sort by [count, letter_index] allows us to make stable sort by count (it's useful for predictable order of same-height nucleotides)
+      position.each_with_index.sort_by{|count, letter_index| [count, letter_index] }.reverse
+    end
+    private :position_sorted_by_height
+  end
+end

data/lib/sequence_logo/data_models/predefined_logo.rb

@@ -0,0 +1,29 @@
+module SequenceLogo
+  class PredefinedLogo
+    attr_reader :direct_image, :reverse_image
+    def initialize(options = {})
+      @direct_image = options[:direct_image]
+      @reverse_image = options[:reverse_image]
+      @name = options[:name]
+      @length = options[:length]
+    end
+
+    def length
+      raise 'Length not defined'  unless @length
+      @length
+    end
+
+    def name
+      raise 'Name not defined'  unless @name
+      @name
+    end
+
+    def revcomp
+      PredefinedLogo.new(direct_image: @reverse_image, reverse_image: @direct_image, name: @name, length: @length)
+    end
+
+    def render(canvas_factory)
+      @direct_image
+    end
+  end
+end

data/lib/sequence_logo/data_models/sequence.rb

@@ -0,0 +1,40 @@
+require_relative '../canvases'
+
+module SequenceLogo
+  class Sequence
+    attr_reader :sequence, :name
+    def initialize(sequence, options = {})
+      raise 'Wrong sequence' unless Sequence.valid_sequence?(sequence)
+      @sequence = sequence
+      @name = options[:name] || sequence
+    end
+
+    def length
+      sequence.length
+    end
+
+    def revcomp
+      Sequence.new(Sequence.revcomp(sequence), name: name)
+    end
+
+    def render(canvas_factory)
+      canvas = LogoCanvas.new(canvas_factory)
+      canvas.background(Magick::HatchFill.new('white', 'white'))
+      sequence.each_char do |letter|
+        canvas.add_letter(letter)
+      end
+      canvas.image
+    end
+
+    def self.complement(sequence)
+      sequence.tr('acgtACGT', 'tgcaTGCA')
+    end
+    def self.revcomp(sequence)
+      complement(sequence).reverse
+    end
+
+    def self.valid_sequence?(sequence)
+      sequence.match /\A[acgt]+\z/i
+    end
+  end
+end

data/lib/sequence_logo/data_models/sequence_with_snp.rb

@@ -0,0 +1,45 @@
+require_relative 'sequence'
+require_relative '../canvases'
+
+module SequenceLogo
+  class SequenceWithSNP
+    attr_reader :left, :allele_variants, :right, :name
+    def initialize(left, allele_variants, right, options = {})
+      raise unless Sequence.valid_sequence?(left)
+      raise unless Sequence.valid_sequence?(right)
+      raise unless allele_variants.all?{|letter| %w[A C G T].include?(letter.upcase) }
+      @left, @allele_variants, @right = left, allele_variants, right
+      @name = options[:name] || (left + '_' + allele_variants.join('-') + '_' + right)
+    end
+
+    def self.from_string(sequence, options = {})
+      left, mid, right = sequence.split(/[\[\]]/)
+      allele_variants = mid.split('/')
+      SequenceWithSNP.new(left, allele_variants, right, options)
+    end
+
+    def length
+      left.length + 1 + right.length
+    end
+
+    def revcomp
+      SequenceWithSNP.new(Sequence.revcomp(right),
+                          allele_variants.map{|letter| Sequence.complement(letter) },
+                          Sequence.revcomp(left))
+    end
+
+    def render(canvas_factory)
+      canvas = LogoCanvas.new(canvas_factory)
+      canvas.background(Magick::HatchFill.new('white', 'white'))
+      left.each_char{|letter| canvas.add_letter(letter) }
+      canvas.add_position_ordered(snp_position_heights)
+      right.each_char{|letter| canvas.add_letter(letter) }
+      canvas.image
+    end
+
+    def snp_position_heights
+      allele_variants.map{|letter| [1.0 / allele_variants.size, letter] }
+    end
+    private :snp_position_heights
+  end
+end

data/lib/sequence_logo/exec/glue_logos.rb

@@ -1,43 +1,64 @@
 require_relative '../../sequence_logo'
 require 'fileutils'
-require 'cgi'
 require 'tempfile'
 
-def generate_glued_logo(alignment_infos, options, total_orientation, output_file)
-  logos = {}
-  logo_files = []
-  rightmost_side = alignment_infos.map do |line|
+def load_alignment_infos(alignment_lines)
+  alignment_lines.map{|line|
     filename, shift, orientation, motif_name = line.strip.split("\t")
+    motif_name ||= File.basename(filename, File.extname(filename))
     shift = shift.to_i
-    shift + get_ppm_from_file(filename).length
-  end.max
+    orientation = orientation.downcase.to_sym
 
-  alignment_infos.each do |line|
-    filename, shift, orientation, motif_name = line.strip.split("\t")
-    motif_name ||= CGI.unescape(File.basename(filename, File.extname(filename)))
     ppm = get_ppm_from_file(filename)
-    shift = shift.to_i
-    raise 'Unknown orientation'  unless %w[direct revcomp].include?(orientation.downcase)
-    if total_orientation == :revcomp
-      orientation = (orientation == 'direct') ? 'revcomp' : 'direct'
-      shift = rightmost_side - shift - ppm.length
-    end
     checkerr("bad input file: #{filename}") { ppm == nil }
-    logo_file = Tempfile.new(filename)
-    logo_files << logo_file
-    case orientation
-    when 'direct'
-      SequenceLogo.draw_logo(ppm, options).write("PNG:#{logo_file.path}")
-    when 'revcomp'
-      SequenceLogo.draw_logo(ppm.revcomp, options).write("PNG:#{logo_file.path}")
-    else
-      raise "Unknown orientation #{orientation} for #{motif_name}"
-    end
-    logos[logo_file.path] = {shift: shift, length: ppm.length, name: motif_name}
+    ppm.name ||= motif_name
+
+    raise 'Unknown orientation'  unless [:direct, :revcomp].include?(orientation)
+
+    ppm_oriented = (orientation == :direct) ? ppm : ppm.revcomp
+    {motif: ppm_oriented, shift: shift}
+  }
+end
+
+def make_logo_alignment(aligned_motifs, options)
+  alignment = SequenceLogo::Alignment.new
+  aligned_motifs.map {|motif_infos|
+    ppm_logo = SequenceLogo::PPMLogo.new(motif_infos[:motif],
+                                        icd_mode: options[:icd_mode],
+                                        words_count: options[:words_count],
+                                        enable_threshold_lines: options[:threshold_lines])
+    alignment += SequenceLogo::Alignment::Item.new(ppm_logo, motif_infos[:shift])
+  }
+  alignment
+end
+
+def readlines_from_file_or_stdin(argv, options = {})
+  default_options = { source_not_given_msg: 'Specify input data',
+                      both_sources_given_msg: 'Specify either file with data or data itself in stdin, not both'}
+  options = default_options.merge(options)
+  raise options[:both_sources_given_msg]  if !argv.empty? && !$stdin.tty?
+  if !argv.empty?
+    lines = File.readlines(argv.first)
+  elsif !$stdin.tty?
+    lines = $stdin.readlines
+  else
+    raise ArgumentError, options[:source_not_given_msg]
   end
+  lines
+end
 
-  SequenceLogo.glue_files(logos, output_file, options)
-  logo_files.each(&:close)
+def direct_output_filename(output_file)
+  extname = File.extname(output_file)
+  basename = File.basename_wo_extname(output_file)
+  dirname = File.dirname(output_file)
+  File.join(dirname, "#{basename}_direct#{extname}")
+end
+
+def reverse_output_filename(output_file)
+  extname = File.extname(output_file)
+  basename = File.basename_wo_extname(output_file)
+  dirname = File.dirname(output_file)
+  File.join(dirname, "#{basename}_revcomp#{extname}")
 end
 
 begin
@@ -57,7 +78,7 @@ begin
 
   argv = ARGV
   total_orientation = :direct
-  default_options = {x_unit: 30, y_unit: 60, words_count: nil, icd_mode: :discrete, threshold_lines: true, scheme: 'nucl_simpa', logo_shift: 300, text_size_pt: 24}
+  default_options = {x_unit: 30, y_unit: 60, words_count: nil, icd_mode: :discrete, threshold_lines: false, scheme: 'nucl_simpa', logo_shift: 300, text_size: 24}
   cli = SequenceLogo::CLI.new(default_options)
   cli.instance_eval do
     parser.banner = doc
@@ -78,25 +99,25 @@ begin
   output_file = argv.shift
   raise ArgumentError, 'Specify output file'  unless output_file
 
-  raise 'You can specify alignment infos either from file or from stdin. Don\'t use both sources simultaneously' if !ARGV.empty? && !$stdin.tty?
-  if !ARGV.empty?
-    alignment_infos = File.readlines(ARGV.shift)
-  elsif !$stdin.tty?
-    alignment_infos = $stdin.readlines
-  else
-    raise ArgumentError, 'Specify alignment infos'
-  end
+  alignment_lines = readlines_from_file_or_stdin(argv,  source_not_given_msg: 'Specify alignment infos',
+                                                        both_sources_given_msg: 'You can specify alignment infos either from file or from stdin. Don\'t use both sources simultaneously')
+  alignment = make_logo_alignment(load_alignment_infos(alignment_lines), options)
 
-  if total_orientation == :both
-    extname = File.extname(output_file)
-    basename = File.basename(output_file, extname)
-    dirname = File.dirname(output_file)
-    generate_glued_logo(alignment_infos, options, :direct, File.join(dirname, "#{basename}_direct.#{extname}"))
-    generate_glued_logo(alignment_infos, options, :revcomp, File.join(dirname, "#{basename}_revcomp.#{extname}"))
-  else
-    generate_glued_logo(alignment_infos, options, total_orientation, output_file)
+  scheme_dir = File.join(SequenceLogo::AssetsPath, options[:scheme])
+  letter_images = SequenceLogo::CanvasFactory.letter_images(scheme_dir)
+  canvas_factory = SequenceLogo::CanvasFactory.new(letter_images, x_unit: options[:x_unit], y_unit: options[:y_unit],
+                                                    text_size: options[:text_size], logo_shift: options[:logo_shift])
+
+  case total_orientation
+  when :direct
+    alignment.render(canvas_factory).write('PNG:' + output_file)
+  when :revcomp
+    alignment.revcomp.render(canvas_factory).write('PNG:' + output_file)
+  when :both
+    alignment.render(canvas_factory).write('PNG:' + direct_output_filename(output_file))
+    alignment.revcomp.render(canvas_factory).write('PNG:' + reverse_output_filename(output_file))
   end
 
 rescue => err
   $stderr.puts "\n#{err}\n#{err.backtrace.first(5).join("\n")}\n\nUse --help option for help\n\n#{doc}"
-end
+end

data/lib/sequence_logo/exec/sequence_logo.rb

@@ -1,17 +1,50 @@
 require_relative '../../sequence_logo'
 require 'shellwords'
 
+# [{renderable: , name: }] --> [{renderable: , filename: }]
+def in_necessary_orientations(objects_to_render, orientation, logo_folder)
+  objects_to_render.map do |infos|
+    case orientation
+    when :direct
+      {renderable: infos[:renderable], filename: File.join(logo_folder, "#{infos[:name]}.png") }
+    when :revcomp
+      {renderable: infos[:renderable].revcomp, filename: File.join(logo_folder, "#{infos[:name]}.png") }
+    when :both
+      [ {renderable: infos[:renderable], filename: File.join(logo_folder, "#{infos[:name]}_direct.png") },
+        {renderable: infos[:renderable].revcomp, filename: File.join(logo_folder, "#{infos[:name]}_revcomp.png") } ]
+    end
+  end.flatten
+end
+
+def arglist_augmented_with_stdin(argv)
+  result = argv
+  result += $stdin.read.shellsplit  unless $stdin.tty?
+  result
+end
+
 begin
+  include SequenceLogo
+
   doc = <<-EOS
-  sequence_logo is a tool for drawing motif logos. It is able to process PCM files either as a position matrix (*.pat or *.pcm), or in FASTA format (file extensions: .mfa, .fasta, .plain), or in SMall BiSMark format (.xml), or in IUPAC format (any other extension).
+  sequence_logo is a tool for drawing motif and sequence logos
+  It is able to process
+  - PCM / PPM format i.e. position count/frequency matrix (*.pat or *.pcm) - preferable
+  - FASTA format (file extensions: .mfa, .fasta, .plain)
+  - SMall BiSMark format (.xml)
+  - IUPAC format (any other extension)
   Usage:
-    sequence_logo [options] <pcm/ppm file>...
+    sequence_logo [options] <motif file>...
       or
     ls pcm_folder/*.pcm | sequence_logo [options]
+      or
+    sequence_logo --sequence <sequence>...
+      or
+    sequence_logo --snp-sequence <sequence with SNP>...
+
   EOS
 
   argv = ARGV
-  default_options = {x_unit: 30, y_unit: 60, words_count: nil, orientation: :both, logo_folder: '.', icd_mode: :discrete, threshold_lines: true, scheme: 'nucl_simpa'}
+  default_options = {x_unit: 30, y_unit: 60, words_count: nil, orientation: :direct, logo_folder: '.', icd_mode: :discrete, threshold_lines: true, scheme: 'nucl_simpa'}
   cli = SequenceLogo::CLI.new(default_options)
   cli.instance_eval do
     parser.banner = doc
@@ -23,30 +56,61 @@ begin
       raise ArgumentError, 'Orientation can be either direct or revcomp or both'  unless [:direct, :revcomp, :both].include?(v)
       options[:orientation] = v
     end
+
+    parser.on('--snp-sequence', 'Specify sequences with SNP (like ATCTC[C/G]CCTAAT) instead of motif filenames') do
+      options[:sequence_w_snp] = true
+    end
+    parser.on('--sequence', 'Specify sequence (like ATCTCGCCTAAT) instead of motif filenames') do
+      options[:sequence] = true
+    end
   end
   options = cli.parse_options!(argv)
 
   logo_folder = options[:logo_folder]
   Dir.mkdir(logo_folder)  unless Dir.exist?(logo_folder)
 
-  filenames = argv
-  filenames += $stdin.read.shellsplit  unless $stdin.tty?
-  raise ArgumentError, 'Specify at least one motif file'  if filenames.empty?
+  scheme_dir = File.join(SequenceLogo::AssetsPath, options[:scheme])
+  letter_images = SequenceLogo::CanvasFactory.letter_images(scheme_dir)
+  canvas_factory = SequenceLogo::CanvasFactory.new(letter_images, x_unit: options[:x_unit], y_unit: options[:y_unit])
+
+  raise "Specify either sequence or sequence with SNP or none of them, but not both"  if options[:sequence] && options[:sequence_w_snp]
 
-  filenames.each do |filename|
-    ppm = get_ppm_from_file(filename)
-    checkerr("bad input file: #{filename}") { ppm == nil }
+  objects_to_render = []
+  if options[:sequence]
+    sequences = arglist_augmented_with_stdin(argv)
+    raise ArgumentError, 'Specify at least one sequence'  if sequences.empty?
+
+    sequences.each do |sequence|
+      objects_to_render << {renderable: SequenceLogo::Sequence.new(sequence),
+                            name: File.join(logo_folder, sequence)}
+    end
+  elsif options[:sequence_w_snp]
+    sequences = arglist_augmented_with_stdin(argv)
+    raise ArgumentError, 'Specify at least one sequence'  if sequences.empty?
 
-    filename_wo_ext = File.basename(filename, File.extname(filename))
-    if [:direct, :both].include?(options[:orientation])
-      direct_output = File.join(logo_folder, "#{filename_wo_ext}_direct.png")
-      SequenceLogo.draw_logo(ppm, options).write(direct_output)
+    sequences.each do |sequence_w_snp|
+      objects_to_render << {renderable: SequenceLogo::SequenceWithSNP.from_string(sequence_w_snp),
+                            name: File.join(logo_folder, sequence_w_snp.gsub(/[\[\]\/]/, '_'))}
     end
-    if [:revcomp, :both].include?(options[:orientation])
-      revcomp_output = File.join(logo_folder, "#{filename_wo_ext}_revcomp.png")
-      SequenceLogo.draw_logo(ppm.revcomp, options).write(revcomp_output)
+  else
+    filenames = arglist_augmented_with_stdin(argv)
+    raise ArgumentError, 'Specify at least one motif file'  if filenames.empty?
+
+    filenames.each do |filename|
+      ppm = get_ppm_from_file(filename)
+      checkerr("bad input file: #{filename}") { ppm == nil }
+
+      logo = SequenceLogo::PPMLogo.new( ppm,
+                                        icd_mode: options[:icd_mode],
+                                        words_count: options[:words_count],
+                                        enable_threshold_lines: options[:threshold_lines])
+      objects_to_render << {renderable: logo, name: File.join(logo_folder, File.basename_wo_extname(filename))}
     end
   end
+
+  in_necessary_orientations(objects_to_render, options[:orientation], logo_folder).each do |infos|
+    infos[:renderable].render(canvas_factory).write("PNG:#{infos[:filename]}")
+  end
 rescue => err
   $stderr.puts "\n#{err}\n#{err.backtrace.first(5).join("\n")}\n\nUse --help option for help\n\n#{doc}"
-end
+end

data/lib/sequence_logo/magick_support.rb

@@ -0,0 +1,14 @@
+require 'RMagick'
+
+class Magick::ImageList
+  def put_image_at(image, x, y)
+    self << image
+    cur_image.page = Magick::Rectangle.new(0, 0, x, y)
+  end
+
+  # add transparent layer so that full canvas size can't be less than given size
+  def set_minimal_size(x_size, y_size)
+    empty_image = Magick::Image.new(x_size, y_size){ self.background_color = 'transparent'}
+    self.unshift(empty_image)
+  end
+end

data/lib/sequence_logo/pmflogo_lib.rb

@@ -1,114 +1,5 @@
+require_relative 'canvases'
+require_relative 'canvas_factory'
+require_relative 'alignment'
+require_relative 'data_models'
 require_relative 'ytilib'
-require 'RMagick'
-
-module SequenceLogo
-  def self.draw_threshold_lines(i_logo, ppm)
-    x_size = i_logo.columns
-    y_size = i_logo.rows
-
-    line2of4 = y_size - ppm.get_line(ppm.icd2of4) * y_size
-    lineThc = y_size - ppm.get_line(ppm.icdThc) * y_size
-    lineTlc = y_size - ppm.get_line(ppm.icdTlc) * y_size
-
-    dr = Magick::Draw.new
-    dr.fill('transparent')
-
-    dr.stroke_width(y_size / 200.0)
-    dr.stroke_dasharray(7,7)
-
-    dr.stroke('silver')
-    dr.line(0, line2of4, x_size, line2of4)
-    dr.line(0, lineThc, x_size, lineThc)
-    dr.line(0, lineTlc, x_size, lineTlc)
-
-    dr.draw(i_logo)
-  end
-
-  def self.create_canvas(ppm, options)
-    x_size = options[:x_unit] * ppm.length
-    y_size = options[:y_unit]
-
-    i_logo = Magick::ImageList.new
-    if options[:icd_mode] == :discrete
-      i_logo.new_image(x_size, y_size, Magick::HatchFill.new('white', 'white'))
-      draw_threshold_lines(i_logo, ppm)  if options[:threshold_lines]
-    else
-      i_logo.new_image(x_size, y_size, Magick::HatchFill.new('white', 'bisque'))
-    end
-
-    i_logo
-  end
-
-  def self.letter_images(scheme_dir)
-    if File.exist?(File.join(scheme_dir,'a.png'))
-      extension = 'png'
-    elsif File.exist?(File.join(scheme_dir,'a.gif'))
-      extension = 'gif'
-    else
-      raise "Scheme not exists in folder #{scheme_dir}"
-    end
-
-    letter_files = %w[a c g t].collect{|letter| File.join(scheme_dir, "#{letter}.#{extension}") }
-    Magick::ImageList.new(*letter_files)
-  end
-
-  def self.draw_letters_on_canvas(i_logo, i_letters, ppm, options)
-    y_unit = options[:y_unit]
-    x_unit = options[:x_unit]
-    matrix = ppm.get_logo(options[:icd_mode])
-    matrix['A'].each_index { |i|
-      y_pos = 0
-      sorted_letters = ['A', 'C', 'G', 'T'].collect { |letter| {:score => matrix[letter][i], :letter => letter} }.sort_by { |pair| pair[:score] }.collect { |pair| pair[:letter] }.reverse
-      sorted_letters.each { |letter|
-        next if y_unit * matrix[letter][i] <= 1
-        letter_index = {'A' => 0, 'C' => 1, 'G' => 2, 'T' => 3}[letter]
-        y_block = (y_unit * matrix[letter][i]).round
-        i_logo << i_letters[letter_index].dup.resize(x_unit, y_block)
-        y_pos += y_block
-        i_logo.cur_image.page = Magick::Rectangle.new(0, 0, i * x_unit, y_unit - y_pos )
-      }
-    }
-  end
-
-  def self.draw_logo(ppm, options = {})
-    ppm.words_count = options[:words_count]  if options[:words_count]
-    unless ppm.words_count
-      report "words count for PPM is undefined, assuming weblogo mode"
-      options[:icd_mode] = :weblogo
-    end
-    i_logo = create_canvas(ppm, options)
-    scheme_dir = File.join(AssetsPath, options[:scheme])
-    draw_letters_on_canvas(i_logo, letter_images(scheme_dir), ppm, options)
-    i_logo = i_logo.flatten_images
-  end
-
-  # logos = { filename => {shift: ..., length: ..., name: ...} }
-  def self.glue_files(logos, output_file, options)
-    logo_shift = options[:logo_shift] || 300
-    x_unit = options[:x_unit] || 30
-    y_unit = options[:y_unit] || 60
-    text_size = options[:text_size] || 24
-
-    leftmost_shift = logos.map{|file,infos| infos[:shift] }.min
-    logos.each{|file, infos| infos[:shift] -= leftmost_shift}
-    full_alignment_size = logos.map{|file,infos| infos[:length] + infos[:shift] }.max
-
-    x_size = logo_shift + full_alignment_size * x_unit
-    y_size = logos.size * y_unit
-    command_string = "convert -size #{ x_size }x#{ y_size } -pointsize #{text_size} xc:white "
-    logos.each_with_index do |(logo_filename,infos), idx|
-      logo_x_start = logo_shift + infos[:shift] * x_unit
-      logo_y_start = y_unit * idx
-      command_string << "\"#{ logo_filename }\" -geometry +#{ logo_x_start }+#{ logo_y_start } -composite "
-    end
-
-    command_draw_names = ""
-    logos.each_with_index do |(logo_filename,infos), idx|
-      text_x_start = 10
-      text_y_start = y_unit * (idx + 0.5)
-      command_draw_names << "-draw \"text #{ text_x_start },#{ text_y_start } '#{infos[:name]}'\" "
-    end
-
-    system(command_string + command_draw_names + "\"#{output_file}\"")
-  end
-end

data/lib/sequence_logo/support.rb

@@ -0,0 +1,5 @@
+class File
+  def self.basename_wo_extname(filename)
+    File.basename(filename, File.extname(filename))
+  end
+end

data/lib/sequence_logo/version.rb

@@ -1,3 +1,3 @@
 module SequenceLogo
-  VERSION = "1.0.6"
+  VERSION = "1.1.0"
 end

data/lib/sequence_logo/ytilib.rb

@@ -7,4 +7,4 @@ require_relative 'ytilib/randoom'
 require_relative 'ytilib/bismark'
 require_relative 'ytilib/hack1'
 require_relative 'ytilib/infocod'
-require_relative 'ytilib/ppm_support'
+require_relative 'ytilib/ppm_support'

data/lib/sequence_logo/ytilib/pm.rb

@@ -5,6 +5,18 @@ module Ytilib
     attr_accessor :words_count
     
     alias length size
+
+    def each_position_index(&block)
+      @matrix['A'].each_index(&block)
+    end
+
+    def each_position(&block)
+      return enum_for(:each_position)  unless block_given?
+      @matrix['A'].each_index do |i|
+        position =  ['A', 'C', 'G', 'T'].map{|letter| @matrix[letter][i] }
+        yield position
+      end
+    end
     
     def score_mean(bckgr = Randoom::DEF_PROBS)
       (0...@size).inject(0.0) { |mean, i| mean += ['A','C','G','T'].inject(0.0) { |sum,l| sum += @matrix[l][i] * bckgr[l] } }
@@ -324,12 +336,12 @@ module Ytilib
       attributes = {"length" => @size}
       attributes["words-count"] = @words_count if @words_count && @words_count > 0
       pe = b.add_element( pwm ? "PWM" : "PCM", attributes )
-      (0...@matrix['A'].size).each { |i|
+      each_position_index do |i|
         pm_c = pe.add_element("pm-column", {"position" => i+1})
         ['A', 'C', 'G', 'T'].each { |l|
           pm_c.add_element(l.downcase).add_text(@matrix[l][i].to_s)
         }
-      }
+      end
     end
     
     def PM.from_bismark(b, iupacomp = false)

data/lib/sequence_logo/ytilib/ppm_support.rb

@@ -43,40 +43,25 @@ class PPM
 
 
   def get_logo_weblogo
-    rseq = []
-    @matrix['A'].each_index { |i|
-      rseq << 2 + ['A','C','G','T'].inject(0) { |sum, l|
-        pn = @matrix[l][i]
-        sum += (pn == 0) ? 0 : pn * Math.log(pn) / Math.log(2)
-      }
+    rseq = each_position.map {|position|
+      position.map{|el| (el == 0) ? 0 : el * Math.log2(el) }.inject(0, :+) + 2
     }
-    
-    mat = {'A'=>[], 'C'=>[], 'G'=>[], 'T'=>[]}
-    @matrix['A'].each_index { |i|
-      ['A','C','G','T'].each { |l|
-        mat[l][i]= @matrix[l][i] * rseq[i] / 2 # so we can handle a '2 bit' scale here
-      }
+
+    each_position.with_index.map {|position, ind|
+      position.map{|el| el * rseq[ind] / 2 }
     }
-    
-    mat
   end
 
   def get_logo_discrete
     checkerr("words count is undefined") { !words_count }
     
-    rseq = []
-    @matrix['A'].each_index { |i|
-      rseq << (icd4of4 == 0 ? 1.0 : ( (infocod(i) - icd4of4) / icd4of4 ).abs)
+    rseq = each_position_index.map {|i|
+      (icd4of4 == 0) ? 1.0 : get_line(infocod(i))
     }
-    
-    mat = {'A'=>[], 'C'=>[], 'G'=>[], 'T'=>[]}
-    @matrix['A'].each_index { |i|
-      ['A','C','G','T'].each { |l| 
-        mat[l][i] = @matrix[l][i] * rseq[i]
-      }
+
+    each_position.with_index.map {|position, ind|
+      position.map{|el| el * rseq[ind] }
     }
-    
-    mat
   end
   
   def revcomp

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequence_logo
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.1.0
 platform: ruby
 authors:
 - Ilya Vorontsov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-21 00:00:00.000000000 Z
+date: 2014-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rmagick
@@ -44,14 +44,32 @@ files:
 - bin/glue_logos
 - bin/sequence_logo
 - lib/sequence_logo.rb
+- lib/sequence_logo/alignment.rb
 - lib/sequence_logo/assets/nucl_simpa/a.png
 - lib/sequence_logo/assets/nucl_simpa/c.png
 - lib/sequence_logo/assets/nucl_simpa/g.png
 - lib/sequence_logo/assets/nucl_simpa/t.png
+- lib/sequence_logo/assets/nucl_simpa_bw/a.png
+- lib/sequence_logo/assets/nucl_simpa_bw/c.png
+- lib/sequence_logo/assets/nucl_simpa_bw/g.png
+- lib/sequence_logo/assets/nucl_simpa_bw/t.png
+- lib/sequence_logo/canvas_factory.rb
+- lib/sequence_logo/canvases.rb
+- lib/sequence_logo/canvases/gluing_canvas.rb
+- lib/sequence_logo/canvases/horizontal_gluing_canvas.rb
+- lib/sequence_logo/canvases/logo_canvas.rb
+- lib/sequence_logo/canvases/vertical_gluing_canvas.rb
 - lib/sequence_logo/cli.rb
+- lib/sequence_logo/data_models.rb
+- lib/sequence_logo/data_models/ppm_logo.rb
+- lib/sequence_logo/data_models/predefined_logo.rb
+- lib/sequence_logo/data_models/sequence.rb
+- lib/sequence_logo/data_models/sequence_with_snp.rb
 - lib/sequence_logo/exec/glue_logos.rb
 - lib/sequence_logo/exec/sequence_logo.rb
+- lib/sequence_logo/magick_support.rb
 - lib/sequence_logo/pmflogo_lib.rb
+- lib/sequence_logo/support.rb
 - lib/sequence_logo/version.rb
 - lib/sequence_logo/ytilib.rb
 - lib/sequence_logo/ytilib/addon.rb
@@ -90,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Tool for drawing sequence logos of motifs