imgry 0.1.0

data/README.md

@@ -0,0 +1,18 @@
+# Imgry
+
+A Ruby gem for fast image resizing/cropping designed for JRuby with MRI support.
+
+Imgry provides an elegant interface and optimizations to third party libraries: Imgscalr, ImageVoodoo and MiniMagick. The library was designed to work as fast as possible under JRuby, and it does, from what we've seen it outperforms any other JRuby image resizing library, if it doesn't, please show us and let's improve it!
+
+It's also convienient for teams that work between MRI and JRuby, working seamlessly across development/production app environments.
+
+We've also implemented ImageMagick/GraphicsMagick's geometry for defining sizes such as "500x", "300x200!", "256x100>", etc. This works consistently across all image processors.
+
+# Authors
+
+* Peter Kieltyka
+* Haifeng Cao
+
+# License
+
+MIT License - Copyright (c) 2007-2012 Nulayer Inc.

data/lib/imgry.rb

@@ -0,0 +1,24 @@
+module Imgry
+  extend self
+
+  def with_bytes(img_blob, format=nil)
+  end
+
+  def from_file(img_blob, format=nil)
+  end
+
+  def default_processor
+    :mini_magick
+  end
+
+  def default_processor=(default_processor)
+    @default_processor = default_processor
+  end
+
+end
+
+Imagery = Imgry
+
+require 'imgry/version'
+require 'imgry/geometry'
+require 'imgry/processor'

data/lib/imgry/geometry.rb

@@ -0,0 +1,48 @@
+module Imgry
+  module Geometry
+    extend self
+
+    def scale(orig_width, orig_height, geometry)
+      op = geometry[-1] # Expecting !, >, <, or nothing
+      new_width, new_height = nil, nil
+      ask_width, ask_height = geometry.split('x').map {|x| x.to_i }
+      ask_height ||= 0
+      aspect_ratio = orig_width.to_f / orig_height.to_f
+      
+      scale = Proc.new do
+        if ask_width == 0 || ask_width < ask_height
+          new_width, new_height = scale_by_height(ask_height, aspect_ratio)
+        else
+          new_width, new_height = scale_by_width(ask_width, aspect_ratio)
+        end
+      end
+
+      case op
+      when '!'
+        new_width, new_height = ask_width.to_i, ask_height.to_i
+      when '>'
+        scale.call if orig_width > ask_width || orig_height > ask_height
+      when '<'
+        scale.call if orig_width < ask_width || orig_height < ask_height
+      else
+        scale.call
+      end
+
+      # In the end, we've determined we don't want to resizie (perhaps due to > or < operations)
+      # return [nil,nil] if new_width.nil? || new_width.nil?
+
+      # binding.pry
+
+      [new_width, new_height]
+    end
+
+    def scale_by_width(new_width, aspect_ratio)
+      [new_width.to_i, (new_width / aspect_ratio).to_i]
+    end
+
+    def scale_by_height(new_height, aspect_ratio)
+      [(new_height * aspect_ratio).to_i, new_height.to_i]
+    end
+
+  end
+end

data/lib/imgry/processor.rb

@@ -0,0 +1,43 @@
+module Imgry
+  module Processor
+
+    class Adapter
+
+      def self.with_bytes(img_blob, format=nil)
+        new(img_blob, format)
+      end
+
+      def self.from_file(path, format=nil)
+        # TODO: .. get the format from the filepath ... unless specified..
+      end
+
+      def self.lib_loaded?
+        !!@lib_loaded
+      end
+
+      def initialize(img_blob, format=nil)
+        self.class.load_lib! if !self.class.lib_loaded?
+
+        @img_blob = img_blob
+        @format = format
+        load_image_blob!
+      end
+
+      def aspect_ratio
+        width.to_f / height.to_f
+      end
+
+      # TODO .. add abstract methods.. at least comments..
+
+    end
+
+    class InvalidImageError < StandardError; end
+
+  end
+end
+
+%w(
+  image_voodoo
+  img_scalr
+  mini_magick
+).each {|lib| require "imgry/processor/#{lib}" }

data/lib/imgry/processor/image_voodoo.rb

@@ -0,0 +1,90 @@
+module Imgry
+  module Processor
+
+    class ImageVoodoo < Adapter
+
+      def self.load_lib!
+        return if @lib_loaded
+
+        if RUBY_ENGINE != 'jruby'
+          raise 'The ImageVoodoo processor is only available on JRuby.'
+        end
+
+        begin
+          require 'image_voodoo'
+        rescue LoadError
+          raise 'Cannot load image_voodoo gem.'
+        end
+
+        # TODO... 
+        # turn on opengl........
+
+        # Add-ons..
+        ::ImageVoodoo.class_eval do
+          def src
+            @src
+          end
+        end
+
+        @lib_loaded = true
+      end
+
+      #-----
+
+      def load_image_blob!
+        begin
+          @image_ref = ::ImageVoodoo.with_bytes(@img_blob)
+          if @image_ref.src.nil?
+            raise InvalidImageError, "Image is either corrupt or unsupported."
+          end
+        rescue => ex
+          raise InvalidImageError, ex.message
+        end
+      end
+
+      def resize!(geometry)
+        return if geometry.nil?        
+        @image_ref = @image_ref.resize(*Geometry.scale(width, height, geometry))
+      end
+
+      def width
+        @image_ref.width
+      end
+
+      def height
+        @image_ref.height
+      end
+
+      def to_blob
+        # TODO: output format is hardcoded, we should get the format
+        # that it is while coming in, and use that on the way out..
+        # we can use jpg by default..
+        @image_ref.bytes('jpg')
+      end
+
+      def raw
+        @image_ref
+      end
+
+      def supported_write_formats
+        # Typical formats:
+        # [BMP, bmp, jpg, JPG, wbmp, jpeg, png, JPEG, PNG, WBMP, GIF, gif]
+        ::ImageVoodoo::ImageIO.getReaderFormatNames.to_a
+      end
+
+      def supported_read_formats
+        # Typical formats:
+        # [BMP, bmp, jpg, JPG, wbmp, jpeg, png, JPEG, PNG, WBMP, GIF, gif]
+        ::ImageVoodoo::ImageIO.getWriterFormatNames.to_a
+      end
+
+      def clean!
+        @image_ref = nil
+        @src_blob = nil
+      end
+
+    end
+
+  end
+end
+

data/lib/imgry/processor/img_scalr.rb

@@ -0,0 +1,182 @@
+module Imgry
+  module Processor
+
+    class ImgScalr < Adapter
+
+      def self.load_lib!
+        return if @lib_loaded
+
+        if RUBY_ENGINE != 'jruby'
+          raise 'The ImgScalr processor is only available on JRuby.'
+        end
+
+        self.class_eval do
+          include Java
+
+          require 'java/imgscalr-lib-4.2.jar'
+
+          java_import javax.imageio.ImageIO
+          java_import org.imgscalr.Scalr
+          java_import java.awt.image.BufferedImage
+          java_import java.io.ByteArrayInputStream
+          java_import java.io.ByteArrayOutputStream
+        end
+
+        @lib_loaded = true
+      end
+
+      #-----
+
+      def load_image_blob!
+        @img_blob = @img_blob.to_java_bytes if String === @img_blob
+
+        @image_ref = ImageIO.read(ByteArrayInputStream.new(@img_blob))
+        # TODO .. raise if bullshit... InvalidImageError...
+
+      end
+
+      def resize!(width, height)
+        options = {}
+        method = options[:method] ? options[:method] : Scalr::Method::QUALITY
+        mode   = options[:mode] ? options[:mode] : Scalr::Mode::FIT_EXACT
+        ops    = options[:ops] ? options[:ops] : Scalr::OP_ANTIALIAS
+
+        @image_ref = Scalr.resize(@image_ref, method, mode, width, height, ops)
+      end
+
+      def width
+        @image_ref.width
+      end
+
+      def height
+        @image_ref.height
+      end
+
+      def to_blob(format=nil)
+        format ||= 'jpg'
+
+        out = ByteArrayOutputStream.new
+        ImageIO.write(@image_ref, format, out)
+        String.from_java_bytes(out.to_byte_array)
+      end
+
+      def clean!
+      end
+
+    end
+
+  end
+end
+
+__END__
+class ImgScalrVoodoo
+  include Java
+
+  require 'java/imgscalr-lib-4.2.jar'
+
+  java_import javax.imageio.ImageIO
+  java_import org.imgscalr.Scalr
+  java_import java.awt.image.BufferedImage
+
+  JFile = java.io.File
+
+  def initialize(src)
+    @src = src
+  end
+
+  def self.with_image(path)
+    raise ArgumentError, "file does not exist" unless File.file?(path)
+    image = guard do
+              buffered_image = ImageIO.read(JFile.new(path))
+              buffered_image ? ImgScalrVoodoo.new(buffered_image) : nil
+            end
+
+    image && block_given? ? yield(image) : image
+  end
+
+
+  def self.with_bytes(bytes)
+    bytes = bytes.to_java_bytes if String === bytes
+    image = guard do
+              ImgScalrVoodoo.new(ImageIO.read(ByteArrayInputStream.new(bytes)))
+            end
+
+    block_given? ? yield(image) : image
+  end
+
+  def img_scalr_resize(width, height, options={})
+    method = options[:method]? options[:method] : Scalr::Method::QUALITY
+    mode   = options[:mode]? options[:mode] : Scalr::Mode::FIT_EXACT
+    ops    = options[:ops]? options[:ops] : Scalr::OP_ANTIALIAS
+
+    target = guard { Scalr.resize(@src, method, mode, width, height, ops) }
+
+    image = ImgScalrVoodoo.new(target)
+
+    block_given? ? yield(image) : image
+  rescue NativeException => ne
+    raise ArgumentError, ne.message
+  end
+
+  def resize(width, height)
+    image = img_scalr_resize(width, height)
+    block_given? ? yield(image) : image
+  end
+
+  def cropped_thumbnail(size)
+    l, t, r, b, half = 0, 0, width, height, (width - height).abs / 2
+    l, r = half, half + height if width > height
+    t, b = half, half + width if height > width
+
+    target = with_crop(l, t, r, b).thumbnail(size)
+    block_given? ? yield(target) : target
+  end
+
+  def save(file)
+    format = File.extname(file)
+    return false if format == ""
+    format = format[1..-1].downcase
+    guard { ImageIO.write(@src, format, JFile.new(file)) }
+    true
+  end
+
+  def scale(ratio)
+    new_width, new_height = (width * ratio).to_i, (height * ratio).to_i
+    target = resize(new_width, new_height)
+    block_given? ? yield(target) : target
+  end
+
+  def thumbnail(size)
+    target = scale(size.to_f / (width > height ? width : height))
+    block_given? ? yield(target) : target
+  end
+
+  def with_crop(left, top, right, bottom)
+    image = guard { ImgScalrVoodoo.new(Scalr.crop(@src, left, top, right-left, bottom-top)) }
+    block_given? ? yield(image) : image
+  end
+
+  def self.guard(&block)
+    begin
+      return block.call
+    rescue NoMethodError => e
+      "Unimplemented Feature: #{e}"
+    end
+  end
+
+  def guard(&block)
+    ImgScalrVoodoo.guard(&block)
+  end
+
+  def height
+    @src.height
+  end
+
+  def width
+    @src.width
+  end
+
+  def to_java
+    @src
+  end
+end

data/lib/imgry/processor/mini_magick.rb

@@ -0,0 +1,57 @@
+module Imgry
+  module Processor
+
+    class MiniMagick < Adapter
+
+      def self.load_lib!
+        return if @lib_loaded
+
+        begin
+          require 'mini_magick'
+        rescue LoadError
+          raise "Cannot load mini_magick gem"
+        end
+
+        ::MiniMagick.processor = :gm
+        ::MiniMagick.timeout = 45
+
+        @lib_loaded = true
+      end
+
+      #-----
+
+      def load_image_blob!
+        begin
+          @image_ref = ::MiniMagick::Image.read(@img_blob)
+        rescue ::MiniMagick::Invalid => ex
+          raise InvalidImageError, ex.message
+        end
+      end
+
+      def resize!(geometry)
+        @image_ref.resize(geometry) if !geometry.nil?
+        nil
+      end
+
+      def width
+        @image_ref['width']
+      end
+
+      def height
+        @image_ref['height']
+      end
+
+      def to_blob
+        @image_ref.to_blob
+      end
+
+      def clean!
+        @image_ref.destroy!
+        @image_ref = nil
+        @img_blob = nil
+      end
+
+    end
+
+  end
+end

data/lib/imgry/version.rb

@@ -0,0 +1,3 @@
+module Imgry
+  VERSION = '0.1.0'
+end

data/spec/imgry/geometry_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Imgry::Geometry do
+
+  it 'scales to a strict size' do
+    size = Imgry::Geometry.scale(300, 500, "70x70!")
+    size.should == [70, 70]
+  end
+
+  it 'scales to a size with aspect ratio maintained' do
+    size = Imgry::Geometry.scale(1024, 768, "600x")
+    size.should == [600, 450]
+  end
+
+  it 'scales to a size with aspect ratio maintained' do
+    size = Imgry::Geometry.scale(1024, 768, "x300")
+    size.should == [400, 300]
+  end
+
+  it 'shrinks to a size when dimensions are larger then corresponding width/height' do
+    size = Imgry::Geometry.scale(1024, 768, "600x600>")
+    
+    binding.pry
+
+    # size.should == [400, 300]
+  end
+
+  # it 'enlarges to a size when dimensions are smaller then corresponding width/height' do
+  #   geo = "600x600<"
+  #   # TODO..
+  # end
+
+end

data/spec/imgry/processor/image_voodoo_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Imgry::Processor::ImageVoodoo do
+
+  let (:img_data) { IO.read(SPEC_ROOT.join('support/335is.jpg')) }
+
+  context "a pretty picture" do    
+
+    it "basic loading and resizing of an image" do
+      img = Imgry::Processor::ImageVoodoo.with_bytes(img_data)
+
+      img.width.should == 1024
+      img.height.should == 764
+
+      img.resize!("512x")
+      img.width.should == 512
+      img.height.should == 382
+
+      new_img_blob = img.to_blob
+      new_img_blob.length.should < img_data.length
+      new_img_blob.length.should == 32159
+    end
+
+  end
+
+end

data/spec/imgry/processor/img_scalr_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Imgry::Processor::ImgScalr do
+
+  let (:img_data) { IO.read(SPEC_ROOT.join('support/335is.jpg')) }
+
+  context "a pretty picture" do    
+
+    it "basic loading and resizing of an image" do
+      img = Imgry::Processor::ImgScalr.with_bytes(img_data)
+
+      img.width.should == 1024
+      img.height.should == 764
+
+      # img.resize!("512x")
+      img.resize!(512, 382)
+      img.width.should == 512
+      img.height.should == 382
+
+      new_img_blob = img.to_blob
+      new_img_blob.length.should < img_data.length
+      new_img_blob.length.should == 30319
+    end
+
+  end
+
+end

data/spec/imgry/processor/mini_magick_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Imgry::Processor::MiniMagick do
+
+  let (:img_data) { IO.read(SPEC_ROOT.join('support/335is.jpg')) }
+
+  context "a pretty picture" do    
+
+    it "basic loading and resizing of an image" do
+      img = Imgry::Processor::MiniMagick.with_bytes(img_data)
+
+      img.width.should == 1024
+      img.height.should == 764
+
+      img.resize!("512x")
+      img.width.should == 512
+      img.height.should == 382
+
+      new_img_blob = img.to_blob
+      new_img_blob.length.should < img_data.length
+      new_img_blob.length.should == 32671
+    end
+
+  end
+
+end

data/spec/imgry/processor_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Imgry::Processor do
+
+  let (:img_data) { IO.read(SPEC_ROOT.join('support/335is.jpg')) }
+
+  context "a pretty picture" do    
+
+    it "should do stuff..." do
+      # This will use the best processor for the VM .. etc.
+      # .. what about the format...?
+      img = Imgry.with_bytes(img_data)
+
+      # img.class # .. this will be ImageTools::Processor::MiniMagick or ::ImgScalr etc.
+
+      # img.resize!("300x200!")
+
+      # img = ImageTools.from_file(SPEC_ROOT.join('support/335is.jpg'))
+
+      binding.pry
+      x = 1
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+begin
+  require 'bundler'
+  Bundler.setup(:default, :development)
+rescue LoadError => e
+  # Fall back on doing an unlocked resolve at runtime.
+  $stderr.puts e.message
+  $stderr.puts "Try running `bundle install`"
+  exit!
+end
+
+require 'pathname'
+
+$:.unshift(File.dirname(__FILE__))
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+IMGRY_ROOT = Pathname.new(File.expand_path('../../', __FILE__))
+SPEC_ROOT = IMGRY_ROOT.join('spec')
+
+begin
+  require 'pry'
+  require 'pry-nav'
+rescue LoadError
+end
+
+require 'imgry'
+require 'rspec'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+# Dir["#{SPEC_ROOT}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.mock_with :rspec  
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: imgry
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Pressly
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+description: Fast image resizing/cropping designed for JRuby with MRI support
+email:
+- info@pressly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/imgry/geometry.rb
+- lib/imgry/processor/image_voodoo.rb
+- lib/imgry/processor/img_scalr.rb
+- lib/imgry/processor/mini_magick.rb
+- lib/imgry/processor.rb
+- lib/imgry/version.rb
+- lib/imgry.rb
+- lib/java/imgscalr-lib-4.2.jar
+- README.md
+- spec/imgry/geometry_spec.rb
+- spec/imgry/processor/image_voodoo_spec.rb
+- spec/imgry/processor/img_scalr_spec.rb
+- spec/imgry/processor/mini_magick_spec.rb
+- spec/imgry/processor_spec.rb
+- spec/spec_helper.rb
+- spec/support/335is.gif
+- spec/support/335is.jpg
+- spec/support/335is.png
+homepage: http://github.com/nulayer/imgry
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Fast image resizing/cropping designed for JRuby with MRI support
+test_files:
+- spec/imgry/geometry_spec.rb
+- spec/imgry/processor/image_voodoo_spec.rb
+- spec/imgry/processor/img_scalr_spec.rb
+- spec/imgry/processor/mini_magick_spec.rb
+- spec/imgry/processor_spec.rb
+- spec/spec_helper.rb
+- spec/support/335is.gif
+- spec/support/335is.jpg
+- spec/support/335is.png
+has_rdoc: