smartimage 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.textile
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Tony Arcieri
+
+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/README.textile

@@ -0,0 +1,11 @@
+h1. SmartImage
+
+Hi.  There will be a real README here soon, I promise.
+
+h2. Credits
+
+SmartImage assumes your Ruby interpreter supports the absurdly powerful RMagick
+library, unless you're running JRuby, in which case it uses the absurdly 
+powerful Java Graphics2D library and AWT.
+
+Mongoose courtesy Wikimedia Commons: http://en.wikipedia.org/wiki/File:Mongoose.jpg

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "smartimage"
+    gem.summary = %Q{It's like a Swiss Army Knife for images, but one of those tiny ones you can keep on your keychain}
+    gem.description = <<-EOD
+    SmartImage provides a cross-platform solution for image compositing that works on both MRI and JRuby.
+    If using RMagick feels like swatting a fly with a nucler missile, and ImageScience just doesn't get 
+    you there, SmartImage is hopefully at that sweet spot in the middle
+    EOD
+    
+    gem.email = "tony@medioh.com"
+    gem.homepage = "http://github.com/tarcieri/smartimage"
+    gem.authors = ["Tony Arcieri"]
+    gem.add_dependency "imagesize", ">= 0.1.1"
+    gem.add_dependency "rmagick",   ">= 2.12.2"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "smartimage #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/smart_image.rb

@@ -0,0 +1,137 @@
+require 'image_size'
+require 'smart_image/ratio_calculator'
+
+# Load the appropriate canvas class for the current environment
+if defined? JRUBY_VERSION
+  require 'smart_image/java_canvas'
+else
+  require 'smart_image/rmagick_canvas'
+end
+
+# SmartImage: it's like a Swiss Army Knife for images, but one of those tiny
+# ones you can keep on your keychain.
+class SmartImage
+  # I'm sorry, I couldn't understand the data you gave me
+  class FormatError < ArgumentError; end
+  
+  # Struct type containing information about a given image
+  class Info < Struct.new(:width, :height, :type); end
+  
+  class << self
+    # Obtain basic information about the given image data
+    # Returns a SmartImage::Info object
+    def info(data)
+      img = ImageSize.new data
+      raise FormatError, "invalid image" if img.get_type == "OTHER"
+    
+      Info.new(img.width, img.height, img.get_type.downcase.to_sym)
+    end
+    
+    # Obtain information about a file
+    # Returns a SmartImage::Info object
+    def file_info(path)
+      info File.read(path)
+    end
+  end
+  
+  # Create a new SmartImage of the given width and height.  Always takes a
+  # block... no exceptions!  Returns a destroyed SmartImage object.
+  #
+  #  SmartImage.new(400, 300) do |compositor|
+  #    compositor.image "foo/bar.jpg", :x => 10, :y => 10
+  #    compositor.text  "Hello, world!", :x => 20, :y => 20
+  #    compositor.write "baz/qux.jpg"
+  #  end
+  #
+  # When used with a block, all images are automatically freed from memory
+  def initialize(width, height, &block)
+    raise ArgumentError, "give me a block, pretty please" unless block_given?
+    
+    @width, @height = Integer(width), Integer(height)
+    @canvas = SmartImage::Canvas.new @width, @height
+    
+    yield self
+    @canvas.destroy
+    @canvas = DeadCanvas.new
+  end
+  
+  class DeadCanvas
+    def method_missing(*args)
+      raise ArgumentError, "your image exists only within the SmartImage.new block"
+    end
+  end
+  
+  # Composite the given image data onto the SmartImage
+  #
+  # Accepts the following options:
+  #
+  # * x: coordinate of the upper left corner of the image (default 0)
+  # * y: ditto, it's the y coordinate
+  # * width: an alternate width
+  # * height: alternate height
+  # * preserve_aspect_ratio: should the aspect ratio be preserved? (default: true)
+  def composite(data, options = {})
+    info = self.class.info data
+    
+    opts = {
+      :x => 0,
+      :y => 0,
+      :width  => info.width,
+      :height => info.height,
+      :preserve_aspect_ratio => true
+    }.merge(options)
+  
+    if opts[:preserve_aspect_ratio]
+      composited_size = SmartImage::RatioCalculator.new(
+        :source_width  => info.width,
+        :source_height => info.height,
+        :dest_width  => Integer(opts[:width]), 
+        :dest_height => Integer(opts[:height])
+      ).size
+    
+      dest_width, dest_height = composited_size.width, composited_size.height
+    else
+      dest_width, dest_height = opts[:width], opts[:height]
+    end
+  
+    @canvas.composite data, :width  => Integer(dest_width),
+                            :height => Integer(dest_height),
+                            :x      => opts[:x], 
+                            :y      => opts[:y]
+  end
+  
+  # Composite a given image file onto the SmartImage.  Accepts the same options
+  # as the composite method
+  def composite_file(file, options = {})
+    composite File.read(file), options
+  end
+  
+  # Apply an alpha mask from the given image data.  Doesn't accept any options
+  # right now, sorry.  It's just another useless dangling options hash.
+  def alpha_mask(data, options = {})
+    @canvas.alpha_mask data
+  end
+  
+  # Apply an alpha mask from the given file.  Accepts the same options as the
+  # alpha_mask method.
+  def alpha_mask_file(file, options = {})
+    alpha_mask File.read(file), options
+  end
+  
+  # Encode the image with the given format (a file extension) and return it 
+  # as a string.  Doesn't accept any options at present.  The options hash is
+  # just there to annoy you and make you wish it had more options.
+  def encode(format, options = {})
+    # Sorry .jpeg lovers, I'm one of you too but the standard is jpg
+    format = :jpg if format.to_s == 'jpeg'
+    
+    @canvas.encode format, options
+  end
+  
+  # Write the resulting image out to disk.  Picks format based on filename.
+  # Takes the same options as encode
+  def write(path, options = {})    
+    format = File.extname(path).sub(/^\./, '')
+    File.open(path, 'w') { |file| file << encode(format, options) }
+  end
+end

data/lib/smart_image/base_canvas.rb

@@ -0,0 +1,46 @@
+class SmartImage
+  # Exception thrown for unimplemented features
+  class NotImplementedError < StandardError; end
+  
+  # This class defines the set of methods all canvases are expected to implement
+  # It also documents the set of methods that should be available for a canvas
+  class BaseCanvas
+    # Create a new canvas object of the given width and height
+    def initialize(width, height)
+      raise NotImplementedError, "some silly person forgot to define a constructor"
+    end
+    
+    # Destroy the canvas (if you need to)
+    def destroy
+      not_implemented :destroy
+    end
+    
+    # Has the canvas been destroyed already?
+    def destroyed?
+      not_implemented :destroyed?
+    end
+    
+    # Composite another image onto this canvas
+    def composite(image_data, width, height, options = {})
+      not_implemented :composite
+    end
+    
+    # Load the given file as an alpha mask for the image
+    def alpha_mask(image_data, options = {})
+      not_implemented :alpha_mask
+    end
+    
+    # Encode the image to the given format
+    def encode(format, options = {})
+      not_implemented :encode
+    end
+    
+    #######
+    private
+    #######
+    
+    def not_implemented(meth)
+      raise NotImplementedError, "#{meth} not implemented by #{self.class.inspect}"
+    end
+  end
+end

data/lib/smart_image/java_canvas.rb

@@ -0,0 +1,74 @@
+require 'smart_image/base_canvas'
+
+class SmartImage
+  # Canvas object backed by Java Graphics2D
+  class JavaCanvas < BaseCanvas
+    java_import java.awt.image.BufferedImage
+    java_import javax.imageio.ImageIO
+    java_import java.io.ByteArrayInputStream
+    java_import java.io.ByteArrayOutputStream
+    
+    def initialize(width, height)
+      @canvas = BufferedImage.new width, height, BufferedImage::TYPE_INT_ARGB
+    end
+    
+    # Stub out destroy since Java actually garbage collects crap, unlike... C
+    def destroy
+    end
+    
+    # Composite the given image data onto the canvas
+    def composite(image_data, options = {})
+      info = SmartImage.info image_data
+      opts = {
+        :width  => info.width,
+        :height => info.height,
+        :x => 0,
+        :y => 0
+      }.merge(options)
+      
+      input_stream = ByteArrayInputStream.new image_data.to_java_bytes
+      image = ImageIO.read input_stream
+      raise FormatError, "invalid image" unless image
+      
+      graphics = @canvas.graphics
+      graphics.draw_image image, opts[:x], opts[:y], opts[:width], opts[:height], nil
+    end
+    
+    # Load the given file as an alpha mask for the image
+    def alpha_mask(image_data, options = {})
+      input_stream = ByteArrayInputStream.new image_data.to_java_bytes
+      mask = ImageIO.read input_stream
+      
+      width = mask.width
+      image_data, mask_data = Java::int[width].new, Java::int[width].new
+      
+      mask.height.times do |y|
+        # fetch a line of data from each image
+        @canvas.get_rgb 0, y, width, 1, image_data, 0, 1
+        mask.get_rgb 0, y, width, 1, mask_data, 0, 1
+        
+        width.times do |x|
+          # mask away the alpha
+          color = image_data[x] & 0x00FFFFFF 
+          
+          # turn red from the mask into alpha
+          alpha = (mask_data[x] & 0x00FF0000) << 8 
+          
+          image_data[x] = color | alpha
+        end
+        
+        @canvas.set_rgb 0, y, width, 1, image_data, 0, 1
+      end
+    end
+    
+    # Encode the image to the given format
+    def encode(format, options = {})
+      output_stream = ByteArrayOutputStream.new
+      ImageIO.write(@canvas, format.to_s, output_stream)
+      String.from_java_bytes output_stream.to_byte_array
+    end
+  end
+  
+  # Java is our Canvas on Java, duh!
+  Canvas = JavaCanvas
+end

data/lib/smart_image/ratio_calculator.rb

@@ -0,0 +1,42 @@
+class SmartImage
+  class RatioCalculator
+    # Create a new RatioCalculator object with the given options
+    def initialize(options = {})
+      @options = options
+    end
+  
+    # Calculate the resulting size given a particular set of contraints
+    def size(options = {})
+      opts = @options.merge(options)
+    
+      source = Size.new opts[:source_width], opts[:source_height]
+      bounds = Size.new opts[:dest_width],   opts[:dest_height]
+    
+      # Calculate what the width would be if we matched the dest height
+      naive_width = bounds.height * source.aspect_ratio
+    
+      # If it fits, use it!
+      if naive_width <= bounds.width
+        width  = naive_width
+        height = naive_width / source.aspect_ratio
+      # Otherwise, the height must fit
+      else
+        height = bounds.width / source.aspect_ratio
+        width  = height * source.aspect_ratio
+      end
+
+      return Size.new(width, height)
+    end
+  
+    #
+    # Struct to hold the resulting size and compute aspect ratios
+    #
+    class Size < Struct.new(:width, :height, :aspect_ratio)
+      def initialize(width, height)
+        width, height = Integer(width), Integer(height)
+        aspect_ratio = width.to_f / height      
+        super(width, height, aspect_ratio)
+      end
+    end
+  end
+end

data/lib/smart_image/rmagick_canvas.rb

@@ -0,0 +1,57 @@
+require 'RMagick'
+require 'smart_image/base_canvas'
+
+class SmartImage
+  # Canvas object, backed by RMagick
+  class RMagickCanvas < BaseCanvas
+    include Magick
+    
+    def initialize(width, height)
+      @canvas = Image.new width, height do
+        self.background_color = "transparent"
+      end
+    end
+    
+    def destroy
+      @canvas.destroy!
+    end
+    
+    def composite(image_data, options = {})
+      image = ImageList.new
+      image.from_blob image_data
+      
+      opts = {
+        :width => image.columns,
+        :height => image.rows,
+        :x => 0,
+        :y => 0
+      }.merge(options)      
+      
+      image.thumbnail! opts[:width], opts[:height]
+      @canvas.composite! image, opts[:x], opts[:y], OverCompositeOp
+    ensure
+      image.destroy!
+    end
+    
+    # Load the given file as an alpha mask for the image
+    def alpha_mask(image_data, options = {})
+      mask = ImageList.new
+      mask.from_blob image_data
+      
+      # Disable this image's alpha channel to use the opacity data as a mask
+      mask.matte = false
+      @canvas.composite! mask, NorthWestGravity, CopyOpacityCompositeOp
+    ensure
+      mask.destroy!
+    end
+    
+    # Encode this image into the given format (as a file extension)
+    def encode(format, options = {})
+      @canvas.format = format.to_s.upcase
+      @canvas.to_blob
+    end
+  end
+  
+  # RMagick is our Canvas on everything besides JRuby.  Hope it works for you!
+  Canvas = RMagickCanvas
+end

data/smartimage.gemspec

@@ -0,0 +1,71 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{smartimage}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tony Arcieri"]
+  s.date = %q{2010-03-26}
+  s.description = %q{    SmartImage provides a cross-platform solution for image compositing that works on both MRI and JRuby.
+    If using RMagick feels like swatting a fly with a nucler missile, and ImageScience just doesn't get 
+    you there, SmartImage is hopefully at that sweet spot in the middle
+}
+  s.email = %q{tony@medioh.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.textile"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.textile",
+     "Rakefile",
+     "VERSION",
+     "lib/smart_image.rb",
+     "lib/smart_image/base_canvas.rb",
+     "lib/smart_image/java_canvas.rb",
+     "lib/smart_image/ratio_calculator.rb",
+     "lib/smart_image/rmagick_canvas.rb",
+     "smartimage.gemspec",
+     "spec/fixtures/mask.png",
+     "spec/fixtures/mongoose.jpg",
+     "spec/smart_image_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/tmp/.gitignore"
+  ]
+  s.homepage = %q{http://github.com/tarcieri/smartimage}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{It's like a Swiss Army Knife for images, but one of those tiny ones you can keep on your keychain}
+  s.test_files = [
+    "spec/smart_image_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<imagesize>, [">= 0.1.1"])
+      s.add_runtime_dependency(%q<rmagick>, [">= 2.12.2"])
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<imagesize>, [">= 0.1.1"])
+      s.add_dependency(%q<rmagick>, [">= 2.12.2"])
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<imagesize>, [">= 0.1.1"])
+    s.add_dependency(%q<rmagick>, [">= 2.12.2"])
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/spec/smart_image_spec.rb

@@ -0,0 +1,44 @@
+SPEC_DIR = File.dirname(__FILE__)
+require SPEC_DIR + '/spec_helper'
+
+describe SmartImage do
+  before :all do
+    @mongoose   = SPEC_DIR + '/fixtures/mongoose.jpg'
+    @mask       = SPEC_DIR + '/fixtures/mask.png'
+    @output_dir = SPEC_DIR + '/tmp/'
+  end
+  
+  it "obtains image information" do
+    info = SmartImage.file_info(@mongoose)
+    
+    info.type.should == :jpeg
+    info.width.should  == 1327
+    info.height.should == 1260
+  end
+  
+  it "composites images" do
+    SmartImage.new(800, 400) do |image|
+      image.composite_file @mongoose, :y => 15
+      image.write @output_dir + 'composited.png'
+    end
+  end
+  
+  it "scales when compositing" do
+    SmartImage.new(800, 400) do |image|
+      image.composite_file @mongoose, :y => 15
+      image.composite_file @mongoose, :x => 100, :y => 30, :width => 250, :height => 100
+      image.write @output_dir + 'scaled.png'
+    end
+  end
+  
+  it "alpha masks images" do
+    SmartImage.new(115, 95) do |image|
+      image.composite_file @mongoose, :width => 115, 
+                                      :height => 95,
+                                      :preserve_aspect_ratio => false
+                                      
+      image.alpha_mask_file @mask
+      image.write @output_dir + 'alpha_mask.png'
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# We depend on the ImageSize gem, at the very least
+require 'rubygems'
+
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib'
+require 'smart_image'

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: smartimage
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Tony Arcieri
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-26 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: imagesize
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.12.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+description: "    SmartImage provides a cross-platform solution for image compositing that works on both MRI and JRuby.\n    If using RMagick feels like swatting a fly with a nucler missile, and ImageScience just doesn't get \n    you there, SmartImage is hopefully at that sweet spot in the middle\n"
+email: tony@medioh.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.textile
+- Rakefile
+- VERSION
+- lib/smart_image.rb
+- lib/smart_image/base_canvas.rb
+- lib/smart_image/java_canvas.rb
+- lib/smart_image/ratio_calculator.rb
+- lib/smart_image/rmagick_canvas.rb
+- smartimage.gemspec
+- spec/fixtures/mask.png
+- spec/fixtures/mongoose.jpg
+- spec/smart_image_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/tmp/.gitignore
+has_rdoc: true
+homepage: http://github.com/tarcieri/smartimage
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --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: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: It's like a Swiss Army Knife for images, but one of those tiny ones you can keep on your keychain
+test_files: 
+- spec/smart_image_spec.rb
+- spec/spec_helper.rb