image_svd 0.0.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c6be55c37295a68be501d5eb609175825105b52
-  data.tar.gz: 33fa7ce261ed05d54123c04ae9bbca9be486b5ba
+  metadata.gz: 66400751ae0908db2cc49a77f51d2aacaa0418f1
+  data.tar.gz: 40c59891f1db50ca96860464314c5b9f3d839cf4
 SHA512:
-  metadata.gz: fbca7cbe89abcccbf9f9a916163b1b3ee122fdd3060b821c1a1e237e783f239b85aa63f081bae7d8574337a00f30196cf9ce11e00a706ab964f3d292de28d479
-  data.tar.gz: 23083c717ed0fc46950cabd0551c82d38f5ceef2ca0c8dc1a5c3fad0cf1f96f7d3ce1f67c7809aae48b2e301eab9abba4a18fe1ddfaefa5285b4db3b02395dec
+  metadata.gz: 24a2168981ee91080b1555416a17944e8c1e638c4aec9cf4bbd79c320b1a21ef7af1080aecb27127137f16f10de1cc1314592559f1aaaccc549c4a90ca151a75
+  data.tar.gz: 1dc02a67c48e6869952854d86cd16a2b96212d95c31378b91585ba0f9fb7647be461a544db513ba8e20befe66020f89eaebc7e0a0e54aed920121595982ed9cd

data/lib/image_svd.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 
 require 'image_svd/version'
+require 'image_svd/util'
 require 'image_svd/cli'
 require 'image_svd/image_matrix'

data/lib/image_svd/cli.rb

@@ -4,57 +4,81 @@ module ImageSvd
   # This class is responsible for handling the command line interface
   class CLI
     # The entry point for the application logic
-    # rubocop:disable MethodLength
-    def run(opts)
-      if opts[:read] == true
-        app = ImageSvd::ImageMatrix.new_from_svd_savefile(opts)
-        app.to_image(opts[:output_name])
-      else
-        opts = process_options(opts)
-        app = ImageSvd::ImageMatrix.new(opts[:singular_values])
-        app.read_image(opts[:input_file])
-        if opts[:archive] == true
-          app.save_svd(opts[:output_name])
-        elsif opts[:convert] == true
-          app.to_image(opts[:output_name])
+    def run(options)
+      Options.iterate_on_input(options) do |o|
+        if o[:directory]
+          fork { run_single_image(o) }
+        else
+          run_single_image(o)
         end
       end
+      Process.waitall
     end
 
-    def process_options(opts)
-      i, valid_i = [opts[:num_singular_values].to_s, /^\d+\.\.\d+$|^\d+$/]
-      fail 'invalid --num-singular-values option' unless i.match valid_i
-      vs = i.split('..').map(&:to_i)
-      vs = (vs.length == 1 ? vs : ((vs.first)..(vs.last)).to_a)
-      opts.merge(singular_values: vs)
+    # rubocop:disable MethodLength
+    def run_single_image(o)
+      if o[:read] == true
+        app = ImageSvd::ImageMatrix.new_from_svd_savefile(o)
+        app.to_image(o[:output_name])
+      else
+        app = ImageSvd::ImageMatrix.new(o[:singular_values], o[:grayscale])
+        app.read_image(o[:input_file])
+        if o[:archive] == true
+          app.save_svd(o[:output_name])
+        elsif o[:convert] == true
+          app.to_image(o[:output_name])
+        end
+      end
     end
   end
   # rubocop:enable MethodLength
 
   # This module holds custom behavior for dealing with the gem trollop
   module Options
+    extend Util
+
     # rubocop:disable MethodLength
     def self.get
       proc do
         version "Image Svd #{ImageSvd::VERSION} (c) 2014 Ilya Kavalerov"
         banner <<-EOS
-          Image Svd is a utilty that performs Singular Value Decomposition
-          on a grayscale image. It can be useful for compressing images, or
-          creating interesting visual effects to distort images when
-          compression is set very high.
+
+                  _____________   ____          ____   ______
+                  \\    ________\\  \\   \\        /   /  /  __  \\
+                   \\   \\           \\   \\      /   /  /  /  \\  \\
+                    \\   \\________   \\   \\    /   /  /  /    \\  \\
+                     \\_________   \\  \\   \\  /   /  /  /     /  /
+                               \\   \\  \\   \\/   /  /  /     /  /
+                       _________\\   \\  \\      /  /  /_____/  /
+                       \\_____________\\  \\____/  /___________/
+
+
+          Image Svd is a utilty for compressing images, or creating
+          interesting visual effects to distort images when compression is
+          set very high. Image Svd performs Singular Value Decomposition
+          on any image, grayscale or color.
 
           Usage:
                  image_svd [options]
           where [options] are:
+ 
         EOS
         opt :input_file,
-            'An input file (Preferably a jpg).',
+            'An input file (Preferably a jpg). If you also specify'\
+              ' --directory or -d, you may provide the path to a directory'\
+              ' (which must end with a "/") instead of a file.',
             type: :io,
             required: true
+        opt :grayscale,
+            'Do not preserve the colors in the input image. Specify'\
+              ' --no-grayscale when you want an output image in color.'\
+              ' Expect processing time to increase 3-fold for color images.',
+            default: true,
+            short: '-g'
         opt :num_singular_values,
             'The number of singular values to keep for an image. Lower'\
-              ' numbers mean lossier compression; smaller files and more'\
-              ' distorted images. You may also provide a range ruby style,'\
+              ' numbers mean lossier compression, smaller files and more'\
+              ' distorted images. You may also provide a range ruby style'\
               ' (ex: 1..9) in which case many images will be output.',
             default: '50',
             short: '-n'
@@ -64,6 +88,13 @@ module ImageSvd
               ' the current directory',
             default: 'svd_image_output',
             short: '-o'
+        opt :directory,
+            'The input provided is a directory instead of a file. In this'\
+              ' case every valid image inside the directory provided with'\
+              ' the option -i will be compressed, and placed into a folder'\
+              ' named "out" inside the directory specified.',
+            default: false,
+            short: '-d'
         opt :convert,
             'Convert the input file now.',
             default: true,
@@ -80,5 +111,57 @@ module ImageSvd
       end
     end
     # rubocop:enable MethodLength
+
+    # this method chooses which number of singular values are valid to output
+    # to an image file from an archive file provided. @returns Array[Int]
+    def self.num_sing_val_out_from_archive(requests, available)
+      valid_svals = requests.reject { |v| v > available }
+      valid_svals.empty? ? [available] : valid_svals
+    end
+
+    def self.process(opts)
+      vs = format_num_sing_vals(opts[:num_singular_values].to_s)
+      opts.merge(singular_values: vs)
+    end
+
+    # reformats the string cmd line option to an array
+    def self.format_num_sing_vals(str)
+      i, valid_i_regex = [str, /^\d+\.\.\d+$|^\d+$/]
+      fail 'invalid --num-singular-values option' unless i.match valid_i_regex
+      vs = i.split('..').map(&:to_i)
+      vs.length == 1 ? vs : ((vs.first)..(vs.last)).to_a
+    end
+
+    # reformats directory inputs into an array of files, or repackages file
+    # inputs to be contained inside an array
+    def self.expand_input_files(opts)
+      if opts[:directory]
+        path = opts[:input_file].path
+        names = Dir.new(path).to_a
+        images = names.select { |name| name =~ Util::VALID_INPUT_EXT_REGEX }
+        images.map { |name| File.new(path + name) }
+      else
+        [opts[:input_file]]
+      end
+    end
+
+    # ignore provided output_name in the case that a directory is input
+    def self.output_dir_path_for_input_file(dir)
+      path_components = dir.path.split('/')
+      filename = path_components.pop
+      (path_components << 'out' << filename).join('/')
+    end
+
+    def self.iterate_on_input(opts)
+      %x(mkdir #{opts[:input_file].path + 'out'}) if opts[:directory]
+      expand_input_files(opts).each do |file|
+        new_options = { input_file: file }
+        if opts[:directory]
+          new_options.merge!(output_name: output_dir_path_for_input_file(file))
+        end
+        o = process(opts).merge(new_options)
+        yield o
+      end
+    end
   end
 end

data/lib/image_svd/image_matrix.rb

@@ -3,44 +3,28 @@ require 'json'
 require 'pnm'
 
 module ImageSvd
-  # This class is responsible for almost everything :(
-  # Reading an image or archive to a matrix
-  # Saving a matrix to an image
-  # Performing Singular Value Decomposition on a matrix
-  class ImageMatrix
-    # rubocop:disable SymbolName
-    # rubocop:disable VariableName
-    attr_reader :singular_values
-    attr_accessor :sigma_vTs, :us, :m, :n
+  # rubocop:disable SymbolName
+  # rubocop:disable VariableName
 
-    def initialize(singular_values)
-      fail 'not enough singular values' if singular_values.length.zero?
-      @singular_values = singular_values
-      @num_singular_values = singular_values.max
-    end
-
-    def read_image(image_path)
-      puts 'Reading image and converting to matrix...'
-      intermediate = extension_swap(image_path.path, 'pgm')
-      %x(convert #{image_path.path} #{intermediate})
-      image = PNM.read intermediate
-      decompose Matrix[*image.pixels]
-      %x(rm #{intermediate})
-      self
-    end
+  # This class is responsible for manipulating matricies that correspond
+  # to the color channels in images, which includes performing Singular
+  # Value Decomposition on a matrix
+  class Channel
+    attr_accessor :sigma_vTs, :us, :m, :n
+    attr_reader :num_singular_values
 
-    # @todo abstract this to another class
-    # always place the new extension, even if there is nothing to swap out
-    def extension_swap(path, new_ext, suffix = '')
-      head = path.gsub(/\..{1,5}$/, '')
-      "#{head}#{suffix}.#{new_ext}"
+    def initialize(matrix, num_singular_values)
+      fail 'Channel initialized without a matrix' unless matrix.is_a? Matrix
+      @matrix = matrix
+      @num_singular_values = num_singular_values
     end
 
     # The most time consuming method
     # Launches the decomposition and saves the two lists
     # of vectors needed to reconstruct the image
     # rubocop:disable MethodLength
-    def decompose(m_A)
+    def decompose(m_A = nil)
+      m_A ||= @matrix
       m_AT = m_A.transpose
       @m, @n = m_A.to_a.length, m_A.to_a.first.length
       m_ATA = m_AT * m_A
@@ -60,6 +44,7 @@ module ImageSvd
       end
       @sigma_vTs = both.map { |p| p.last }
       @us = both.map { |p| p.first }
+      self
     end
     # rubocop:enable MethodLength
 
@@ -71,22 +56,126 @@ module ImageSvd
       end.transpose
     end
 
+    # returns all the information necessary to serialize this channel
+    def to_h
+      {
+        'sigma_vTs' => @sigma_vTs.map(&:to_a),
+        'us' => @us.map(&:to_a),
+        'm' => @m,
+        'n' => @n
+      }
+    end
+
+    # can initialize with the result of #to_h
+    def self.apply_h(hash, num_singular_values)
+      c = new(Matrix[], num_singular_values)
+      c.sigma_vTs = hash['sigma_vTs']
+        .map { |arr| Vector[*arr.flatten].covector }
+      c.us = hash['us'].map { |arr| Vector[*arr.flatten] }
+      c.m = hash['m']
+      c.n = hash['n']
+      c
+    end
+  end
+
+  # This class is responsible for:
+  # Reading an image or archive to a matrix
+  # Saving a matrix to an image
+  class ImageMatrix
+    include ImageSvd::Util
+
+    attr_reader :singular_values, :grayscale
+    attr_accessor :channels
+
+    def initialize(singular_values, grayscale)
+      fail 'not enough singular values' if singular_values.length.zero?
+      @singular_values = singular_values
+      @num_singular_values = singular_values.max
+      @grayscale = grayscale
+      @channels = []
+    end
+
+    def get_image_channels(image_path)
+      extension = @grayscale ? 'pgm' : 'ppm'
+      intermediate = extension_swap(image_path.path, extension)
+      %x(convert #{image_path.path} #{intermediate})
+      if @grayscale
+        channels = [PNM.read(intermediate).pixels]
+      else
+        channels = ImageMatrix.ppm_to_rgb(PNM.read(intermediate).pixels)
+      end
+      %x(rm #{intermediate})
+      channels.map { |c| Matrix[*c] }
+    end
+
+    def read_image(image_path)
+      channels = get_image_channels(image_path)
+      @channels = channels.map { |m| Channel.new(m, @num_singular_values) }
+      @channels.each(&:decompose)
+    end
+
     def to_image(path)
+      if @grayscale
+        to_grayscale_image(path)
+      else
+        to_color_image(path)
+      end
+    end
+
+    def to_grayscale_image(path)
       puts 'writing images...' if @singular_values.length > 1
       @singular_values.each do |sv|
         out_path = extension_swap(path, 'jpg', "_#{sv}_svs")
         intermediate = extension_swap(path, 'pgm', '_tmp_outfile')
-        cleansed_matrix = matrix_to_valid_pixels(reconstruct_matrix(sv))
-        PNM::Image.new(cleansed_matrix).write(intermediate)
+        reconstructed_mtrx = @channels.first.reconstruct_matrix(sv)
+        cleansed_mtrx = ImageMatrix.matrix_to_valid_pixels(reconstructed_mtrx)
+        PNM::Image.new(cleansed_mtrx).write(intermediate)
         %x(convert #{intermediate} #{out_path})
         %x(rm #{intermediate})
       end
-      true
+    end
+
+    def to_color_image(path)
+      puts 'writing images...' if @singular_values.length > 1
+      @singular_values.each do |sv|
+        out_path = extension_swap(path, 'jpg', "_#{sv}_svs")
+        intermediate = extension_swap(path, 'ppm', '_tmp_outfile')
+        ms = @channels.map { |c| c.reconstruct_matrix(sv) }
+        cleansed_mtrxs = ms.map { |m| ImageMatrix.matrix_to_valid_pixels(m) }
+        ppm_matrix = ImageMatrix.rgb_to_ppm(*cleansed_mtrxs)
+        PNM::Image.new(ppm_matrix).write(intermediate)
+        %x(convert #{intermediate} #{out_path})
+        %x(rm #{intermediate})
+      end
+    end
+
+    def save_svd(path)
+      out_path = extension_swap(path, 'svdim')
+      string = @channels.map(&:to_h).to_json
+      File.open(out_path, 'w') do |f|
+        f.puts string
+      end
+    end
+
+    # breaks a ppm image into 3 separate channels
+    def self.ppm_to_rgb(arr)
+      (0..2).to_a.map do |i|
+        arr.map { |row| row.map { |pix| pix[i] } }
+      end
+    end
+
+    # combines 3 separate channels into the ppm scheme
+    def self.rgb_to_ppm(r, g, b)
+      r.each_with_index.map do |row, row_i|
+        row.each_with_index.map do |_, pix_i|
+          [r[row_i][pix_i], g[row_i][pix_i], b[row_i][pix_i]]
+        end
+      end
     end
 
     # conforms a matrix to pnm requirements for pixels: positive integers
     # rubocop:disable MethodLength
-    def matrix_to_valid_pixels(matrix)
+    def self.matrix_to_valid_pixels(matrix)
       matrix.to_a.map do |row|
         row.map do |number|
           rounded = number.round
@@ -102,34 +191,36 @@ module ImageSvd
     end
     # rubocop:enable MethodLength
 
-    def save_svd(path)
-      out_path = extension_swap(path, 'svdim')
-      string = {
-        'sigma_vTs' => @sigma_vTs.map(&:to_a),
-        'us' => @us.map(&:to_a),
-        'm' => @m,
-        'n' => @n
-      }.to_json
-      File.open(out_path, 'w') do |f|
-        f.puts string
+    def self.new_saved_grayscale_svd(opts, h)
+      svals = [opts[:singular_values], h['sigma_vTs'].size]
+      valid_svals = ImageSvd::Options.num_sing_val_out_from_archive(*svals)
+      instance = new(valid_svals, true)
+      instance.channels << Channel.apply_h(h, valid_svals)
+      instance
+    end
+
+    def self.new_saved_color_svd(opts, hs)
+      svals = [opts[:singular_values], hs.first['sigma_vTs'].size]
+      valid_svals = ImageSvd::Options.num_sing_val_out_from_archive(*svals)
+      instance = new(valid_svals, false)
+      3.times do |i|
+        chan = Channel.apply_h(hs[i], valid_svals)
+        instance.channels << chan
       end
+      instance
     end
 
     # @todo error handling code here
     # @todo serialization is kind of silly as is
     def self.new_from_svd_savefile(opts)
       h = JSON.parse(File.open(opts[:input_file], &:readline))
-      svals = [opts[:singular_values], h['sigma_vTs'].size].compact.sort.uniq
-      valid_svals = svals.reject { |v| v > h['sigma_vTs'].size }
-      instance = new(valid_svals)
-      instance.sigma_vTs = h['sigma_vTs']
-        .map { |arr| Vector[*arr.flatten].covector }
-      instance.us = h['us'].map { |arr| Vector[*arr.flatten] }
-      instance.n = h['n']
-      instance.m = h['m']
-      instance
+      if h.length == 1 # grayscale
+        new_saved_grayscale_svd(opts, h.first)
+      else
+        new_saved_color_svd(opts, h)
+      end
     end
-    # rubocop:enable SymbolName
-    # rubocop:enable VariableName
   end
+  # rubocop:enable SymbolName
+  # rubocop:enable VariableName
 end

data/lib/image_svd/util.rb

@@ -0,0 +1,16 @@
+module ImageSvd
+  # This module holds useful miscellaneous methods
+  module Util
+    # rubocop:disable LineLength
+    # imagemagick supported formats from running `convert -list format`,
+    # plus this application's native archive extension '.svdim'
+    VALID_INPUT_EXT_REGEX = /\.svdim|\.3FR|\.A|\.AAI|\.AI|\.ART|\.ARW|\.AVI|\.AVS|\.B|\.BGR|\.BGRA|\.BMP|\.BMP2|\.BMP3|\.BRF|\.C|\.CAL|\.CALS|\.CANVAS|\.CAPTION|\.CIN|\.CIP|\.CLIP|\.CMYK|\.CMYKA|\.CR2|\.CRW|\.CUR|\.CUT|\.DCM|\.DCR|\.DCX|\.DDS|\.DFONT|\.DNG|\.DOT|\.DPX|\.DXT1|\.DXT5|\.EPDF|\.EPI|\.EPS|\.EPS2|\.EPS3|\.EPSF|\.EPSI|\.ERF|\.FAX|\.FITS|\.FRACTAL|\.FTS|\.G|\.G3|\.GIF|\.GIF87|\.GRADIENT|\.GRAY|\.GV|\.HALD|\.HDR|\.HISTOGRAM|\.HRZ|\.HTM|\.HTML|\.ICB|\.ICO|\.ICON|\.INFO|\.INLINE|\.IPL|\.ISOBRL|\.JNG|\.JNX|\.JPEG|\.JPG|\.K|\.K25|\.KDC|\.LABEL|\.M|\.M2V|\.M4V|\.MAC|\.MAP|\.MASK|\.MAT|\.MATTE|\.MEF|\.MIFF|\.MNG|\.MONO|\.MOV|\.MP4|\.MPC|\.MPEG|\.MPG|\.MRW|\.MSL|\.MSVG|\.MTV|\.MVG|\.NEF|\.NRW|\.NULL|\.O|\.ORF|\.OTB|\.OTF|\.PAL|\.PALM|\.PAM|\.PANGO|\.PATTERN|\.PBM|\.PCD|\.PCDS|\.PCL|\.PCT|\.PCX|\.PDB|\.PDF|\.PDFA|\.PEF|\.PES|\.PFA|\.PFB|\.PFM|\.PGM|\.PICON|\.PICT|\.PIX|\.PJPEG|\.PLASMA|\.PNG|\.PNG00|\.PNG24|\.PNG32|\.PNG48|\.PNG64|\.PNG8|\.PNM|\.PPM|\.PREVIEW|\.PS|\.PS2|\.PS3|\.PSB|\.PSD|\.PWP|\.R|\.RAF|\.RAS|\.RGB|\.RGBA|\.RGBO|\.RGF|\.RLA|\.RLE|\.RW2|\.SCR|\.SCT|\.SFW|\.SGI|\.SHTML|\.SPARSE|\.SR2|\.SRF|\.STEGANO|\.SUN|\.SVG|\.SVGZ|\.TEXT|\.TGA|\.THUMBNAIL|\.TILE|\.TIM|\.TTC|\.TTF|\.TXT|\.UBRL|\.UIL|\.UYVY|\.VDA|\.VICAR|\.VID|\.VIFF|\.VST|\.WBMP|\.WMV|\.WPG|\.X3F|\.XBM|\.XC|\.XCF|\.XPM|\.XPS|\.XV|\.Y|\.YCbCr|\.YCbCrA|\.YUV/i
+    # rubocop:enable LineLength
+
+    # always place the new extension, even if there is nothing to swap out
+    def extension_swap(path, new_ext, suffix = '')
+      head = path.gsub(/\..{1,5}$/, '')
+      "#{head}#{suffix}.#{new_ext}"
+    end
+  end
+end

data/lib/image_svd/version.rb

@@ -1,4 +1,4 @@
 # This module holds the gem's code
 module ImageSvd
-  VERSION = '0.0.2'
+  VERSION = '0.1.4'
 end

data/spec/cli_spec.rb

@@ -3,23 +3,28 @@
 require 'spec_helper'
 
 describe 'CLI' do
-  describe 'integration spec' do
+  describe 'integration spec for grayscale images' do
     let(:cli) { ImageSvd::CLI.new }
     let(:orig) { File.new('./spec/fixtures/2x2.jpg') }
+    let(:default_opts) do
+      {
+        input_file: orig,
+        convert: true,
+        num_singular_values: '2',
+        grayscale: true
+      }
+    end
 
     it 'converts an image without too great errors' do
       conv = './spec/fixtures/svd_image_output'
-      cli.run(
-        input_file: orig,
-        convert: true,
-        num_singular_values: 2,
-        output_name: conv
-      )
-      i = ImageSvd::ImageMatrix.new([2])
+      cli.run(default_opts.merge(output_name: conv))
+      i = ImageSvd::ImageMatrix.new([2], true)
       i.read_image(orig)
-      i2 = ImageSvd::ImageMatrix.new([2])
+      i2 = ImageSvd::ImageMatrix.new([2], true)
       i2.read_image(File.new("#{conv}_2_svs.jpg"))
-      diff_matrix = i.reconstruct_matrix - i2.reconstruct_matrix
+      m = i.channels.first.reconstruct_matrix
+      m2 = i2.channels.first.reconstruct_matrix
+      diff_matrix = m - m2
       diff_matrix.to_a.flatten.each do |diff_component|
         diff_component.abs.should be < 5
       end
@@ -31,23 +36,23 @@ describe 'CLI' do
     it 'archives, reads, and converts an image without too great errors' do
       conv = './spec/fixtures/svd_image_output'
       # archive
-      cli.run(
-        input_file: orig,
+      cli.run(default_opts.merge(
         archive: true,
-        num_singular_values: '2',
         output_name: conv
-      )
+      ))
       # read archive and write and image
-      cli.run(
+      cli.run(default_opts.merge(
         input_file: "#{conv}.svdim",
         read: true,
         output_name: "#{conv}_two"
-      )
-      i = ImageSvd::ImageMatrix.new([2])
+      ))
+      i = ImageSvd::ImageMatrix.new([2], true)
       i.read_image(orig)
-      i2 = ImageSvd::ImageMatrix.new([2])
+      i2 = ImageSvd::ImageMatrix.new([2], true)
       i2.read_image(File.new("#{conv}_two_2_svs.jpg"))
-      diff_matrix = i.reconstruct_matrix - i2.reconstruct_matrix
+      m = i.channels.first.reconstruct_matrix
+      m2 = i2.channels.first.reconstruct_matrix
+      diff_matrix = m - m2
       diff_matrix.to_a.flatten.each do |diff_component|
         diff_component.abs.should be < 5
       end
@@ -55,4 +60,81 @@ describe 'CLI' do
       %x(rm #{conv}_two_2_svs.jpg #{conv}.svdim)
     end
   end
+
+  describe 'integration spec for color images' do
+    let(:cli) { ImageSvd::CLI.new }
+    let(:orig) { File.new('./spec/fixtures/2x2_color.png') }
+    let(:default_opts) do
+      {
+        input_file: orig,
+        convert: true,
+        num_singular_values: '2',
+        grayscale: false
+      }
+    end
+
+    it 'converts an image without too great errors' do
+      conv = './spec/fixtures/svd_image_output'
+      cli.run(default_opts.merge(output_name: conv))
+      i = ImageSvd::ImageMatrix.new([2], false)
+      i.read_image(orig)
+      i2 = ImageSvd::ImageMatrix.new([2], false)
+      i2.read_image(File.new("#{conv}_2_svs.jpg"))
+      m = i.channels.map { |c| c.reconstruct_matrix }
+      m2 = i2.channels.map { |c| c.reconstruct_matrix }
+      diff_matricies = (0..2).to_a.map { |idx| m[idx] - m2[idx] }
+      diff_matricies.map(&:to_a).flatten.each do |diff_component|
+        diff_component.abs.should be < 5
+      end
+      # cleanup
+      %x(rm #{conv}_2_svs.jpg)
+    end
+
+    it 'archives, reads, and converts an image without too great errors' do
+      conv = './spec/fixtures/svd_image_output'
+      # archive
+      cli.run(default_opts.merge(
+        archive: true,
+        output_name: conv
+      ))
+      # read archive and write and image
+      cli.run(default_opts.merge(
+        input_file: "#{conv}.svdim",
+        read: true,
+        output_name: "#{conv}_two"
+      ))
+      i = ImageSvd::ImageMatrix.new([2], false)
+      i.read_image(orig)
+      i2 = ImageSvd::ImageMatrix.new([2], false)
+      i2.read_image(File.new("#{conv}_two_2_svs.jpg"))
+      m = i.channels.map { |c| c.reconstruct_matrix }
+      m2 = i2.channels.map { |c| c.reconstruct_matrix }
+      diff_matricies = (0..2).to_a.map { |idx| m[idx] - m2[idx] }
+      diff_matricies.map(&:to_a).flatten.each do |diff_component|
+        diff_component.abs.should be < 5
+      end
+      # cleanup
+      %x(rm #{conv}_two_2_svs.jpg #{conv}.svdim)
+    end
+  end
+
+  describe 'expand_input_files' do
+    it 'packages a file input into an array container' do
+      file = File.new('./spec/fixtures/2x2.jpg')
+      opts = { input_file: file, directory: false }
+      formatted = ImageSvd::Options.expand_input_files(opts)
+      formatted.should eq([file])
+    end
+    it 'expands valid files in a directory into an array' do
+      # This spec will break if any more fixtures are added
+      in_dir = File.new('./spec/fixtures/') # the output of trollop
+      contents = [
+        './spec/fixtures/2x2.jpg',
+        './spec/fixtures/2x2_color.png'
+      ]
+      opts = { input_file: in_dir, directory: true }
+      formatted = ImageSvd::Options.expand_input_files(opts)
+      formatted.map(&:path).should eq(contents)
+    end
+  end
 end

data/spec/image_matrix_spec.rb

@@ -8,9 +8,11 @@ describe ImageSvd::ImageMatrix do
   end
 
   it 'recovers a 2x3 matrix' do
-    i = ImageSvd::ImageMatrix.new([2])
-    i.decompose(@m)
-    rounded_matrix = Matrix[*i.matrix_to_valid_pixels(i.reconstruct_matrix)]
+    c = ImageSvd::Channel.new(@m, 2)
+    c.decompose
+    rounded_matrix = Matrix[
+      *ImageSvd::ImageMatrix.matrix_to_valid_pixels(c.reconstruct_matrix)
+    ]
     # due to numerical instability, even a 2x3 matrix needs to be rounded
     @m.should eq(rounded_matrix)
   end

data/spec/options_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'ImageSvd::Options' do
+  describe 'num_sing_val_out_from_archive' do
+    it 'returns the number of sing vals available when none are requested' do
+      o = ImageSvd::Options.num_sing_val_out_from_archive([6], 20)
+      o.should eq([6])
+    end
+
+    it 'allows the requested number of sing vals when more are available' do
+      o = ImageSvd::Options.num_sing_val_out_from_archive([6], 20)
+      o.should eq([6])
+    end
+
+    it 'returns the number of sing vals available if more are requested' do
+      o = ImageSvd::Options.num_sing_val_out_from_archive([400], 20)
+      o.should eq([20])
+    end
+
+    it 'returns the valid segment of a range of sing vals requested' do
+      o = ImageSvd::Options.num_sing_val_out_from_archive((1..40).to_a, 20)
+      o.should eq((1..20).to_a)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: image_svd
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Ilya Kavalerov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-23 00:00:00.000000000 Z
+date: 2014-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pnm
@@ -114,10 +114,13 @@ files:
 - lib/image_svd.rb
 - lib/image_svd/cli.rb
 - lib/image_svd/image_matrix.rb
+- lib/image_svd/util.rb
 - lib/image_svd/version.rb
 - spec/cli_spec.rb
 - spec/fixtures/2x2.jpg
+- spec/fixtures/2x2_color.png
 - spec/image_matrix_spec.rb
+- spec/options_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ilyakava/image_svd
 licenses:
@@ -146,5 +149,7 @@ summary: Compress images with Linear Algebra.
 test_files:
 - spec/cli_spec.rb
 - spec/fixtures/2x2.jpg
+- spec/fixtures/2x2_color.png
 - spec/image_matrix_spec.rb
+- spec/options_spec.rb
 - spec/spec_helper.rb