carlosnz-image_science 1.1.3

data/History.txt

@@ -0,0 +1,41 @@
+== 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
+lib/image_science.rb
+quick_thumb
+test/pix.png
+test/test_image_science.rb

data/README.txt

@@ -0,0 +1,66 @@
+ImageScience
+    http://seattlerb.rubyforge.org/ImageScience.html
+    http://rubyforge.org/projects/seattlerb
+    by Ryan Davis
+
+== 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
+
+== 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-2007 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,17 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/image_science.rb'
+
+Hoe.new('image_science', ImageScience::VERSION) do |p|
+  p.rubyforge_name = 'seattlerb'
+  p.description = p.paragraphs_of('README.txt', 2..3).join(" ")
+  p.summary = p.description[/^[^.]+\./]
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1].first.strip
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.extra_deps << 'RubyInline'
+  p.clean_globs << 'blah*png'
+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/lib/image_science.rb

@@ -0,0 +1,339 @@
+#!/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.1.3'
+
+  ##
+  # The top-level image loader opens +path+ and then yields the image.
+
+  def self.with_image(path) # :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); 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
+
+  ##
+  # converts the image to 8 bits , note DOES NOT YIELD
+  #
+  def convert_8_bits;
+  end
+
+  ##
+  # converts the image to 24 bits note DOES NOT YIELD
+  #
+  def convert_24_bits;
+  end
+
+  ##
+  # converts the image to 32 bits ( including alpha chanel for compisiting) note DOES NOT YIELD
+  #
+  def convert_32_bits;
+  end
+
+  ##
+  # 
+  #
+  def paste;
+  end
+
+  #
+  # make sure your foreground image is 32 bit and your background image is 24 bit, and both images are the same size note DOES NOT YIELD
+  #
+  def composite;
+  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(FIBITMAP *image, VALUE self, FREE_IMAGE_FORMAT fif) {
+         VALUE klass = fif ? self         : CLASS_OF(self);
+         VALUE type  = fif ? 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 obj;
+      }
+
+      VALUE wrap_and_yield(FIBITMAP *image, VALUE self, FREE_IMAGE_FORMAT fif) {
+        VALUE obj = wrap(image, self, fif);
+        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) {
+        if (! RTEST(ruby_debug)) return;
+        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)) {
+            result = wrap_and_yield(bitmap, self, fif);
+          }
+          return result;
+        }
+        rb_raise(rb_eTypeError, "Unknown file format");
+      }
+    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"
+      VALUE convert_to_8_bits()) {
+        FIBITMAP *copy;
+        VALUE result = Qnil;
+        GET_BITMAP(bitmap);
+
+        if (copy = FreeImage_ConvertTo8Bits(bitmap)) {
+          copy_icc_profile(self, bitmap, copy);
+          result = wrap(copy, self, 0);
+        }
+        return result;
+      }
+    END
+    
+    builder.c <<-"END"
+      VALUE convert_to_24_bits()) {
+        FIBITMAP *copy;
+        VALUE result = Qnil;
+        GET_BITMAP(bitmap);
+
+        if (copy = FreeImage_ConvertTo24Bits(bitmap)) {
+          copy_icc_profile(self, bitmap, copy);
+          result = wrap(copy, self, 0);
+        }
+        return result;
+      }
+    END
+
+    builder.c <<-"END"
+      VALUE convert_to_32_bits()) {
+        FIBITMAP *copy;
+        VALUE result = Qnil;
+        GET_BITMAP(bitmap);
+
+        if (copy = FreeImage_ConvertTo32Bits(bitmap)) {
+          copy_icc_profile(self, bitmap, copy);
+          result = wrap(copy, self, 0);
+        }
+        return result;
+     }
+    END
+  
+    builder.c <<-"END"
+      VALUE paste(VALUE src, int l, int t, int a) {
+        FIBITMAP *src_bitmap;
+        GET_BITMAP(bitmap);
+        Data_Get_Struct(src, FIBITMAP, src_bitmap);
+
+        if (FreeImage_Paste(bitmap, src_bitmap, l, t, a))
+        {
+         return Qtrue;
+        }
+        else
+        {
+          return Qfalse;
+        }
+      }
+    END
+    
+    builder.c <<-"END"
+      VALUE composite(VALUE use_file_background, VALUE background_color, VALUE background_image) {
+        VALUE result = Qnil;
+        BOOL useFileBackground;
+        RGBQUAD  *backgroundColor = NULL;
+        FIBITMAP *backgroundImage = NULL;
+        FIBITMAP *compositeImage = NULL;
+        GET_BITMAP(bitmap);
+
+        useFileBackground = (use_file_background == Qtrue) ? TRUE: FALSE;
+
+        if (background_color != Qnil)
+          Data_Get_Struct(background_color, RGBQUAD, backgroundColor);
+
+        if (background_image != Qnil)
+          Data_Get_Struct(background_image, FIBITMAP, backgroundImage);
+
+        if (compositeImage = FreeImage_Composite(bitmap, useFileBackground, backgroundColor, backgroundImage)) {
+            copy_icc_profile(self, bitmap, compositeImage);
+          result = wrap(compositeImage, 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) {
+        FIBITMAP *image;
+        if (w <= 0) rb_raise(rb_eArgError, "Width <= 0");
+        if (h <= 0) rb_raise(rb_eArgError, "Height <= 0");
+        GET_BITMAP(bitmap);
+        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(char * output) {
+        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)) { 
+          int flags = fif == FIF_JPEG ? JPEG_QUALITYSUPERB : 0;
+          GET_BITMAP(bitmap);
+          if (fif == FIF_PNG) FreeImage_DestroyICCProfile(bitmap);
+          return FreeImage_Save(fif, bitmap, output, flags) ? Qtrue : Qfalse;
+        }
+        rb_raise(rb_eTypeError, "Unknown file format");
+      }
+    END
+  end
+end

data/quick_thumb

@@ -0,0 +1,27 @@
+#!/usr/local/bin/ruby -w
+
+abort "#{File.basename $0} max_length files..." unless ARGV.size > 1
+
+require 'rubygems'
+require 'image_science'
+
+max_length = ARGV.shift.to_i
+
+ARGV.each do |file|
+  begin
+    result = ImageScience.with_image file do |img|
+      begin
+        img.thumbnail(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/test/test_image_science.rb

@@ -0,0 +1,124 @@
+require 'test/unit/testcase'
+require 'test/unit' if $0 == __FILE__
+require 'image_science'
+
+class TestImageScience < Test::Unit::TestCase
+  def deny x; assert ! x; end
+
+  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_nil ImageScience.with_image("nope#{@path}") do |img|
+      flunk
+    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
+
+    deny 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
+
+    deny 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
+
+    deny 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
+
+    deny File.exists?(@tmppath)
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: carlosnz-image_science
+version: !ruby/object:Gem::Version 
+  version: 1.1.3
+platform: ruby
+authors: 
+- Ryan Davis
+autorequire: 
+bindir: bin
+cert_chain: 
+date: 2007-05-30 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: RubyInline
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.1
+    version: 
+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/
+email: ryand-ruby@zenspider.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bench.rb
+- lib/image_science.rb
+- quick_thumb
+- test/pix.png
+- test/test_image_science.rb
+has_rdoc: true
+homepage: http://seattlerb.rubyforge.org/ImageScience.html
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: seattlerb
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 1
+summary: ImageScience is a clean and happy Ruby library that generates thumbnails -- and kicks the living crap out of RMagick.
+test_files: 
+- test/test_image_science.rb