tdd-image_science 1.2.1

data/History.txt

@@ -0,0 +1,79 @@
+== 1.2.1-tdd / 2009-08-04
+
+* 1 enhancement:
+
+  * Added an optional jpeg_quality argument to save, taken into account when
+    saving to JPEG, which lets you define which quality level you want for
+    the JPEG output.  Any FreeImage JPEG_xxx constant is acceptable (they're
+    also present, commented, in the Ruby source).
+
+== 1.2.0 / 2009-06-23
+
+* 7 minor enhancements:
+
+  * Moved quick_thumb to bin/image_science_thumb and properly added.
+  * Added -s (square) flag to bin/image_science_thumb
+  * Added autorotating on image load. (choonkeat)
+  * Added ruby_inline to clean globs
+  * Added with_image_from_memory. (sumbach)
+  * Switched to minitest.
+  * Updated rakefile for now hoe capabilities.
+
+* 3 bug fixes:
+
+  * Check and convert to 24 BPP if save type is jpg. Caused by 32bpp png to jpg.
+  * Fixed 1.9isms
+  * Fixed BMP support. Tweaked whitespace.
+
+== 1.1.3 / 2007-05-30
+
+* 2 minor enhancements:
+
+  * Added quick_thumb as an example to look at.
+  * Error handler doesn't raise by default. Raises if $DEBUG==true.
+
+== 1.1.2 / 2007-04-18
+
+* 2 bug fixes:
+
+  * reports bad height/width values for resize
+  * explicitly removes ICC color profiles from PNGs (bug in freeimage).
+
+== 1.1.1 / 2007-03-08
+
+* 5 minor enhancements:
+
+  * Added error handler that raises with information about what went wrong.
+  * thumbnail is now pure ruby, everything now uses resize.
+  * Produces cleaner JPEG files, with a small cost to file size/speed.
+  * resize now uses Catmull-Rom spline filter for better quality.
+  * resize copies existing ICC Profile to thumbnail, producing better color.
+  * ICC Profile NOT copied for PNG as it seems to be buggy.
+
+* 1 bug fix:
+
+  * Fixed rdoc
+
+== 1.1.0 / 2007-01-05
+
+* 3 major enhancements:
+
+  * Added resize(width, height)
+  * Added save(path)
+  * All thumbnail and resize methods yield instead of saving directly.
+
+* 1 minor enhancement:
+
+  * Will now try to use FreeImage from ports if /opt/local exists.
+
+* 2 bug fixes:
+
+  * Fixed the linker issue on PPC.
+  * Rakefile will now clean the image files created by bench.rb
+
+== 1.0.0 / 2006-12-01
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,9 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bench.rb
+bin/image_science_thumb
+lib/image_science.rb
+test/pix.png
+test/test_image_science.rb

data/README.txt

@@ -0,0 +1,71 @@
+= ImageScience
+
+* http://seattlerb.rubyforge.org/ImageScience.html
+* http://rubyforge.org/projects/seattlerb
+* http://github.com/tdd/image_science/tree/master (fork with JPEG quality patch)
+
+== DESCRIPTION:
+
+ImageScience is a clean and happy Ruby library that generates
+thumbnails -- and kicks the living crap out of RMagick. Oh, and it
+doesn't leak memory like a sieve. :)
+
+For more information including build steps, see http://seattlerb.rubyforge.org/
+
+== FEATURES/PROBLEMS:
+
+* Glorious graphics manipulation magi... errr, SCIENCE! in less than 200 LoC!
+* Supports square and proportional thumbnails, as well as arbitrary resizes.
+* Pretty much any graphics format you could want. No really.
+
+== SYNOPSYS:
+
+  ImageScience.with_image(file) do |img|
+    img.cropped_thumbnail(100) do |thumb|
+      thumb.save "#{file}_cropped.png"
+    end
+
+    img.thumbnail(100) do |thumb|
+      thumb.save "#{file}_thumb.png"
+    end
+  end
+  
+The save method accepts an optional jpeg_quality argument, defaulting to JPEG_QUALITYSUPERB
+(100% quality / lossless), which you can change to any of the JPEG_xxx constants in FreeImage
+when saving to JPEG in order to considerably reduce file size.
+
+== REQUIREMENTS:
+
+* FreeImage
+* ImageScience
+
+== INSTALL:
+
+* Download and install FreeImage. See notes at url above.
+* sudo gem install -y image_science
+* see http://seattlerb.rubyforge.org/ImageScience.html for more info.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2006-2009 Ryan Davis, Seattle.rb
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,18 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugin :seattlerb
+Hoe.plugin :inline
+
+Hoe.spec 'image_science' do
+  developer 'Ryan Davis', 'ryand-ruby@zenspider.com'
+  developer 'Christophe Porteneuve', 'tdd@tddsworld.com'
+
+  self.rubyforge_name = 'seattlerb'
+
+  clean_globs << 'blah*png' << 'images/*_thumb.*'
+end
+
+# vim: syntax=Ruby

data/bench.rb

@@ -0,0 +1,63 @@
+#!/usr/local/bin/ruby -w
+
+require 'benchmark'
+require 'rubygems'
+require 'image_science'
+
+max = (ARGV.shift || 100).to_i
+ext = ARGV.shift || "png"
+
+file = "blah_big.#{ext}"
+
+if RUBY_PLATFORM =~ /darwin/ then
+  # how fucking cool is this???
+  puts "taking screenshot for thumbnailing benchmarks"
+  system "screencapture -SC #{file}"
+else
+  abort "You need to plonk down #{file} or buy a mac"
+end unless test ?f, "#{file}"
+
+ImageScience.with_image(file.sub(/#{ext}$/, 'png')) do |img|
+  img.save(file)
+end if ext != "png"
+
+puts "# of iterations = #{max}"
+Benchmark::bm(20) do |x|
+  x.report("null_time") {
+    for i in 0..max do
+      # do nothing
+    end
+  }
+
+  x.report("cropped") {
+    for i in 0..max do
+      ImageScience.with_image(file) do |img|
+        img.cropped_thumbnail(100) do |thumb|
+          thumb.save("blah_cropped.#{ext}")
+        end
+      end
+    end
+  }
+
+  x.report("proportional") {
+    for i in 0..max do
+      ImageScience.with_image(file) do |img|
+        img.thumbnail(100) do |thumb|
+          thumb.save("blah_thumb.#{ext}")
+        end
+      end
+    end
+  }
+
+  x.report("resize") {
+    for i in 0..max do
+      ImageScience.with_image(file) do |img|
+        img.resize(200, 200) do |resize|
+          resize.save("blah_resize.#{ext}")
+        end
+      end
+    end
+  }
+end
+
+# File.unlink(*Dir["blah*#{ext}"])

data/bin/image_science_thumb

@@ -0,0 +1,31 @@
+#!/usr/local/bin/ruby -ws
+
+$s ||= false
+
+abort "#{File.basename $0} max_length files..." unless ARGV.size > 1
+
+require 'rubygems'
+require 'image_science'
+
+max_length = ARGV.shift.to_i
+
+msg = $s ? :cropped_thumbnail : :thumbnail
+
+ARGV.each do |file|
+  begin
+    result = ImageScience.with_image file do |img|
+      begin
+        img.send(msg, max_length) do |thumb|
+          # add _thumb and switch from gif to png. Really. gif just sucks.
+          out = file.sub(/(\.[^\.]+)$/, '_thumb\1').sub(/gif$/, 'png')
+          thumb.save(out)
+        end
+      rescue => e
+        warn "Exception thumbnailing #{file}: #{e}"
+      end
+    end
+    p file => result
+  rescue => e
+    warn "Exception opening #{file}: #{e}"
+  end
+end

data/lib/image_science.rb

@@ -0,0 +1,295 @@
+#!/usr/local/bin/ruby -w
+
+require 'rubygems'
+require 'inline'
+
+##
+# Provides a clean and simple API to generate thumbnails using
+# FreeImage as the underlying mechanism.
+#
+# For more information or if you have build issues with FreeImage, see
+# http://seattlerb.rubyforge.org/ImageScience.html
+
+class ImageScience
+  VERSION = '1.2.1.tdd'
+
+  # These actually come from FreeImage.h.
+  JPEG_DEFAULT        = 0      #  75%
+  JPEG_FAST           = 1
+  JPEG_ACCURATE       = 2
+  JPEG_QUALITYSUPERB  = 0x80   # 100%
+  JPEG_QUALITYGOOD    = 0x100  #  75%
+  JPEG_QUALITYNORMAL  = 0x200  #  50%
+  JPEG_QUALITYAVERAGE = 0x400  #  25%
+  JPEG_QUALITYBAD     = 0x800  #  10%
+  JPEG_PROGRESSIVE    = 0x2000 # save as a progressive-JPEG (use | to combine with other flags)
+
+  ##
+  # The top-level image loader opens +path+ and then yields the image.
+
+  def self.with_image(path) # :yields: image
+  end
+
+  ##
+  # The top-level image loader, opens an image from the string +data+ and then yields the image.
+
+  def self.with_image_from_memory(data) # :yields: image
+  end
+
+  ##
+  # Crops an image to +left+, +top+, +right+, and +bottom+ and then
+  # yields the new image.
+
+  def with_crop(left, top, right, bottom) # :yields: image
+  end
+
+  ##
+  # Returns the width of the image, in pixels.
+
+  def width; end
+
+  ##
+  # Returns the height of the image, in pixels.
+
+  def height; end
+
+  ##
+  # Saves the image out to +path+. Changing the file extension will
+  # convert the file type to the appropriate format.
+
+  def save(path, jpeg_quality = JPEG_QUALITYSUPERB)
+    save_with_quality(path, jpeg_quality)
+  end
+  
+  def save_with_quality(path, jpeg_quality); end
+
+  ##
+  # Resizes the image to +width+ and +height+ using a cubic-bspline
+  # filter and yields the new image.
+
+  def resize(width, height) # :yields: image
+  end
+
+  ##
+  # Creates a proportional thumbnail of the image scaled so its longest
+  # edge is resized to +size+ and yields the new image.
+
+  def thumbnail(size) # :yields: image
+    w, h = width, height
+    scale = size.to_f / (w > h ? w : h)
+
+    self.resize((w * scale).to_i, (h * scale).to_i) do |image|
+      yield image
+    end
+  end
+
+  ##
+  # Creates a square thumbnail of the image cropping the longest edge
+  # to match the shortest edge, resizes to +size+, and yields the new
+  # image.
+
+  def cropped_thumbnail(size) # :yields: image
+    w, h = width, height
+    l, t, r, b, half = 0, 0, w, h, (w - h).abs / 2
+
+    l, r = half, half + h if w > h
+    t, b = half, half + w if h > w
+
+    with_crop(l, t, r, b) do |img|
+      img.thumbnail(size) do |thumb|
+        yield thumb
+      end
+    end
+  end
+
+  inline do |builder|
+    if test ?d, "/opt/local" then
+      builder.add_compile_flags "-I/opt/local/include"
+      builder.add_link_flags "-L/opt/local/lib"
+    end
+
+    builder.add_link_flags "-lfreeimage"
+    builder.add_link_flags "-lstdc++" # only needed on PPC for some reason. lame
+    builder.include '"FreeImage.h"'
+
+    builder.prefix <<-"END"
+      #define GET_BITMAP(name) FIBITMAP *(name); Data_Get_Struct(self, FIBITMAP, (name)); if (!(name)) rb_raise(rb_eTypeError, "Bitmap has already been freed")
+    END
+
+    builder.prefix <<-"END"
+      VALUE unload(VALUE self) {
+        GET_BITMAP(bitmap);
+
+        FreeImage_Unload(bitmap);
+        DATA_PTR(self) = NULL;
+        return Qnil;
+      }
+    END
+
+    builder.prefix <<-"END"
+      VALUE wrap_and_yield(FIBITMAP *image, VALUE self, FREE_IMAGE_FORMAT fif) {
+        unsigned int self_is_class = rb_type(self) == T_CLASS;
+        VALUE klass = self_is_class ? self         : CLASS_OF(self);
+        VALUE type  = self_is_class ? INT2FIX(fif) : rb_iv_get(self, "@file_type");
+        VALUE obj = Data_Wrap_Struct(klass, NULL, NULL, image);
+        rb_iv_set(obj, "@file_type", type);
+        return rb_ensure(rb_yield, obj, unload, obj);
+      }
+    END
+
+    builder.prefix <<-"END"
+      void copy_icc_profile(VALUE self, FIBITMAP *from, FIBITMAP *to) {
+        FREE_IMAGE_FORMAT fif = FIX2INT(rb_iv_get(self, "@file_type"));
+        if (fif != FIF_PNG && FreeImage_FIFSupportsICCProfiles(fif)) {
+          FIICCPROFILE *profile = FreeImage_GetICCProfile(from);
+          if (profile && profile->data) {
+            FreeImage_CreateICCProfile(to, profile->data, profile->size);
+          }
+        }
+      }
+    END
+
+    builder.prefix <<-"END"
+      void FreeImageErrorHandler(FREE_IMAGE_FORMAT fif, const char *message) {
+        rb_raise(rb_eRuntimeError,
+                 "FreeImage exception for type %s: %s",
+                  (fif == FIF_UNKNOWN) ? "???" : FreeImage_GetFormatFromFIF(fif),
+                  message);
+      }
+    END
+
+    builder.add_to_init "FreeImage_SetOutputMessage(FreeImageErrorHandler);"
+
+    builder.c_singleton <<-"END"
+      VALUE with_image(char * input) {
+        FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
+
+        fif = FreeImage_GetFileType(input, 0);
+        if (fif == FIF_UNKNOWN) fif = FreeImage_GetFIFFromFilename(input);
+        if ((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)) {
+          FIBITMAP *bitmap;
+          VALUE result = Qnil;
+          int flags = fif == FIF_JPEG ? JPEG_ACCURATE : 0;
+          if (bitmap = FreeImage_Load(fif, input, flags)) {
+            FITAG *tagValue = NULL;
+            FreeImage_GetMetadata(FIMD_EXIF_MAIN, bitmap, "Orientation", &tagValue); 
+            switch (tagValue == NULL ? 0 : *((short *) FreeImage_GetTagValue(tagValue))) {
+              case 6:
+                bitmap = FreeImage_RotateClassic(bitmap, 270);
+                break;
+              case 3:
+                bitmap = FreeImage_RotateClassic(bitmap, 180);
+                break;
+              case 8:
+                bitmap = FreeImage_RotateClassic(bitmap, 90);
+                break;
+              default:
+               break;
+            }
+
+            result = wrap_and_yield(bitmap, self, fif);
+          }
+          return result;
+        }
+        rb_raise(rb_eTypeError, "Unknown file format");
+      }
+    END
+
+    builder.c_singleton <<-"END"
+      VALUE with_image_from_memory(VALUE image_data) {
+        FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
+
+        Check_Type(image_data, T_STRING);
+        BYTE *image_data_ptr    = (BYTE*)RSTRING_PTR(image_data);
+        DWORD image_data_length = RSTRING_LEN(image_data);
+        FIMEMORY *stream = FreeImage_OpenMemory(image_data_ptr, image_data_length);
+
+        if (NULL == stream) {
+          rb_raise(rb_eTypeError, "Unable to open image_data");
+        }
+
+        fif = FreeImage_GetFileTypeFromMemory(stream, 0);
+        if ((fif == FIF_UNKNOWN) || !FreeImage_FIFSupportsReading(fif)) {
+          rb_raise(rb_eTypeError, "Unknown file format");
+        }
+
+        FIBITMAP *bitmap = NULL;
+        VALUE result = Qnil;
+        int flags = fif == FIF_JPEG ? JPEG_ACCURATE : 0;
+        bitmap = FreeImage_LoadFromMemory(fif, stream, flags);
+        FreeImage_CloseMemory(stream);
+        if (bitmap) {
+          result = wrap_and_yield(bitmap, self, fif);
+        }
+        return result;
+      }
+    END
+
+    builder.c <<-"END"
+      VALUE with_crop(int l, int t, int r, int b) {
+        FIBITMAP *copy;
+        VALUE result = Qnil;
+        GET_BITMAP(bitmap);
+
+        if (copy = FreeImage_Copy(bitmap, l, t, r, b)) {
+          copy_icc_profile(self, bitmap, copy);
+          result = wrap_and_yield(copy, self, 0);
+        }
+        return result;
+      }
+    END
+
+    builder.c <<-"END"
+      int height() {
+        GET_BITMAP(bitmap);
+
+        return FreeImage_GetHeight(bitmap);
+      }
+    END
+
+    builder.c <<-"END"
+      int width() {
+        GET_BITMAP(bitmap);
+
+        return FreeImage_GetWidth(bitmap);
+      }
+    END
+
+    builder.c <<-"END"
+      VALUE resize(long w, long h) {
+        if (w <= 0) rb_raise(rb_eArgError, "Width <= 0");
+        if (h <= 0) rb_raise(rb_eArgError, "Height <= 0");
+        GET_BITMAP(bitmap);
+        FIBITMAP *image = FreeImage_Rescale(bitmap, w, h, FILTER_CATMULLROM);
+        if (image) {
+          copy_icc_profile(self, bitmap, image);
+          return wrap_and_yield(image, self, 0);
+        }
+        return Qnil;
+      }
+    END
+
+    builder.c <<-"END"
+      VALUE save_with_quality(char * output, int jpeg_quality) {
+        FREE_IMAGE_FORMAT fif = FreeImage_GetFIFFromFilename(output);
+        if (fif == FIF_UNKNOWN) fif = FIX2INT(rb_iv_get(self, "@file_type"));
+        if ((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsWriting(fif)) {
+          GET_BITMAP(bitmap);
+          int flags = fif == FIF_JPEG ? jpeg_quality : 0;
+          BOOL result = 0, unload = 0;
+
+          if (fif == FIF_PNG) FreeImage_DestroyICCProfile(bitmap);
+          if (fif == FIF_JPEG && FreeImage_GetBPP(bitmap) != 24)
+            bitmap = FreeImage_ConvertTo24Bits(bitmap), unload = 1; // sue me
+
+          result = FreeImage_Save(fif, bitmap, output, flags);
+
+          if (unload) FreeImage_Unload(bitmap);
+
+          return result ? Qtrue : Qfalse;
+        }
+        rb_raise(rb_eTypeError, "Unknown file format");
+      }
+    END
+  end
+end

data/test/test_image_science.rb

@@ -0,0 +1,183 @@
+dir = File.expand_path "~/.ruby_inline"
+if test ?d, dir then
+  require 'fileutils'
+  puts "nuking #{dir}"
+  # force removal, Windoze is bitching at me, something to hunt later...
+  FileUtils.rm_r dir, :force => true
+end
+
+require 'rubygems'
+require 'minitest/unit'
+require 'minitest/autorun' if $0 == __FILE__
+require 'image_science'
+
+class TestImageScience < MiniTest::Unit::TestCase
+  def setup
+    @path = 'test/pix.png'
+    @tmppath = 'test/pix-tmp.png'
+    @h = @w = 50
+  end
+
+  def teardown
+    File.unlink @tmppath if File.exist? @tmppath
+  end
+
+  def test_class_with_image
+    ImageScience.with_image @path do |img|
+      assert_kind_of ImageScience, img
+      assert_equal @h, img.height
+      assert_equal @w, img.width
+      assert img.save(@tmppath)
+    end
+
+    assert File.exists?(@tmppath)
+
+    ImageScience.with_image @tmppath do |img|
+      assert_kind_of ImageScience, img
+      assert_equal @h, img.height
+      assert_equal @w, img.width
+    end
+  end
+
+  def test_class_with_image_missing
+    assert_raises TypeError do
+      ImageScience.with_image @path + "nope" do |img|
+        flunk
+      end
+    end
+  end
+
+  def test_class_with_image_missing_with_img_extension
+    assert_raises RuntimeError do
+      assert_nil ImageScience.with_image("nope#{@path}") do |img|
+        flunk
+      end
+    end
+  end
+
+  def test_class_with_image_from_memory
+    data = File.new(@path).binmode.read
+
+    ImageScience.with_image_from_memory data do |img|
+      assert_kind_of ImageScience, img
+      assert_equal @h, img.height
+      assert_equal @w, img.width
+      assert img.save(@tmppath)
+    end
+
+    assert File.exists?(@tmppath)
+
+    ImageScience.with_image @tmppath do |img|
+      assert_kind_of ImageScience, img
+      assert_equal @h, img.height
+      assert_equal @w, img.width
+    end
+  end
+
+  def test_class_with_image_from_memory_empty_string
+    assert_raises TypeError do
+      ImageScience.with_image_from_memory "" do |img|
+        flunk
+      end
+    end
+  end
+
+  def test_resize
+    ImageScience.with_image @path do |img|
+      img.resize(25, 25) do |thumb|
+        assert thumb.save(@tmppath)
+      end
+    end
+
+    assert File.exists?(@tmppath)
+
+    ImageScience.with_image @tmppath do |img|
+      assert_kind_of ImageScience, img
+      assert_equal 25, img.height
+      assert_equal 25, img.width
+    end
+  end
+
+  def test_resize_floats
+    ImageScience.with_image @path do |img|
+      img.resize(25.2, 25.7) do |thumb|
+        assert thumb.save(@tmppath)
+      end
+    end
+
+    assert File.exists?(@tmppath)
+
+    ImageScience.with_image @tmppath do |img|
+      assert_kind_of ImageScience, img
+      assert_equal 25, img.height
+      assert_equal 25, img.width
+    end
+  end
+
+  def test_resize_zero
+    assert_raises ArgumentError do
+      ImageScience.with_image @path do |img|
+        img.resize(0, 25) do |thumb|
+          assert thumb.save(@tmppath)
+        end
+      end
+    end
+
+    refute File.exists?(@tmppath)
+
+    assert_raises ArgumentError do
+      ImageScience.with_image @path do |img|
+        img.resize(25, 0) do |thumb|
+          assert thumb.save(@tmppath)
+        end
+      end
+    end
+
+    refute File.exists?(@tmppath)
+  end
+
+  def test_resize_negative
+    assert_raises ArgumentError do
+      ImageScience.with_image @path do |img|
+        img.resize(-25, 25) do |thumb|
+          assert thumb.save(@tmppath)
+        end
+      end
+    end
+
+    refute File.exists?(@tmppath)
+
+    assert_raises ArgumentError do
+      ImageScience.with_image @path do |img|
+        img.resize(25, -25) do |thumb|
+          assert thumb.save(@tmppath)
+        end
+      end
+    end
+
+    refute File.exists?(@tmppath)
+  end
+
+  def test_save_with_quality
+    tmppath = 'pix-tmp.jpg'
+    ImageScience.with_image @path do |img|
+      assert img.save(tmppath)
+    end
+
+    assert File.exists?(tmppath)
+    superb_size = File.size(tmppath)
+
+    ImageScience.with_image @path do |img|
+      assert img.save(tmppath, ImageScience::JPEG_QUALITYNORMAL)
+    end
+
+    ImageScience.with_image tmppath do |img|
+      assert_kind_of ImageScience, img
+      assert File.size(tmppath) <= superb_size / 2
+    end
+
+  ensure
+    File.unlink tmppath if File.exist? tmppath
+  end
+
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: tdd-image_science
+version: !ruby/object:Gem::Version 
+  version: 1.2.1
+platform: ruby
+authors: 
+- Ryan Davis
+- Christophe Porteneuve
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-04 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.15"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: diff-lcs
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.2
+    version: 
+description: "This is a fork of Ryan\xE2\x80\x99s image_science lib that adds JPEG quality control on save operations."
+email: tdd@tddsworld.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bench.rb
+- bin/image_science_thumb
+- lib/image_science.rb
+- test/pix.png
+- test/test_image_science.rb
+has_rdoc: true
+homepage: http://github.com/tdd/image_science
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: image_science
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: "This is a fork of Ryan\xE2\x80\x99s image_science lib that adds JPEG quality control on save operations."
+test_files: []
+