carray 1.1.4 → 1.1.5

data/lib/carray/io/excel.rb

@@ -0,0 +1,26 @@
+require "spreadsheet"
+
+class CArray
+  
+  def save_excel (filename, &block)
+    if self.rank >= 3
+      raise "too large rank (>2) to write excel file"
+    end
+    book = Spreadsheet::Workbook.new
+    worksheet = book.create_worksheet
+    self.dim0.times do |i|
+      worksheet.row(i).push *self[i,nil]
+    end
+    if block
+      block.call(worksheet)
+    end
+    book.write(filename)    
+  end
+  
+  def self.load_excel (filename, sheet=0)
+    book = Spreadsheet.open(filename)
+    sheet = book.worksheet(sheet)
+    return sheet.map(&:to_a).to_ca
+  end
+  
+end

data/lib/carray/io/imagemagick.rb

@@ -0,0 +1,231 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/io/imagemagick.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#  You can redistribute it and/or modify it under the terms of
+#  the Ruby Licence.
+#
+#  Copyright (C) 2005 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
+#
+# carray/imagemagick.rb
+#
+# This library adds image loading/saving functions to CArray class.
+# These method uses the command line tools in ImageMagick internally.
+# ImageMagick package is required to use this library, but RMagick
+# library is not required.
+#
+# --- CArray.load_by_magick(filename[, map="rgb", data_type=nil])
+#
+# Creates a CArray object from the image file _filename_.
+# The argument _map_ should be the combination of [r|g|b|a|o|i|c|m|y|b|p].
+# The dimension of new array is determined from map's contents.
+# The data_type of array is determined automatically by the depth of image,
+# unless the data_type is not given.
+#
+# --- CArray#save_by_magick(filename[, image_type="rgb", options=""])
+#
+# Saves a CArray object to the image file _filename_.
+# The argument _image_type_ should be the one of
+#   * gray, rgb, rgba, cmyk, cmyka
+# The _options_ are passed to "convert"
+#
+# --- CArray#display_by_magick([image_type="rgb", options=""])
+#
+
+require 'yaml'
+require 'carray'
+
+class CArray
+
+  private
+  @@magick_tempfile_count = 0
+
+  public
+  def self.load_by_magick (filename, imap = "rgb", data_type = nil)
+    if not File.exist?(filename)
+      raise "can't find image file '#{filename}'"
+    end
+    identify_command = [
+                        "identify",
+                        "-format " + "'" + [
+                                           "---",
+                                           "height: %h",
+                                           "width: %w",
+                                           "depth: %z",
+                                          ].join("\n") + "'",
+                        filename,
+                        "2>/dev/null"
+                       ].join(" ")
+    ident = YAML.load(`#{identify_command}`)
+    if ident.empty?
+      raise "ImageMagick's identify command failed to read image file '#{filename}'"
+    end
+    height, width, depth = ident.values_at('height', 'width', 'depth')
+    unless data_type
+      case depth
+      when 8
+        data_type = CA_UINT8
+      when 16
+        data_type = CA_UINT16
+      when 32
+        data_type = CA_UINT32
+      end
+    end
+    storage_type = case data_type
+                   when CA_UINT8, CA_INT8
+                     "char"
+                   when CA_UINT16, CA_INT16
+                     "short"
+                   when CA_UINT32, CA_INT32
+                     "integer"
+                   when CA_FLOAT32
+                     "float"
+                   when CA_FLOAT64
+                     "double"
+                   else
+                     raise "invalid data_type"
+                   end
+    tempfile = "CA_Magick_#{$$}_#{@@magick_tempfile_count}.dat"
+    @@magick_tempfile_count += 1
+    stream_command = [
+                      "stream",
+                      "-storage-type #{storage_type}",
+                      "-map #{imap}",
+                      filename,
+                      tempfile,
+                      "2>/dev/null"
+                     ].join(" ")
+    begin
+      system stream_command
+      return open(tempfile) { |io|
+        if imap.size == 1
+          CArray.new(data_type, [height, width]).load_binary(io)
+        else
+          CArray.new(data_type, [height, width, imap.size]).load_binary(io)
+        end
+      }
+    rescue
+      raise "ImageMagick's stream command failed to read image file '#{filename}'"
+    ensure
+      if File.exist?(tempfile)
+        File.unlink(tempfile)
+      end
+    end
+  end
+
+  private
+
+  def magick_guess_image_type
+    image_type = nil
+    case rank
+    when 2
+      if fixlen?
+        case bytes
+        when 1
+          image_type = "gray"
+        when 3
+          image_type = "rgb"
+        when 4
+          image_type = "rgba"
+        end
+      else
+        image_type = "gray"
+      end
+    when 3
+      case dim2
+      when 1
+        image_type = "gray"
+      when 3
+        image_type = "rgb"
+      when 4
+        image_type = "rgba"
+      end
+    end
+    return image_type
+  end
+
+  public
+
+  def save_by_magick (filename, image_type = nil, options = "")
+    unless image_type
+      image_type = magick_guess_image_type()
+    end
+    unless image_type
+      raise "please specify image_type"
+    end
+    quantum_format = self.float? ? "-define quantum:format=floating-point" : ""
+    case self.data_type
+    when CA_INT8, CA_UINT8
+      depth = "-depth 8"
+    when CA_INT16, CA_UINT16
+      depth = "-depth 16"
+    when CA_FIXLEN
+      depth = "-depth #{8*bytes}"
+    else
+      depth = "-depth 8"
+    end
+    convert_command = [
+                       "convert",
+                       depth,
+                       "-size " + [dim1, dim0].join("x"),
+                       quantum_format,
+                       options,
+                       "#{image_type}:-",
+                       filename
+                      ].join(" ")
+    begin
+      IO.popen(convert_command, "w") { |io|
+        if data_type != CA_FIXLEN and data_type != CA_OBJECT
+          if bytes > 1 and CArray.endian == CA_LITTLE_ENDIAN
+            self.dump_binary(io)
+#            swap_bytes.dump_binary(io)
+          else
+            self.dump_binary(io)
+          end
+        else
+          self.dump_binary(io)
+        end
+      }
+    rescue
+      raise "ImageMagick's convert command failed to write image file '#{filename}'"
+    end
+  end
+
+  def display_by_magick (image_type = nil, options = "")
+    unless image_type
+      image_type = magick_guess_image_type()
+    end
+    unless image_type
+      raise "please specify image_type"
+    end
+    quantum_format = self.float? ? "-define quantum:format=floating-point" : ""
+    depth = fixlen? ? "-depth 8" : "-depth #{8*bytes}"
+    display_command = [
+                       "display",
+                       depth,
+                       "-size " + [dim1, dim0].join("x"),
+                       quantum_format,
+                       options,
+                       "#{image_type}:-",
+                      ].join(" ")
+    begin                  
+      IO.popen(display_command, "w") { |io|
+        if bytes > 1 and CArray.endian == CA_LITTLE_ENDIAN
+          swap_bytes.dump_binary(io)
+        else
+          self.dump_binary(io)
+        end
+      }
+    rescue
+      raise "ImageMagick's display command failed to display image"
+    end
+  end
+
+end
+
+
+

data/lib/carray/io/pg.rb

@@ -0,0 +1,101 @@
+require "pg"
+require "carray"
+
+class CArray
+  
+  def self.load_pg (expr, *args)
+    case expr
+    when Hash
+      opts = expr
+      sql, *vars = *args
+      db = PG.connect(opts)
+      begin
+        result = db.async_exec(sql, *vars)
+        names = result.fields
+        table = result.values
+      rescue Interrupt
+        db.cancel
+        raise 
+      ensure
+        db.finish       
+      end
+    when PG::Result
+      result = expr
+      names = result.fields
+      table = result.values
+    when PG::Connection
+      db = expr
+      sql, *vars = *args
+      begin
+        result = db.async_exec(sql, *vars)
+        names = result.fields
+        table = result.values
+      rescue Interrupt
+        db.cancel
+        raise
+      end
+    else
+      raise "invalid 1st arg"
+    end
+    table = table.to_ca
+    table.instance_exec { 
+      @result = result
+      @names  = names
+    }
+    class << table
+      attr_reader :names, :result
+      def column (name)
+        if self.size == 0
+          if name.is_a?(Integer)
+            return CA_OBJECT([])
+          elsif @names
+            if i = @names.index(name.to_s)
+              return CA_OBJECT([])
+            end
+          end
+          return nil          
+        else
+          if name.is_a?(Integer)
+            return self[false, name]
+          elsif @names
+            if i = @names.index(name.to_s)
+              return self[false, i]
+            end
+          end
+          return nil
+        end
+      end
+    end
+    return table
+  end
+
+  def unescape_bytea (type, subdim = nil)
+    bytes = CArray.sizeof(type)
+    max_bytesize = self.convert{|v| v ? PG::Connection.unescape_bytea(v).bytesize : 0}.max
+    unless subdim
+      subdim = [max_bytesize/bytes]
+    end
+    out = CArray.new(type, dim + subdim)
+    needed_bytes = out.elements/self.elements*bytes
+    ref = out.refer(:fixlen, dim, :bytes=>needed_bytes)
+    if needed_bytes == max_bytesize
+      ref.load_binary self.convert {|v| PG::Connection.unescape_bytea(v) }.join
+    else
+      self.each_addr do |addr|
+        if self[addr]
+          text = PG::Connection.unescape_bytea(self[addr])
+          ref[[addr]].load_binary PG::Connection.unescape_bytea(self[addr])
+        else
+          out[addr,false] = UNDEF
+        end
+      end
+    end
+    return out
+  end
+  
+  def escape_bytea (db)
+    return db.escape_bytea(self.to_s)
+  end
+
+end
+

data/lib/carray/io/sqlite3.rb

@@ -0,0 +1,202 @@
+require "carray"
+require "sqlite3"
+require "carray/io/table"
+
+class CArray
+  
+  def self.load_sqlite3 (expr, *args)
+    case expr
+    when String
+      file = expr
+      sql, *vars = *args
+      db = SQLite3::Database.new(file)
+      names, *table = db.execute2(sql, *vars)
+      db.close
+    when SQLite3::Database
+      db = expr
+      sql, *vars = *args
+      names, *table = db.execute2(sql, *vars)
+    when SQLite3::Statement
+      stmt = expr
+      vars = args
+      names = stmt.columns
+      table = stmt.execute!(*vars)
+    else
+      raise "invalid 1st arg"
+    end
+    table = table.to_ca
+    table.extend(CA::TableMethods)
+    table.column_names = names
+    return table
+  end
+
+  def to_sqlite3 (database: nil, table:, datatype: "numeric", schema: nil, transaction: true)
+    unless rank <= 2
+      raise "to_sqlite3 is valid only for 2-dim array (table)"
+    end
+    case database
+    when SQLite3::Database
+    when String
+      if File.exist? database
+        database = SQLite3::Database.open(database)
+      else
+        database = SQLite3::Database.new(database)        
+      end
+    else
+      database = SQLite3::Database.new ":memory:"
+    end
+    if respond_to?(:column_names) and column_names
+      vars = column_names
+    else
+      if rank == 1
+        vars = ["c0"]
+      else
+        vars = CArray.object(dim1).seq.map{|s| "c#{s}" }
+      end
+    end
+    
+    if schema
+      database.execute "create table if not exists #{table} (" + schema + ")"          
+    else
+      database.execute "create table if not exists #{table} (" + vars.map{|s| s + " " + datatype }.join(",") + ")"
+    end
+
+    insert = database.prepare %{ insert or replace into #{table} values (#{(["?"]*vars.size).join(",")}) }
+    database.transaction if transaction
+    if rank == 1
+      dim0.times do |i|
+        insert.execute [self[i]]
+      end
+    else
+      dim0.times do |i|
+        insert.execute self[i,nil].to_a
+      end
+    end
+    database.commit if transaction
+    insert.close
+    return database
+  end
+
+  def unblob (type, subdim = nil)
+    bytes = CArray.sizeof(type)
+    elem  = self[0]
+    if elem == nil and subdim == nil
+      raise "first element is nil, please specify dimension."
+    end
+    unless subdim
+      subdim = [elem.bytesize/bytes]
+    end
+    out = CArray.new(type, dim + subdim)
+    needed_bytes = out.elements/self.elements*bytes
+    ref = out.refer(:fixlen, dim, :bytes=>needed_bytes)
+    if elem and needed_bytes != elem.bytesize 
+      self.each_addr do |addr|
+        if self[addr].nil?
+          ref[[addr]] = UNDEF
+        else
+          ref[[addr]].load_binary self[addr]
+        end
+      end
+    elsif self.any_equal?(nil)
+      copy  = self.to_ca
+      sel   = self.eq(nil)
+      copy[sel] = "\0" * needed_bytes
+      ref.load_binary copy.join
+      ref[sel] = UNDEF
+    else
+      ref.load_binary self.join
+    end
+    return out
+  end
+  
+end
+
+module SQLite3
+  
+  class Database
+    
+    def create_table (table, data, names = nil)
+      ncols = data.rank == 1 ? 1 : data.dim1
+      if names
+        varlist = names.map{|s| s.to_s }
+      elsif data.respond_to?(:names)
+        varlist = data.names
+      else
+        varlist = []
+        ncols.times do |i|
+          varlist << "col#{i}"
+        end
+      end
+      execute %{create table #{table} (#{varlist.join(",")})}
+      insert(table, data)
+    end
+    
+    def insert (table, data)
+      table_info = execute %{
+        pragma table_info(#{table}) 
+      }  
+      if table_info.empty?
+        raise "#{table} is empty table"
+      end
+      qstns = (["?"]*table_info.size).join(",")
+      self.transaction {
+        stmt = prepare %{ 
+          insert or replace into #{table} values (#{qstns}) 
+        }
+        data.to_a.each do |row|
+          stmt.execute *row
+        end
+        stmt.close      
+      }
+    end
+
+    def schema (table = nil)
+      if table
+        return get_first_value %{
+          select sql from sqlite_master where type in ('table', 'view', 'index') and name = "#{table}"
+        }
+      else
+        return execute(%{
+          select sql from sqlite_master where type in ('table', 'view', 'index')
+        }).map{|v| v[0]}
+      end
+    end
+
+    # insert
+    def import_table (dbfile, src_table, dst_table = nil)
+      dst_table ||= src_table
+      db = "db#{Thread.current.object_id}"
+      execute %{
+        attach database "#{dbfile}" as #{db};
+      }
+      sql = get_first_value %{
+        select sql from #{db}.sqlite_master where type = 'table' and name = "#{src_table}"
+      }
+      sql.sub!(/create\s+table\s(.+?)\s/i, "create table if not exists #{dst_table}")
+      execute sql
+      execute %{
+        insert into #{dst_table} select * from #{db}.#{src_table};
+      }
+      indeces = execute %{
+        select sql from #{db}.sqlite_master where type = 'index' and tbl_name = "#{src_table}"        
+      } 
+      indeces.each do |row|
+        sql = row[0]
+        unless sql
+          break
+        end
+        sql.sub!(/create\s+index/i, "create index if not exists")
+        sql.sub!(/on\s+#{src_table}\(/i, "on #{dst_table}(")
+        execute sql
+      end
+      execute %{
+        detach database #{db};
+      }
+    end
+    
+  end
+  
+end
+
+
+