sequence_logo 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a53d6d681797aec870766358a55b460aa10a87f1
-  data.tar.gz: 43c4712e2b1bbef50ac8de24626c115c5492dfaf
+  metadata.gz: 6f1c64cbd02b8379d849f555d8aebacffc885886
+  data.tar.gz: b2d2189f7f72a60faa86978d997ab8a240604e45
 SHA512:
-  metadata.gz: 4331c46e148cb21342e7cb5d39ab635ff633086974a3e87d20a8d1efd1534f5590d6df7ccd50f0a5e7eea1d6222fc8a03709a2200f90432083a63a016bf3f9fa
-  data.tar.gz: 7b1013ed36a55848884760f55bb2418789e98fd9cd040e846a8748360889c3bcf34d0a92d520b3e034d501eb21ec2df3948a5d3be41b1b1f22aad699a7546e3b
+  metadata.gz: 900ab873940c8646483a5b56b5596a2cdc606fda91941a33134f82b8e163a50a8dc00f6454a0a8608e78a236deb6b7393f6367e9298c55162befc2e1d2270851
+  data.tar.gz: 7503db8c78201db87ae1069deb9585e86721c4a7d8e0910debfa2c48fc46443411bca8036a72761462acc3cf94f1644092068a20c756185234bc983927569ffc

data/TODO.txt

@@ -8,3 +8,5 @@ And how to make possible use schemes inside the assets path
 Make tests
 
 Wrap execs into methods
+
+remove SolidFill class because it's in a new version of RMagick

data/lib/sequence_logo/canvases/logo_canvas.rb

@@ -1,4 +1,4 @@
-require 'RMagick'
+require 'rmagick'
 require_relative '../magick_support'
 require_relative 'horizontal_gluing_canvas'
 

data/lib/sequence_logo/cli.rb

@@ -21,9 +21,6 @@ module SequenceLogo
         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])

data/lib/sequence_logo/data_models/ppm_logo.rb

@@ -3,19 +3,12 @@ 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
+    attr_reader :ppm, :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
@@ -27,7 +20,7 @@ module SequenceLogo
     end
 
     def revcomp
-      PPMLogo.new(ppm.revcomp, words_count: words_count, icd_mode: icd_mode, enable_threshold_lines: enable_threshold_lines)
+      PPMLogo.new(ppm.revcomp, icd_mode: icd_mode, enable_threshold_lines: enable_threshold_lines)
     end
 
     def logo_matrix
@@ -37,10 +30,11 @@ module SequenceLogo
     def render(canvas_factory)
       canvas = LogoCanvas.new(canvas_factory)
       canvas.background(canvas_factory.background_fill)
+      word_count = ppm.each_position.map{|pos| pos.inject(0.0, &:+) }.max
       if icd_mode == :discrete && 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))
+        canvas.draw_threshold_line( scale(icd2of4(word_count), relative_to: icd4of4(word_count)) )
+        canvas.draw_threshold_line( scale(icdThc(word_count),  relative_to: icd4of4(word_count)) )
+        canvas.draw_threshold_line( scale(icdTlc(word_count),  relative_to: icd4of4(word_count)) )
       end
 
       logo_matrix.each do |position|

data/lib/sequence_logo/di_pm.rb

@@ -0,0 +1,99 @@
+require 'bioinform'
+require 'fileutils'
+
+##########
+module Bioinform
+  module MotifModel
+    class DiPM # Doesn't work with alphabet
+
+      def self.from_file(filename)
+        parser = Bioinform::MatrixParser.new(fix_nucleotides_number: 16)
+        infos = parser.parse(File.read(filename))
+        name = infos[:name] || File.basename(filename, File.extname(filename))
+        pcm = self.new(infos[:matrix]).named(name)
+      end
+
+      attr_reader :matrix
+      def initialize(matrix)
+        @matrix = matrix
+        raise ValidationError.new('invalid matrix', validation_errors: validation_errors)  unless valid?
+      end
+
+      def validation_errors
+        errors = []
+        errors << "matrix should be an Array"  unless matrix.is_a? Array
+        errors << "matrix shouldn't be empty"  unless matrix.size > 0
+        errors << "each matrix position should be an Array"  unless matrix.all?{|pos| pos.is_a?(Array) }
+        errors << "each matrix position should be of size compatible with alphabet (=#{16})"  unless matrix.all?{|pos| pos.size == 16 }
+        errors << "each matrix element should be Numeric"  unless matrix.all?{|pos| pos.all?{|el| el.is_a?(Numeric) } }
+        errors
+      end
+      private :validation_errors
+
+      def valid?
+       validation_errors.empty?
+      rescue
+        false
+      end
+
+      private :valid?
+
+      def to_s
+        MotifFormatter.new.format(self)
+      end
+
+      def named(name)
+        NamedModel.new(self, name)
+      end
+
+      def length
+        matrix.size + 1
+      end
+
+      def ==(other)
+        self.class == other.class && matrix == other.matrix # alphabet should be considered (when alphabet implemented)
+      end
+
+      def each_position
+        if block_given?
+          matrix.each{|pos| yield pos}
+        else
+          self.to_enum(:each_position)
+        end
+      end
+
+    end
+
+    class DiPCM < DiPM
+
+      def sum_dependent_on_first_letter(pos)
+        mono_pos = Array.new(4, 0.0)
+        pos.each.with_index{|count, diletter|
+          first_letter = diletter / 4
+          mono_pos[first_letter] += count
+        }
+        mono_pos
+      end
+
+      def sum_dependent_on_second_letter(pos)
+        mono_pos = Array.new(4, 0.0)
+        pos.each.with_index{|count, diletter|
+          second_letter = diletter % 4
+          mono_pos[second_letter] += count
+        }
+        mono_pos
+      end
+
+      def to_mono
+        mono_matrix = each_position.map{|pos|
+          sum_dependent_on_first_letter(pos)
+        } + [ sum_dependent_on_second_letter(matrix.last) ]
+
+        PCM.new(mono_matrix)
+      end
+    end
+
+    class DiPWM < DiPM
+    end
+  end
+end

data/lib/sequence_logo/exec/glue_logos.rb

@@ -9,8 +9,7 @@ def load_alignment_infos(alignment_lines)
     shift = shift.to_i
     orientation = orientation.downcase.to_sym
 
-    ppm = get_ppm_from_file(filename)
-    checkerr("bad input file: #{filename}") { ppm == nil }
+    ppm = Bioinform::MotifModel::PCM.from_file(filename)
     ppm.name ||= motif_name
 
     raise 'Unknown orientation'  unless [:direct, :revcomp].include?(orientation)
@@ -25,7 +24,6 @@ def make_logo_alignment(aligned_motifs, options)
   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])
   }
@@ -79,7 +77,7 @@ begin
   argv = ARGV
   total_orientation = :direct
   default_options = { x_unit: 30, y_unit: 60, logo_shift: 300, scheme: 'nucl_simpa',
-                      words_count: nil, icd_mode: :discrete, threshold_lines: false,
+                      icd_mode: :discrete, threshold_lines: false,
                       text_size: 24, background_color: 'white' }
   cli = SequenceLogo::CLI.new(default_options)
   cli.instance_eval do

data/lib/sequence_logo/exec/sequence_logo.rb

@@ -45,8 +45,9 @@ begin
 
   argv = ARGV
   default_options = { x_unit: 30, y_unit: 60, scheme: 'nucl_simpa',
-                      words_count: nil, orientation: :direct, icd_mode: :discrete, threshold_lines: true,
-                      logo_folder: '.', background_color: 'white' }
+                      orientation: :direct, icd_mode: :discrete, threshold_lines: true,
+                      logo_folder: '.', background_color: 'white',
+                      from_dinucleotide: false }
   cli = SequenceLogo::CLI.new(default_options)
   cli.instance_eval do
     parser.banner = doc
@@ -72,6 +73,8 @@ begin
         options[:background_fill] = Magick::SolidFill.new(v)
       end
     end
+
+    parser.on('--dinucleotide'){ options[:from_dinucleotide] = true }
   end
   options = cli.parse_options!(argv)
 
@@ -107,12 +110,14 @@ begin
     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 }
+      if options[:from_dinucleotide]
+        ppm = Bioinform::MotifModel::DiPCM.from_file(filename).to_mono
+      else
+        ppm = Bioinform::MotifModel::PCM.from_file(filename)
+      end
 
       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.basename_wo_extname(filename)}
     end

data/lib/sequence_logo/magick_support.rb

@@ -1,4 +1,4 @@
-require 'RMagick'
+require 'rmagick'
 
 module Magick
   class ImageList

data/lib/sequence_logo/pmflogo_lib.rb

@@ -2,4 +2,5 @@ require_relative 'canvases'
 require_relative 'canvas_factory'
 require_relative 'alignment'
 require_relative 'data_models'
-require_relative 'ytilib'
+require_relative 'ppm_support'
+require_relative 'di_pm'

data/lib/sequence_logo/ppm_support.rb

@@ -0,0 +1,81 @@
+require 'bioinform'
+
+class Float
+  def log_fact
+    Math.lgamma(self + 1).first
+  end
+end
+
+class Integer
+  def log_fact
+    self.to_f.log_fact
+  end
+end
+
+def position_infocod(pos)
+  words_count = pos.inject(0.0, &:+)
+  ( pos.map(&:log_fact).inject(0.0, &:+) - words_count.log_fact ) / words_count
+end
+
+def icd4of4(words_count, floor: false)
+  i4o4 = words_count / 4.0
+  i4o4 = i4o4.floor  if floor
+  position_infocod([i4o4, i4o4, i4o4, i4o4])
+end
+
+def icd2of4(words_count, floor: false)
+  i2o4 = words_count / 2.0
+  i2o4 = i2o4.floor if floor
+  position_infocod([i2o4, i2o4, 0, 0]) # 0 is equal to words_count % 2, because 0! = 1!
+end
+
+def icd3of4(words_count, floor: false)
+  i3o4 = words_count / 3.0
+  i3o4 = i3o4.floor if floor
+  addon = floor ? words_count % 3 : 0
+  position_infocod([i3o4, i3o4, i3o4, addon])
+end
+
+def icdThc(words_count, floor: false)
+  icd3of4(words_count, floor: floor)
+end
+
+def icdTlc(words_count, floor: false)
+  io = words_count / 6.0
+  io = io.floor  if floor
+  position_infocod([2*io, 2*io, io, io])
+end
+
+def scale(value, relative_to:)
+  ( (value - relative_to) / relative_to ).abs
+end
+
+class Bioinform::MotifModel::PCM
+  def get_logo(icd_mode)
+    case icd_mode.to_s
+    when 'weblogo'
+      get_logo_weblogo
+    when 'discrete'
+      get_logo_discrete
+    end
+  end
+
+  def get_logo_weblogo
+    each_position.map{|position|
+      word_count = position.inject(0.0, &:+)
+      inf_content = position.map{|el|
+        (el == 0) ? 0 : (el / word_count) * Math.log2(el / word_count)
+      }.inject(0.0, :+) + 2
+      position.map{|el| (el / word_count) * inf_content / 2 }
+    }
+  end
+
+  def get_logo_discrete
+    each_position.map{|position|
+      word_count = position.inject(0.0, &:+)
+      icd4of4 = icd4of4(word_count)
+      inf_content = (icd4of4 == 0) ? 1.0 : scale(position_infocod(position), relative_to: icd4of4)
+      position.map{|el| (el / word_count) * inf_content }
+    }
+  end
+end

data/lib/sequence_logo/version.rb

@@ -1,3 +1,3 @@
 module SequenceLogo
-  VERSION = "1.1.2"
+  VERSION = "1.2.0"
 end

data/lib/sequence_logo/ytilib/ppm_support.rb

@@ -1,70 +0,0 @@
-class Object
-  def deep_dup
-    Marshal.load(Marshal.dump(self))
-  end
-end
-
-def get_ppm_from_file(in_file_name)
-  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.get_ppm
-rescue
-  nil
-end
-
-class PPM
-  attr_accessor :name
-  
-  def get_ppm
-    self
-  end
-  
-  def get_line(v)
-    ( (v - icd4of4) / icd4of4 ).abs
-  end
-
-  def get_logo(icd_mode)
-    case icd_mode.to_s
-    when 'weblogo'
-      get_logo_weblogo
-    when 'discrete'
-      get_logo_discrete
-    end
-  end
-
-
-  def get_logo_weblogo
-    rseq = each_position.map {|position|
-      position.map{|el| (el == 0) ? 0 : el * Math.log2(el) }.inject(0, :+) + 2
-    }
-
-    each_position.with_index.map {|position, ind|
-      position.map{|el| el * rseq[ind] / 2 }
-    }
-  end
-
-  def get_logo_discrete
-    checkerr("words count is undefined") { !words_count }
-    
-    rseq = each_position_index.map {|i|
-      (icd4of4 == 0) ? 1.0 : get_line(infocod(i))
-    }
-
-    each_position.with_index.map {|position, ind|
-      position.map{|el| el * rseq[ind] }
-    }
-  end
-  
-  def revcomp
-    deep_dup.revcomp!
-  end
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequence_logo
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Ilya Vorontsov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-05 00:00:00.000000000 Z
+date: 2015-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rmagick
@@ -69,23 +69,15 @@ files:
 - 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/di_pm.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/ppm_support.rb
 - lib/sequence_logo/support.rb
 - lib/sequence_logo/version.rb
-- lib/sequence_logo/ytilib.rb
-- lib/sequence_logo/ytilib/addon.rb
-- lib/sequence_logo/ytilib/bismark.rb
-- lib/sequence_logo/ytilib/hack1.rb
-- lib/sequence_logo/ytilib/infocod.rb
-- lib/sequence_logo/ytilib/iupac.rb
-- lib/sequence_logo/ytilib/pm.rb
-- lib/sequence_logo/ytilib/pmsd.rb
 - lib/sequence_logo/ytilib/ppm_support.rb
-- lib/sequence_logo/ytilib/randoom.rb
-- lib/sequence_logo/ytilib/ytilib.rb
 - sequence_logo.gemspec
 - test/data/logo/AHR_si_direct.png
 - test/data/logo/AHR_si_revcomp.png
@@ -112,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Tool for drawing sequence logos of motifs