mizlab 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0997e1a56ba6b17aa4eedc2fd89e84462e3ac2d3f51c1c251221a0fc7613ff66'
-  data.tar.gz: aaac55320663e3b8fef03c5518d73156ea3a1880736936c8debb1a6eb9d60935
+  metadata.gz: ee3b63815d8af26656457f4d496fc4d5b8527cd4402591d454739052f98b6950
+  data.tar.gz: 7aad66b65cf70b3e820ad31626ab35c3ad924f2c8944973afa03f1768a06b56c
 SHA512:
-  metadata.gz: a5e073bceea54fd25ad99e80c35052732c265a6e827b8e23bcf4f2bc21f3b03095243d5e9b718bf6b521ae8097f5059b72a15cc32ec67e7bfe534e3b8c7d35bc
-  data.tar.gz: 61f1545fd3218ce1a74b030a6a64718964a8129f30587deaebeb038cadfe82991b9d7356751129ba92df751278193d5a1cf92c147790e8a88008bb285fa665c8
+  metadata.gz: 9278897277093689b3b7f855d01574e6d580ec1ff3b5a5efd3e74ec9ba1981b66ad62d2fc1cf257191e4f66697d213bc368423f829c174212fe2df81deae37af
+  data.tar.gz: bb2a961976d7b414e06bc99d6969752e3f54e4c472cf2faa22873116ebf1b64e8ae8769160e92c1051bbba0b5e276919a20fc84b3484d919c63aadea3aaca24d

data/lib/mizlab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mizlab
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/lib/mizlab.rb

@@ -4,6 +4,7 @@ require_relative "mizlab/version"
 require "set"
 require "bio"
 require "stringio"
+require "open3"
 require "rexml/document"
 
 module Mizlab
@@ -72,7 +73,7 @@ module Mizlab
     # @param  [Bio::Sequence] sequence sequence
     # @param  [Hash] mappings Hash formated {String => [Float...]}. All of [Float...] must be have same dimention.
     # @param  [Hash] weights Weights for some base combination.
-    # @param  [Integer] Size of window when scanning sequence. If not give this, will use `mappings.keys[0].length -1`.
+    # @param  [Integer] window_size Size of window when scanning sequence. If not give this, will use `mappings.keys[0].length -1`.
     # @return [Array] coordinates like [[dim1...], [dim2...]...].
     def calculate_coordinates(sequence, mappings,
                               weights = nil, window_size = nil)
@@ -117,8 +118,8 @@ module Mizlab
     end
 
     # Compute local patterns from coordinates.
-    # @param  [Array] x_coordinates coordinates on x.
-    # @param  [Array] y_coordinates coordinates on y.
+    # @param  [Array] x_coordinates Coordinates on x dimention.
+    # @param  [Array] y_coordinates Coordinates on y dimention.
     # @return [Array] Local pattern histgram (unnormalized).
     def local_patterns(x_coordinates, y_coordinates)
       length = x_coordinates.length
@@ -127,14 +128,21 @@ module Mizlab
       end
 
       filled_pixs = Set.new
-      0.upto(length - 2) do |idx|
-        filled_pixs += bresenham(x_coordinates[idx].truncate, y_coordinates[idx].truncate,
-                                 x_coordinates[idx + 1].truncate, y_coordinates[idx + 1].truncate)
+      x_coordinates[...-1].zip(y_coordinates[...-1],
+                               x_coordinates[1...],
+                               y_coordinates[1...]) do |x_start, y_start, x_end, y_end|
+        bresenham(x_start.truncate, y_start.truncate,
+                  x_end.truncate, y_end.truncate).each do |pix|
+          filled_pixs.add("#{pix[0]}##{pix[1]}")
+          # NOTE:
+          # In set or hash, if including array make it so slow.
+          # Prevend it by converting array into symbol or freezed string.
+        end
       end
 
       local_pattern_list = [0] * 512
-      get_patterns(filled_pixs) do |pix|
-        local_pattern_list[convert(pix)] += 1
+      get_patterns(filled_pixs) do |pattern|
+        local_pattern_list[pattern] += 1
       end
       return local_pattern_list
     end
@@ -167,87 +175,86 @@ module Mizlab
     end
 
     # get patterns from filled pixs.
-    # @param [Set] filleds filled pix's coordinates.
-    # @yield [binaries] Array like [t, f, t...].
+    # @param [Set] filleds Filled pix's coordinates.
+    # @yield [Integer] Pattern that shown as binary
     def get_patterns(filleds)
       unless filleds.is_a?(Set)
         raise TypeError, "The argument must be Set"
       end
 
-      centers = Set.new()
+      centers = Set.new
       filleds.each do |focused|
-        get_centers(focused) do |center|
+        x, y = focused.split("#").map(&:to_i)
+        get_centers(x, y) do |center|
           if centers.include?(center)
             next
           end
           centers.add(center)
-          binaries = []
+          binary = ""
+          x, y = center.split("#").map(&:to_i)
           -1.upto(1) do |dy|
             1.downto(-1) do |dx|
-              binaries.append(filleds.include?([center[0] + dx, center[1] + dy]))
+              binary += filleds.include?("#{x + dx}##{y + dy}") ? "1" : "0"
             end
           end
-          yield binaries
+          yield binary.to_i(2)
         end
       end
     end
 
     # get center coordinates of all window that include focused pixel
-    # @param  [Array] focused coordinate of focused pixel
-    # @yield [Array] center coordinates of all window
-    def get_centers(focused)
+    # @param [Integer] focused_x Coordinate of focused pixel on x dimention
+    # @param [Integer] focused_y Coordinate of focused pixel on y dimention
+    # @yield [String] Center coordinates of all window as string
+    def get_centers(focused_x, focused_y)
       -1.upto(1) do |dy|
         1.downto(-1) do |dx|
-          yield [focused[0] + dx, focused[1] + dy]
+          yield "#{focused_x + dx}##{focused_y + dy}"
         end
       end
     end
 
-    # Convert binary array to interger
-    # @param  [Array] binaries Array of binaries
-    # @return [Integer] converted integer
-    def convert(binaries)
-      unless binaries.all? { |v| v.is_a?(TrueClass) || v.is_a?(FalseClass) }
-        raise TypeError, "The argument must be Boolean"
-      end
-      rst = 0
-      binaries.reverse.each_with_index do |b, i|
-        if b
-          rst += 2 ** i
-        end
-      end
-      return rst
-    end
-
     # Compute fill pixels by bresenham algorithm
     # @param  [Interger] x0 the start point on x.
     # @param  [Interger] y0 the start point on y.
     # @param  [Interger] x1 the end point on x.
     # @param  [Interger] x1 the end point on y.
-    # @return [Array] filled pixels
+    # @return [Array] Filled pixels
+    # ref https://aidiary.hatenablog.com/entry/20050402/1251514618 (japanese)
     def bresenham(x0, y0, x1, y1)
       if ![x0, y0, x1, y1].all? { |v| v.is_a?(Integer) }
         raise TypeError, "All of arguments must be Integer"
       end
-      dx = (x1 - x0).abs
-      dy = (y1 - y0).abs
-      sx = x0 < x1 ? 1 : -1
-      sy = y0 < y1 ? 1 : -1
-      err = dx - dy
-      lines = []
-      while true
-        lines.append([x0, y0])
-        if (x0 == x1 && y0 == y1)
-          break
-        end
-        e2 = 2 * err
-        if e2 > -dy
-          err = err - dy
-          x0 = x0 + sx
+
+      dx = x1 - x0
+      dy = y1 - y0
+      step_x = dx.positive? ? 1 : -1
+      step_y = dy.positive? ? 1 : -1
+      dx, dy = [dx, dy].map { |x| (x * 2).abs }
+
+      lines = [[x0, y0]]
+
+      if dx > dy
+        fraction = dy - dx / 2
+        while x0 != x1
+          if fraction >= 0
+            y0 += step_y
+            fraction -= dx
+          end
+          x0 += step_x
+          fraction += dy
+          lines << [x0, y0]
         end
-        if e2 < dx
-          err = err + dx
-          y0 = y0 + sy
+      else
+        fraction = dx - dy / 2
+        while y0 != y1
+          if fraction >= 0
+            x0 += step_x
+            fraction -= dx
+          end
+          y0 += step_y
+          fraction += dx
+          lines << [x0, y0]
         end
       end
       return lines
@@ -278,4 +285,54 @@ module Mizlab
       return { element.name.to_sym => value }
     end
   end
+
+  class Blast < Bio::Blast
+    # Execute blast+
+    # @param  [Bio::Sequence, Bio::Sequence::NA, Bio::Sequence::AA] q Query sequence
+    # @param  [Hash] opts commandline arguments optionaly
+    # @return [Bio::Blast::Report] Result for blast+
+    def query(q, opts = {})
+      # NOTE: I dont use **kwargs for compatibility
+      case q
+      when Bio::Sequence
+        q = q.output(:fasta)
+      when Bio::Sequence::NA, Bio::Sequence::AA, Bio::Sequence::Generic
+        q = q.to_fasta("query", 70)
+      else
+        q = q.to_s
+      end
+      stdout, _ = exec_local(q, opts)
+      return parse_result(stdout)
+    end
+
+    private
+
+    # Execute blast on local
+    # @param  [string] query_string Query string, fasta etc
+    # @param  [Hash] opts commandline arguments optionaly
+    # @return [Array] Array [stdout, stderr] as string
+    # TODO: compatibility with original
+    def exec_local(query_string, opts = {})
+      # NOTE: I dont use **kwargs for compatibility
+      cmd = []
+      cmd << @program if @program
+      cmd += ["-db", @db] if @program
+      cmd += ["-outfmt", "5"]
+      opts.each do |kv|
+        cmd += kv.map(&:to_s)
+      end
+      return execute_command(cmd, stdin: query_string)
+    end
+
+    # Execute command on shell
+    # @param  [Array] cmd Array of command strings that splited by white space
+    # @param  [String] stdin String of stdin
+    # @return [Array] String of stdout and stderr
+    # @raise  [IOError] Command finished without status 0
+    def execute_command(cmd, stdin)
+      stdout, stderr, status = Open3.capture3(cmd.join(" "), stdin_data: stdin)
+      raise IOError, stderr unless status == 0
+      return [stdout, stderr]
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mizlab
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Omochice
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-28 00:00:00.000000000 Z
+date: 2021-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bio