semin-egor 0.9.0

data/lib/egor/environment.rb

@@ -0,0 +1,34 @@
+module Egor
+  class Environment
+
+    attr_accessor :amino_acids,
+      :number,
+      :label,
+      :freq_array,
+      :prob_array,
+      :logo_array,
+      :smooth_prob_array
+
+    def initialize(number, label, amino_acids = "ACDEFGHIKLMNPQRSTVWYJ".split(''))
+      @amino_acids        = amino_acids
+      @number             = number
+      @label              = label
+      @freq_array         = $noweight ? NArray.int(@amino_acids.size) : NArray.float(@amino_acids.size)
+      @prob_array         = NArray.float(@amino_acids.size)
+      @logo_array         = NArray.float(@amino_acids.size)
+      @smooth_prob_array  = NArray.float(@amino_acids.size)
+    end
+
+    def increase_residue_count(a, inc = 1.0)
+      @freq_array[@amino_acids.index(a.upcase)] += inc
+    end
+
+    def label_set
+      label.split("").map_with_index { |l, i| "#{i}#{l}" }.to_set
+    end
+
+    def to_s
+      "#{number}-#{label}"
+    end
+  end
+end

data/lib/egor/environment_class_hash.rb

@@ -0,0 +1,20 @@
+module Egor
+  class EnvironmentClassHash < Hash
+
+    def group_by_non_residue_labels
+      self.values.group_by { |env| env.label[1..-1] }
+    end
+
+    def groups_sorted_by_residue_labels
+      group_by_non_residue_labels.to_a.sort_by { |env_group|
+        env_group[0].split('').map_with_index { |l, i|
+          $env_features[i + 1].labels.index(l)
+        }
+      }
+    end
+
+    def group_size
+      group_by_non_residue_labels.size
+    end
+  end
+end

data/lib/egor/environment_feature.rb

@@ -0,0 +1,16 @@
+module Egor
+  class EnvironmentFeature < Struct.new(:name, :symbols, :labels, :constrained, :silent)
+
+    def to_s
+      [name, symbols.join, labels.join, constrained, silent].join(";")
+    end
+
+    def constrained?
+      constrained == "T"
+    end
+
+    def silent?
+      silent == "T"
+    end
+  end
+end

data/lib/egor/environment_feature_array.rb

@@ -0,0 +1,12 @@
+module Egor
+  class EnvironmentFeatureArray < Array
+
+    def label_combinations
+      self.inject([]) { |sum, ec|
+        sum << ec.labels
+      }.inject { |pro, lb|
+        pro.product(lb)
+      }
+    end
+  end
+end

data/lib/egor/heatmap_array.rb

@@ -0,0 +1,111 @@
+require 'rubygems'
+require 'facets'
+
+begin
+  require 'RMagick'
+  include Magick
+rescue
+  $logger.warn "A RubyGems package, 'rmagick' is not found, so heat maps cannot be generated."
+  $no_rmagick = true
+end
+
+
+
+module Egor
+  class HeatmapArray < Array
+
+    def heatmap(options = {})
+      if $no_rmagick
+        return nil
+      end
+
+      opts = {:columns                => 4,
+              :rvg_width              => nil,
+              :dpi                    => 100,
+              :title                  => '',
+              :max_val                => nil,
+              :mid_val                => nil,
+              :min_val                => nil,
+              :print_gradient         => true,
+              :gradient_beg_color     => '#FFFFFF',
+              :gradient_mid_color     => nil,
+              :gradient_end_color     => '#FF0000',
+              :gradient_border_width  => 1,
+              :gradient_border_color  => '#000000'}.merge(options)
+
+      row_images = ImageList.new
+
+      self.each_by(opts[:columns]) { |maps|
+        images = ImageList.new
+        maps.each { |m| images << m }
+        row_images << images.append(false)
+      }
+
+      tbl_img = row_images.append(true)
+
+      unless opts[:print_gradient]
+        return tbl_img
+      else
+        RVG::dpi    = opts[:dpi]
+        rvg_width   = opts[:rvg_width] * opts[:columns]
+        rvg_height  = rvg_width / 10.0
+
+        rvg = RVG.new(rvg_width, rvg_height) do |canvas|
+          canvas.viewbox(0, 0, rvg_width, rvg_height)
+          canvas.background_fill = 'white'
+          canvas.desc = 'gradient key'
+
+          gradient_width = rvg_width / 2.0
+          gradient_height = gradient_width / 15.0
+
+          if opts[:gradient_mid_color]
+            img1  = Image.new(gradient_width / 2,
+                              gradient_height,
+                              GradientFill.new(0, 0, 0, gradient_width / 2,
+                                               opts[:gradient_beg_color], opts[:gradient_mid_color]))
+
+            img2  = Image.new(gradient_width / 2,
+                              gradient_height,
+                              GradientFill.new(0, 0, 0, gradient_width / 2,
+                                               opts[:gradient_mid_color], opts[:gradient_end_color]))
+
+            img3  = ImageList.new
+            img3  << img1 << img2
+            img   = img3.append(false)
+          else
+            img = Image.new(gradient_width,
+                            gradient_height,
+                            GradientFill.new(0, 0, 0, gradient_width,
+                                             opts[:gradient_beg_color], opts[:gradient_end_color]))
+          end
+
+          img.border!(opts[:gradient_border_width],
+                      opts[:gradient_border_width],
+                      opts[:gradient_border_color])
+
+          gradient_x = (rvg_width - gradient_width) / 2.0
+          gradient_y = (rvg_height - gradient_height) / 2.0
+          gradient_font_size = rvg_width / 45.0
+
+          canvas.image(img,
+                       gradient_width,
+                       gradient_height,
+                       gradient_x,
+                       gradient_y)
+
+          canvas.text(gradient_x,
+                      gradient_y + gradient_height + gradient_font_size * 1.1,
+                      "#{'%.1f' % opts[:min_val]}").styles(:font_size => gradient_font_size)
+
+          canvas.text(gradient_x + gradient_width,
+                      gradient_y + gradient_height + gradient_font_size * 1.1,
+                      "#{'%.1f' % opts[:max_val]}").styles(:font_size => gradient_font_size)
+        end
+
+        fin_img = ImageList.new
+        fin_img << tbl_img << rvg.draw
+        fin_img.append(true)
+      end
+    end
+  end
+end

data/lib/egor.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Egor
+  VERSION = '0.9.0'
+end

data/lib/math_extensions.rb

@@ -0,0 +1,7 @@
+module MathExtensions
+  def log2(val)
+    log(val) / log(2)
+  end
+end
+
+Math.extend(MathExtensions)

data/lib/narray_extensions.rb

@@ -0,0 +1,22 @@
+#require 'rubygems'
+require 'narray'
+require 'facets'
+
+module NArrayExtensions
+
+  def pretty_string(opts={})
+    { :col_header   => nil,
+      :row_header   => nil }.merge!(opts)
+
+    ("%-3s" % "#") + opts[:col_header].inject("") { |s, a| s + ("%7s" % a) } + "\n" +
+      self.to_a.inject("%-3s" % opts[:row_header]) { |s, v|
+      if v.is_a? Float
+        s + ("%7.2f" % v)
+      else
+        s + ("%7d" % v)
+      end
+    }
+  end
+end
+
+NArray.send(:include, NArrayExtensions)

data/lib/nmatrix_extensions.rb

@@ -0,0 +1,245 @@
+require 'rubygems'
+require 'narray'
+require 'facets'
+
+begin
+  require 'rvg/rvg'
+  include Magick
+rescue
+  $logger.warn "A RubyGems package, 'rmagick' is not found, so heat maps cannot be generated."
+  $no_rmagick = true
+end
+
+module NMatrixExtensions
+
+  def pretty_string(options={})
+    opts = {:col_header   => nil,
+            :row_header   => nil }.merge(options)
+
+    ("%-3s" % "#") + opts[:col_header].inject("") { |s, a|
+      s + ("%7s" % a)
+    } + "\n" + self.to_a.map_with_index { |a, i|
+      ("%-3s" % opts[:row_header][i]) + a.inject("") { |s, v|
+        if v.is_a? Float
+          s + ("%7.2f" % v)
+        else
+          s + ("%7d" % v)
+        end
+      }
+    }.join("\n")
+  end
+
+  def heatmap(options={})
+    if $no_rmagick
+      return nil
+    end
+
+    opts = {:col_header             => 'ACDEFGHIKLMNPQRSTVWYJ'.split(''),
+            :row_header             => 'ACDEFGHIKLMNPQRSTVWYJ'.split(''),
+            :max_val                => self.max,
+            :mid_val                => (self.max - self.min) / 2.0,
+            :min_val                => self.min,
+            :dpi                    => 100,
+            :margin_width           => 30,
+            :rvg_width              => nil,
+            :rvg_height             => nil,
+            :canvas_width           => nil,
+            :canvas_height          => nil,
+            :cell_width             => 20,
+            :cell_height            => 20,
+            :cell_border_color      => '#888888',
+            :cell_border_width      => 1,
+            :table_border_color     => '#000000',
+            :table_border_width     => 2,
+            :header_height          => 100,
+            :footer_height          => 50,
+            :print_gradient         => true,
+            :gradient_width         => 300,
+            :gradient_height        => 30,
+            :gradient_beg_color     => '#FFFFFF',
+            :gradient_mid_color     => nil,
+            :gradient_end_color     => '#FF0000',
+            :gradient_border_width  => 1,
+            :gradient_border_color  => '#000000',
+            :font_scale             => 0.9,
+            :font_family            => 'san serif',
+            :small_gap_width        => 2,
+            :title?                 => true,
+            :title                  => '',
+            :title_font_size        => 35,
+            :print_value            => false,
+            :key_font_size          => 15,
+            :value_font_size        => 8,
+            :background             => '#FFFFFF'}.merge(options)
+
+    RVG::dpi = opts[:dpi]
+
+    rvg = RVG.new(opts[:rvg_width], opts[:rvg_height]) do |canvas|
+      title_x = (opts[:canvas_width] - opts[:title].length * opts[:title_font_size] * 0.6) / 2.0
+      title_y = opts[:header_height] - opts[:title_font_size]
+
+      canvas.viewbox(0, 0, opts[:canvas_width], opts[:canvas_height])
+      canvas.background_fill = opts[:background]
+      canvas.desc = opts[:title]
+
+      if opts[:title?]
+        canvas.text(title_x, title_y, opts[:title]).styles(:font_size => opts[:title_font_size])
+      end
+
+      # border for whole matrix
+      table_x = (opts[:canvas_width] - opts[:cell_width] * self.shape[0]) / 2.0
+      table_y = opts[:header_height] + opts[:cell_height]
+
+      canvas.rect(self.shape[0] * opts[:cell_width],
+                  self.shape[1] * opts[:cell_height],
+                  table_x,
+                  table_y).styles(:stroke       => opts[:table_border_color],
+                                  :stroke_width => opts[:table_border_width])
+
+      # drawing column and row labels
+      0.upto(self.shape[0] - 1) do |col|
+        canvas.text(table_x + col * opts[:cell_width] + opts[:small_gap_width],
+                    opts[:cell_height] + opts[:header_height] - opts[:small_gap_width],
+                    opts[:col_header][col]).styles( :font_family  => opts[:font_family],
+                                                    :font_size    => opts[:cell_width] * opts[:font_scale])
+      end
+
+      0.upto(self.shape[1] - 1) do |row|
+        canvas.text(table_x - opts[:cell_width],
+                    table_y + (row + 1) * opts[:cell_height],
+                    opts[:row_header][row]).styles( :font_family  => opts[:font_family],
+                                                    :font_size    => opts[:cell_height] * opts[:font_scale])
+      end
+
+      # drawing cells
+
+      # calculating a unit of RGB color in a decimal number
+      r_beg = (opts[:gradient_beg_color].rgb_to_integer & 0xFF0000) >> 16
+      g_beg = (opts[:gradient_beg_color].rgb_to_integer & 0x00FF00) >> 8
+      b_beg = (opts[:gradient_beg_color].rgb_to_integer & 0x0000FF) >> 0
+      r_end = (opts[:gradient_end_color].rgb_to_integer & 0xFF0000) >> 16
+      g_end = (opts[:gradient_end_color].rgb_to_integer & 0x00FF00) >> 8
+      b_end = (opts[:gradient_end_color].rgb_to_integer & 0x0000FF) >> 0
+      gap   = opts[:max_val] - opts[:min_val]
+
+      if opts[:gradient_mid_color]
+        r_mid = (opts[:gradient_mid_color].rgb_to_integer & 0xFF0000) >> 16
+        g_mid = (opts[:gradient_mid_color].rgb_to_integer & 0x00FF00) >> 8
+        b_mid = (opts[:gradient_mid_color].rgb_to_integer & 0x0000FF) >> 0
+        gap1  = opts[:mid_val] - opts[:min_val]
+        gap2  = opts[:max_val] - opts[:mid_val]
+      end
+
+      0.upto(self.shape[0] - 1) do |col|
+        0.upto(self.shape[1] - 1) do |row|
+          if opts[:gradient_mid_color]
+            if self[col, row] <= opts[:mid_val]
+              r = interpolate(r_beg, r_mid, self[col, row] - opts[:min_val], gap1)
+              g = interpolate(g_beg, g_mid, self[col, row] - opts[:min_val], gap1)
+              b = interpolate(b_beg, b_mid, self[col, row] - opts[:min_val], gap1)
+            else
+              r = interpolate(r_mid, r_end, self[col, row] - opts[:mid_val], gap2)
+              g = interpolate(g_mid, g_end, self[col, row] - opts[:mid_val], gap2)
+              b = interpolate(b_mid, b_end, self[col, row] - opts[:mid_val], gap2)
+            end
+          else
+            r = interpolate(r_beg, r_end, self[col, row] - opts[:min_val], gap)
+            g = interpolate(g_beg, g_end, self[col, row] - opts[:min_val], gap)
+            b = interpolate(b_beg, b_end, self[col, row] - opts[:min_val], gap)
+          end
+
+          color = ("#%6X" % ((((r << 8) | g) << 8) | b)).gsub(" ", "0")
+
+          canvas.rect(opts[:cell_width],
+                      opts[:cell_height],
+                      table_x + col * opts[:cell_width],
+                      table_y + row * opts[:cell_height]).styles( :fill         => color,
+                                                                  :stroke       => opts[:cell_border_color],
+                                                                  :stroke_width => opts[:cell_border_width])
+
+          if opts[:print_value]
+            canvas.text(table_x + col * opts[:cell_width] + opts[:cell_border_width],
+                        table_y + (row + 1) * opts[:cell_height],
+                        "#{'%.1f' % self[col, row]}").styles(:font_size => opts[:value_font_size])
+          end
+        end
+      end
+
+      # gradient key
+      if opts[:print_gradient]
+        if opts[:gradient_mid_color]
+          img1 = Image.new(opts[:gradient_height],
+                          opts[:gradient_width] / 2,
+                          GradientFill.new(0,
+                                            opts[:gradient_width] / 2,
+                                            opts[:gradient_height],
+                                            opts[:gradient_width] / 2,
+                                            opts[:gradient_beg_color],
+                                            opts[:gradient_mid_color])).rotate(90)
+
+          img2 = Image.new(opts[:gradient_height],
+                          opts[:gradient_width] / 2,
+                          GradientFill.new(0,
+                                            opts[:gradient_width] / 2,
+                                            opts[:gradient_height],
+                                            opts[:gradient_width] / 2,
+                                            opts[:gradient_mid_color],
+                                            opts[:gradient_end_color])).rotate(90)
+          img3 = ImageList.new
+          img3 << img1 << img2
+          img = img3.append(false)
+        else
+          img = Image.new(opts[:gradient_height],
+                          opts[:gradient_width],
+                          GradientFill.new(0,
+                                          opts[:gradient_width],
+                                          opts[:gradient_height],
+                                          opts[:gradient_width],
+                                          opts[:gradient_beg_color],
+                                          opts[:gradient_end_color])).rotate(90)
+        end
+
+        img.border!(opts[:gradient_border_width],
+                    opts[:gradient_border_width],
+                    opts[:gradient_border_color])
+
+        gradient_x = (opts[:canvas_width] - opts[:gradient_width]) / 2
+        gradient_y = opts[:header_height] + opts[:cell_height] * opts[:row_header].count + opts[:margin_width]
+
+        canvas.image(img,
+                    opts[:gradient_width],
+                    opts[:gradient_height] + opts[:margin_width],
+                    gradient_x,
+                    gradient_y)
+
+        canvas.text(gradient_x,
+                    gradient_y + opts[:gradient_height] + opts[:key_font_size] * 2,
+                    "#{'%.1f' % opts[:min_val]}").styles(:font_size => opts[:key_font_size])
+
+        canvas.text(gradient_x + opts[:gradient_width],
+                    gradient_y + opts[:gradient_height] + opts[:key_font_size] * 2,
+                    "#{'%.1f' % opts[:max_val]}").styles(:font_size => opts[:key_font_size])
+      end
+    end
+
+    rvg.draw
+  end
+
+
+  private
+
+  def interpolate(start_val, end_val, step, no_steps)
+    begin
+      if (start_val < end_val)
+        ((end_val - start_val) / no_steps.to_f) * step + start_val
+      else
+        start_val - ((start_val - end_val) / no_steps.to_f) * step
+      end.round
+    rescue FloatDomainError
+      start_val
+    end
+  end
+
+end
+
+NMatrix.send(:include, NMatrixExtensions)

data/lib/string_extensions.rb

@@ -0,0 +1,17 @@
+module StringExtensions
+
+  def remove_internal_spaces
+    gsub(/[\n|\r|\s]+/, '')
+  end
+
+  def rgb_to_integer
+    if self.length == 7 # '#FF00FF'
+      Integer(self.gsub('#', '0x'))
+    else
+      raise "#{self} doesn't seem to be a proper RGB code."
+    end
+  end
+end
+
+String.send :include, StringExtensions
+

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/egor.rb'}"
+puts "Loading egor gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+load File.dirname(__FILE__) + "/../Rakefile"
+require 'rubyforge'
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+
+download = "http://rubyforge.org/projects/#{$hoe.rubyforge_name}"
+version  = $hoe.version
+
+def rubyforge_project_id
+  RubyForge.new.configure.autoconfig["group_ids"][$hoe.rubyforge_name]
+end
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)

data/test/test_egor.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestEgor < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

data/test/test_egor_cli.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+require 'egor/cli'
+
+class TestEgorCli < Test::Unit::TestCase
+  def test_execute
+    #Egor::CLI.execute
+    assert(true)
+  end
+end

data/test/test_egor_environment_class_hash.rb

@@ -0,0 +1,25 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib', 'egor')
+
+require 'test/unit'
+require 'environment_class_hash'
+
+class TestEgorEnvironmentClassHash < Test::Unit::TestCase
+
+  include Egor
+
+  def setup
+    @env_cls = EnvironmentClassHash.new
+  end
+
+  def test_group_by_non_residue_labels
+    assert(true)
+  end
+
+  def test_groups_sorted_by_residue_labels
+    assert(true)
+  end
+
+  def group_size
+    assert(true)
+  end
+end