sequence_logo 1.0.2 → 1.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ebd54ee5bf1c9fece6a4441f6c6e680c6a0af742
+  data.tar.gz: 7db836f3a01d63b71200496227da726cb681698e
+SHA512:
+  metadata.gz: 03ff397f94506ebc41098bb1d897ed078496d70f516e5193ef5006a3db686cd95dcea45e42c410f87f8ecbc7c74eec0015f4d10a133bd1136058d39ed7dad05c
+  data.tar.gz: 6bb47ee9237f020ea1de0d566642e813fc7de8e7eb87089bbac0259c26f8f5e22b192b3f2269ba0e8feba045e92bc6f5b965266547b5e2600ddb00d07655a350

data/.gitignore

@@ -1,17 +1,17 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in sequence_logo.gemspec
-gemspec
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sequence_logo.gemspec
+gemspec

data/LICENSE

@@ -1,22 +1,22 @@
-Copyright (c) 2012 Ilya Vorontsov
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+Copyright (c) 2012 Ilya Vorontsov
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,61 +1,66 @@
-# SequenceLogo
-
-SequenceLogo is a tool for drawing sequence logos of motifs. It gets Positional Count Matrices(PCMs) at input and generates png-logos for motif. Also one can create logo for reverse complement or even generate logos for a whole collection of motifs.
-Sequence logos are a graphical representation of an amino acid or nucleic acid multiple sequence alignment developed by Tom Schneider and Mike Stephens. Each logo consists of stacks of symbols, one stack for each position in the sequence. The overall height of the stack indicates the sequence conservation at that position, while the height of symbols within the stack indicates the relative frequency of each amino or nucleic acid at that position. In general, a sequence logo provides a richer and more precise description of, for example, a binding site, than would a consensus sequence (see http://weblogo.berkeley.edu/)
- 
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'sequence_logo'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install sequence_logo
-
-## Usage
-
-SequenceLogo consists of three tools:
-* The most flexible tool **pmflogo** generates single logo for a single motif. It has quite complicated usage format:
-  
-    pmflogo \<input_file\> \<output_logo_filename\> [words_count] [x_unit=100] [y_size=200] [icd_mode=discrete|weblogo] [revcomp=no|yes] [scheme=nucl_simpa] [paper_mode=no|yes] [threshold_lines=yes|no]
-  
-  Any optional argument can be set as 'default', skipped parameters are also substituted as default (in example below icd_mode is default, and also scheme, paper_mode and threshold_lines): `pmflogo motif.pcm logo.png default 30 60 default yes`
-
-  Required arguments:
-    * input_file can be either in PCM format (file extension should be .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).
-    * output_logo_filename is output logo file with format .png (extension should be included into name) which will be generated
-    
-  Optional parameters:
-    * words_count [=default] is a float number that represents alignment weight. If words_count is set to 'default' - it'd be obtained from input (if it's PCM or IUPAC). In some cases (when PPM is used) words_count can't be obtained. In such a case discrete logo can't be drawn, and weblogo will be drawn instead.
-    * x_unit - width of a single letter
-    * y_size - full height of an image
-    * icd_mode - information content mode
-    * revcomp - create logo for a direct or reverse-complement orientation
-    * scheme - nucleotide images folder name (by default only one scheme is used)
-    * paper_mode - if paper_mode is true then threshold lines won't be drawn but a border is drawn instead
-    * threshold_lines - lines on levels: icd2of4, icdThc(=icd3of4), icdTlc, - relative to icd4of4
-  
-* Tool **generate_logo** generates two logos - direct and reverse-complement with some reasonable defaults for a single motif and puts a logo in a logo_folder
-  
-    generate_logo \<motif_filename\> [logo_folder = directory of input motif file]
-
-* Tool **create_all_logos** generates two logos - direct and reverse-complement with some reasonable defaults for each motif in a folder and puts all logos in a logo_folder
-
-    create_all_logos \<motifs_folder> \<logo_folder>
- 
- 
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
+# SequenceLogo
+
+SequenceLogo is a tool for drawing sequence logos of motifs. It gets Positional Count Matrices(PCMs) at input and generates png-logos for motif. Also one can create logo for reverse complement or even generate logos for a whole collection of motifs.
+Sequence logos are a graphical representation of an amino acid or nucleic acid multiple sequence alignment developed by Tom Schneider and Mike Stephens. Each logo consists of stacks of symbols, one stack for each position in the sequence. The overall height of the stack indicates the sequence conservation at that position, while the height of symbols within the stack indicates the relative frequency of each amino or nucleic acid at that position. In general, a sequence logo provides a richer and more precise description of, for example, a binding site, than would a consensus sequence (see http://weblogo.berkeley.edu/)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sequence_logo'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sequence_logo
+
+## Usage
+
+SequenceLogo consists of two tools:
+
+    sequence_logo [options] <input files>...
+
+  *input_file* can be either in PCM format (file extension should be .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). In future releases formats except PCM and PPM will be removed in preference of Unix-like modular style.
+
+  Optional parameters:
+
+    * --x-unit SIZE - width of a single letter
+    * --y-unit SIZE - base height of a letter
+    * --words-count WEIGHT - float number that represents alignment weight. If words count not defined - it'd be obtained from input if input file is a PCM. If input file is a PPM words_count can't be obtained. In such a case discrete logo can't be drawn, and weblogo will be drawn instead.
+    * --icd-mode <weblogo|discrete> - information content mode
+    * --orientation <direct|revcomp|both> - create logo for a direct, reverse-complement or both orientations of motif
+    * --scheme FOLDER - name of folder containing nucleotide images
+    * --threshold-lines - draw lines on specific levels
+
+* Tool **glue_logos** generates a single image of aligned motifs.
+
+      `glue_logos <output file> <file with alignment infos>`
+    
+  or
+      
+      `<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:  
+      pcm_file_1  shift_1  orientation_1  
+      pcm_file_2  shift_2  orientation_2        
+      pcm_file_3  shift_3  orientation_3  
+      
+  So it's simple to run
+  
+      align_motifs --pcm leader.pcm other_motifs_1.pcm other_motifs_2.pcm | glue_logos cluster.png
+    
+  Don't forget to specify PCM files instead of PWM files and use `--pcm` key in align_motifs.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
 Copyright (c) 2011-2012 Ivan Kulakovskiy(author), Ilya Vorontsov(refactoring and gemification)

data/Rakefile

@@ -1,5 +1,5 @@
-#!/usr/bin/env rake
-require 'bundler/gem_tasks'
-
-# require 'rspec/core/rake_task'
-# RSpec::Core::RakeTask.new
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+
+# require 'rspec/core/rake_task'
+# RSpec::Core::RakeTask.new

data/TODO.txt

@@ -0,0 +1,8 @@
+AssetsPath shouldn't be used at draw_logo level because it makes it impossible to change scheme on one folder that is outside the gem
+And how to make possible use schemes inside the assets path
+
+Make use of Tempfile in glue_logos.
+
+Make tests
+
+Wrap execs into methods

data/bin/glue_logos

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/sequence_logo/exec/glue_logos.rb'

data/bin/sequence_logo

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/sequence_logo/exec/sequence_logo.rb'

data/lib/sequence_logo.rb

@@ -1,7 +1,7 @@
-require 'sequence_logo/version'
-require 'sequence_logo/pmflogo_lib'
-
-module SequenceLogo
-  AssetsPath = File.join(File.dirname(__FILE__), 'sequence_logo', 'assets')
-  # Your code goes here...
-end
+require_relative 'sequence_logo/version'
+require_relative 'sequence_logo/pmflogo_lib'
+require_relative 'sequence_logo/cli'
+
+module SequenceLogo
+  AssetsPath = File.join(File.dirname(__FILE__), 'sequence_logo', 'assets')
+end

data/lib/sequence_logo/cli.rb

@@ -0,0 +1,37 @@
+require 'fileutils'
+require 'optparse'
+module SequenceLogo
+  class CLI
+    attr_reader :options
+    def initialize(options = {})
+      @options = options.dup
+    end
+    def parse_options!(argv)
+      parser.parse!(argv)
+      options
+    end
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.on('-x', '--x-unit X_UNIT', 'Single letter width') do |v|
+          options[:x_unit] = v.to_i
+        end
+        opts.on('-y', '--y-unit Y_UNIT', 'Base letter height') do |v|
+          options[:y_unit] = v.to_i
+        end
+        opts.on('--words-count WEIGHT', 'Define alignment weight') do |v|
+          options[:words_count] = v.to_f
+        end
+        opts.on('--icd-mode MODE', 'Calculation mode: discrete or weblogo', 'Weblogo is assumed if word count not given') do |v|
+          options[:icd_mode] = v.to_sym
+          raise ArgumentError, 'icd-mode can be either discrete or weblogo'  unless [:discrete, :weblogo].include?(options[:icd_mode])
+        end
+        opts.on('--[no-]threshold-lines', 'Draw threshold lines') do |v|
+          options[:threshold_lines] = v
+        end
+        opts.on('--scheme SCHEME', 'Specify folder with nucleotide images') do |v|
+          options[:scheme] = v
+        end
+      end
+    end
+  end
+end

data/lib/sequence_logo/exec/glue_logos.rb

@@ -0,0 +1,67 @@
+require_relative '../../sequence_logo'
+require 'fileutils'
+
+begin
+  doc = <<-EOS
+  Usage:
+    glue_logos <output file> <alignment infos file>
+      or
+    <alignment infos file> | glue_logos <output file>
+
+  Alignment infos has format:
+    pcm_file_1  shift_1  orientation_1
+    pcm_file_2  shift_2  orientation_2
+    pcm_file_3  shift_3  orientation_3
+  EOS
+
+  argv = ARGV
+  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}
+  cli = SequenceLogo::CLI.new(default_options)
+  cli.instance_eval do
+    parser.banner = doc
+    parser.on_head('--logo-shift SHIFT', 'Width of region for labels') do |v|
+      options[:logo_shift] = v.to_i
+    end
+    parser.on_head('--text-size SIZE', 'Text size in points') do |v|
+      options[:text_size] = v.to_f
+    end
+  end
+  options = cli.parse_options!(argv)
+
+  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
+
+  logos = {}
+  logo_filenames = []
+  alignment_infos.each do |line|
+    filename, shift, orientation = line.strip.split("\t")
+    ppm = get_ppm_from_file(filename)
+    checkerr("bad input file: #{filename}") { ppm == nil }
+    shift = shift.to_i
+    logo_filename = "#{filename}_temp.png"
+    logo_filenames << logo_filename
+    case orientation
+    when 'direct'
+      SequenceLogo.draw_logo(ppm, options).write(logo_filename)
+    when 'revcomp'
+      SequenceLogo.draw_logo(ppm.revcomp, options).write(logo_filename)
+    else
+      raise "Unknown orientation #{orientation} for #{filename}"
+    end
+    logos[logo_filename] = {shift: shift, length: ppm.length, name: File.basename(filename, File.extname(filename))}
+  end
+
+  SequenceLogo.glue_files(logos, output_file, options)
+  logo_filenames.each{|filename| File.delete(filename) }
+rescue => err
+  $stderr.puts "\n#{err}\n#{err.backtrace.first(5).join("\n")}\n\nUse --help option for help\n\n#{doc}"
+end

data/lib/sequence_logo/exec/sequence_logo.rb

@@ -0,0 +1,52 @@
+require_relative '../../sequence_logo'
+require 'shellwords'
+
+begin
+  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).
+  Usage:
+    sequence_logo [options] <pcm/ppm file>...
+      or
+    ls pcm_folder/*.pcm | sequence_logo [options]
+  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'}
+  cli = SequenceLogo::CLI.new(default_options)
+  cli.instance_eval do
+    parser.banner = doc
+    parser.on_head('--logo-folder FOLDER', 'Folder to store generated logos') do |v|
+      options[:logo_folder] = v
+    end
+    parser.on_head('--orientation ORIENTATION', 'Which logo to draw: direct/revcomp/both') do |v|
+      v = v.to_sym
+      raise ArgumentError, 'Orientation can be either direct or revcomp or both'  unless [:direct, :revcomp, :both].include?(v)
+      options[:orientation] = v
+    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?
+
+  filenames.each do |filename|
+    ppm = get_ppm_from_file(filename)
+    checkerr("bad input file: #{filename}") { ppm == nil }
+
+    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)
+    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)
+    end
+  end
+rescue => err
+  $stderr.puts "\n#{err}\n#{err.backtrace.first(5).join("\n")}\n\nUse --help option for help\n\n#{doc}"
+end

data/lib/sequence_logo/pmflogo_lib.rb

@@ -1,193 +1,114 @@
-require 'sequence_logo/ytilib'
+require_relative 'ytilib'
 require 'RMagick'
 
-class PPM
-  def get_ppm
-    self
-  end
-  
-  def get_line(v)
-    ( (v - icd4of4) / icd4of4 ).abs
+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 get_logo(icd_mode)
-    if icd_mode == :weblogo
-      get_logo_weblogo
+
+  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
-      get_logo_discrete
+      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
 
-  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)
-      }
-    }
-    
-    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
-      }
-    }
-    
-    mat
+    letter_files = %w[a c g t].collect{|letter| File.join(scheme_dir, "#{letter}.#{extension}") }
+    Magick::ImageList.new(*letter_files)
   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)
-    }
-    
-    mat = {'A'=>[], 'C'=>[], 'G'=>[], 'T'=>[]}
-    @matrix['A'].each_index { |i|
-      ['A','C','G','T'].each { |l| 
-        mat[l][i] = @matrix[l][i] * rseq[i]
+  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 )
       }
     }
-    
-    mat
-  end
-end
-
-def get_ppm_from_file(in_file_name, words_count)
-  case File.ext_wo_name(in_file_name)
-  when 'pat', 'pcm'
-    pm = PM.load(in_file_name)
-    pm.fixwc  if pm.words_count
-  when 'mfa', 'fasta', 'plain'
-    pm = PM.new_pcm(Ytilib.read_seqs2array(in_file_name))
-  when 'xml'
-    pm = PM.from_bismark(Bismark.new(in_file_name).elements["//PPM"])
-  when in_file_name
-    pm = PPM.from_IUPAC(in_file_name.upcase)
   end
-  pm = pm.get_ppm
-  pm.words_count = words_count  if words_count
-  pm
-end
-
-def create_canvas(x_size, y_size, icd_mode, paper_mode, threshold_lines, pm)
-  
-  i_logo = Magick::ImageList.new
-  if paper_mode
-    i_logo.new_image(x_size, y_size)
-  else
-    if icd_mode == :discrete
-      i_logo.new_image(x_size, y_size, Magick::HatchFill.new('white', 'white'))
-      if threshold_lines
-        dr = Magick::Draw.new
-        dr.fill('transparent')
-        
-        dr.stroke_width(y_size / 200.0)
-        dr.stroke_dasharray(7,7)
-        
-        line2of4 = y_size - pm.get_line(pm.icd2of4) * y_size
-        lineThc = y_size - pm.get_line(pm.icdThc) * y_size
-        lineTlc = y_size - pm.get_line(pm.icdTlc) * y_size
-        
-        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
-    else
-      i_logo.new_image(x_size, y_size, Magick::HatchFill.new('white', 'bisque'))
+
+  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
-  i_logo
-end
-
-def letter_images(scheme_dir)
-  if File.exist?(File.join(scheme_dir,'a.png'))
-    lp = {'A' => File.join(scheme_dir,'a.png'), 'C' => File.join(scheme_dir,'c.png'), 'G' => File.join(scheme_dir,'g.png'), 'T' => File.join(scheme_dir,'t.png')}
-  elsif File.exist?(File.join(scheme_dir,'a.gif'))
-    lp = {'A' => File.join(scheme_dir,'a.gif'), 'C' => File.join(scheme_dir,'c.gif'), 'G' => File.join(scheme_dir,'g.gif'), 'T' => File.join(scheme_dir,'t.gif')}
-  else
-    raise "Scheme not exists in folder #{scheme_dir}"
-  end
-  i_letters = Magick::ImageList.new(lp['A'], lp['C'], lp['G'], lp['T'])
-end
-
-def draw_letters_on_canvas(i_logo, i_letters, matrix, y_size, x_unit)
-  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_size * matrix[letter][i] <= 1
-      letter_index = {'A' => 0, 'C' => 1, 'G' => 2, 'T' => 3}[letter]
-      y_block = (y_size * 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_size - y_pos )
-    }
-  }
-end
-
-
-def draw_logo(in_file_name, out_file_name, options = {})
-  default_options = { words_count: nil,
-                      x_unit: 100,
-                      y_size: 200,
-                      icd_mode: 'discrete',
-                      revcomp: false,
-                      scheme: 'nucl_simpa',
-                      paper_mode: false,
-                      threshold_lines: true }
-
-  options = options.reject{|k,v| v == 'default' || v == :default}
-  options = default_options.merge( options )
-
-  x_unit = options[:x_unit].to_i
-  y_size = options[:y_size].to_i
-  icd_mode = options[:icd_mode].to_sym
-  scheme = options[:scheme]
-  
-  words_count = options[:words_count]
-  words_count = words_count.to_f  if words_count
-  
-  revcomp = options[:revcomp]
-  revcomp = false  if revcomp == 'no' || revcomp == 'false' || revcomp == 'direct'
-  
-  paper_mode = options[:paper_mode]
-  paper_mode = false  if paper_mode == 'no' || paper_mode == 'false'
-
-  threshold_lines = options[:threshold_lines]
-  threshold_lines = false  if threshold_lines == 'no' || threshold_lines == 'false'
-  
-  ########################
-  
-  pm = get_ppm_from_file(in_file_name, words_count)
-  checkerr("bad input file") { pm == nil }
-  
-  x_size = x_unit * pm.length
-  
-  
-  unless pm.words_count
-    report "words count for PM is undefined, assuming weblogo mode"
-    icd_mode = :weblogo
-  end
-  
-  i_logo = create_canvas(x_size, y_size, icd_mode, paper_mode, threshold_lines, pm)
-  
-  pm.revcomp! if revcomp
-  matrix = pm.get_logo(icd_mode)
 
-  scheme_dir = File.join(SequenceLogo::AssetsPath, scheme)
-  i_letters = letter_images(scheme_dir)
-  draw_letters_on_canvas(i_logo, i_letters, matrix, y_size, x_unit)
+  # 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
 
-  i_logo = i_logo.flatten_images
-  i_logo.cur_image.border!(x_unit / 100 + 1, x_unit / 100 + 1, icd_mode == :discrete ? "green" : "red") if paper_mode
+    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
 
-  i_logo.write(out_file_name)
+    system(command_string + command_draw_names + "\"#{output_file}\"")
+  end
 end