dimension 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d1be13d491cf7820b7fdd352dac29074884ee584
+  data.tar.gz: 1cf3a7360986cebb5d83089ad33b7fe85aa171b7
+SHA512:
+  metadata.gz: 1541bb58760ef65bb60df5342b7fe1f85ae9a5fc4b36d4ec896be9d204749eb38cd631e40748c61af7f341865fe2c5068b49cb6453307092f7e31f7d97f025a6
+  data.tar.gz: 7d992bb47aeaeb109d92cd3d0944912012bf4f29fb278c7375122bc5b37cbc8076246e0672f891dd9383696196f1f1d31c8d4f008c1718ae8059f6a9579111df

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+pkg

data/README.md

@@ -0,0 +1,50 @@
+Resizer
+=======
+
+Fast, simplified image resizing for Ruby. No ImageMagick.
+
+``` rb
+  require 'resizer'
+   
+  thumb = Resizer.open('tux.png')
+  thumb.generate('100x100') # => { :width => 100, :height => 100 }
+  thumb.save('resized.png')
+```
+
+Or generate and write file automatically.
+
+``` rb
+  thumb = Resizer.new('tux.png')
+  thumb.generate!('100x300!') # will write file as 'tux-100x300.png'
+```
+
+# In memory processing
+
+Yes sir, we have it.
+
+``` rb
+  thumb = Resizer.open(params[:file])
+  thumb.generate('200x300#')
+  thumb.image_data
+```
+
+You can also pass a block, which will ensure the original image is closed after processing.
+
+``` rb
+  get '/resize/:file' do
+    thumb = Resizer.open(params[:file])
+    thumb.generate('200x300#') do |res|
+      @out = thumb.to_response
+    end
+    @out.to_response
+  end
+```
+
+# Resizing geometries
+
+This is taken directly from the excellent Dragonfly gem. 
+
+Copyright
+=========
+
+(c) Fork, Ltd. MIT Licensed.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/benchmark.rb

@@ -0,0 +1,28 @@
+require './lib/resizer'
+require 'benchmark'
+
+file = ARGV[0] or abort('File needed')
+geometry = ARGV[1] or abort('Geometry required: 100x100#ne')
+
+out = "#{File.basename(file)}.out#{File.extname(file)}"
+puts "Processing #{file}"
+
+Benchmark.bm do |x|
+
+  x.report do
+    Resizer.processor = 'imlib2'
+    a = Resizer.open(file)
+    res = a.generate!(geometry)
+    puts res.inspect
+  end
+
+  sleep 1
+
+  x.report do
+    Resizer.processor = 'image_magick'
+    b = Resizer.open(file)
+    res = b.generate!(geometry)
+    puts res.inspect
+  end
+
+end

data/bin/dimension

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require './lib/dimension'
+require 'benchmark'
+
+file     = ARGV[0] or abort('File needed. Try with examples/assets/chair.jpg')
+geometry = ARGV[1] or abort('Geometry required. Example: 100x100')
+
+thumb = Dimension.open(file)
+res = thumb.generate!(geometry)
+# puts res.inspect

data/dimension.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/dimension/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "dimension"
+  s.version     = Dimension::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Tomás Pollak']
+  s.email       = ['tomas@forkhq.com']
+  s.homepage    = "https://github.com/tomas/dimension"
+  s.summary     = "Native, in-process image resizing in Ruby."
+  s.description = "Yes, there are other graphic libraries besides ImageMagick."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "dimension"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+  # s.bindir       = 'bin'
+end

data/examples/sinatra.rb

@@ -0,0 +1,32 @@
+ROOT = File.expand_path(File.dirname(__FILE__))
+
+require 'sinatra'
+require ROOT + '/../lib/resizer'
+
+get '/' do
+  images = Dir.glob(File.join(ROOT, 'assets') + '/*')
+  links = images.map do |i|
+    name = File.basename(i)
+    "<a href='/images/#{name}'>#{name}</a>"
+  end
+  '<ul><li>' + links.join('</li><li>') + '</li></ul>'
+end
+
+get '/images/:file' do
+  file = File.join(ROOT, 'assets', params[:file])
+
+  if params[:geometry].nil?
+    puts "Returning original file: #{file}"
+    return send_file file
+  end
+
+  begin
+    thumb = Resizer.open(file)
+  rescue => e
+    return e.message
+  end
+
+  thumb.generate(params[:geometry]) do
+    thumb.to_response
+  end
+end

data/lib/dimension/image.rb

@@ -0,0 +1,106 @@
+require 'fileutils'
+
+module Dimension
+
+class Image
+
+  GRAVITIES = {
+    'nw' => 'NorthWest',
+    'n'  => 'North',
+    'ne' => 'NorthEast',
+    'w'  => 'West',
+    'c'  => 'Center',
+    'e'  => 'East',
+    'sw' => 'SouthWest',
+    's'  => 'South',
+    'se' => 'SouthEast'
+  }
+
+  # Geometry string patterns
+  RESIZE_GEOMETRY         = /^(\d+)?x(\d+)?[><%^!]?$|^\d+@$/ # e.g. '300x200!'
+  CROPPED_RESIZE_GEOMETRY = /^(\d+)x(\d+)#(\w{1,2})?$/ # e.g. '20x50#ne'
+  CROP_GEOMETRY           = /^(\d+)x(\d+)([+-]\d+)?([+-]\d+)?(\w{1,2})?$/ # e.g. '30x30+10+10'
+
+  attr_reader :file
+
+  def initialize(file)
+    unless Dimension.processor
+      raise "No processor set! Please set Dimension.processor = 'imlib2' or 'image_magick'"
+    end
+
+    @file = File.expand_path(file)
+    raise ArgumentError, "File not found: #{@file}" unless File.exist?(@file)
+    log "File loaded: #{file}. Geometry: #{geometry.join('x')}"
+  end
+
+  def generate(geometry, &block)
+    new_geometry = resize_to(geometry)
+    if block_given?
+      out = yield(new_geometry)
+      close
+    end
+    out || self
+  end
+
+  def generate!(geometry, output_file = nil)
+    resize_to(geometry)
+    save(output_file) && self
+  end
+
+  def resize_to(geometry)
+    case geometry
+      when RESIZE_GEOMETRY
+        log "Resize -- #{$1}x#{$2}"
+        resize($1, $2)
+      when CROPPED_RESIZE_GEOMETRY
+        log "Resize and crop -- width: #{$1}, height: #{$2}, gravity: #{$3}"
+        resize_and_crop($1, $2, $3)
+      when CROP_GEOMETRY
+        log "Crop -- width: #{$1}, height: #{$2}, x: #{$3}, y: #{$4}, gravity: #{$5}"
+        crop($1, $2, $3, $4, $5)
+      else
+        raise ArgumentError, "Didn't recognise the geometry string #{geometry}"
+    end
+    
+    new_geometry = get_new_geometry
+    {:width => new_geometry[0], :height => new_geometry[1]}
+  end
+
+  def save(out_file)
+    new_geometry = get_new_geometry
+
+    if out_file.nil?
+      out_file = file.sub(File.extname(file), '-' + new_geometry.join('x') + File.extname(file))
+    end
+
+    log "Writing file: #{out_file}"
+    save_as(out_file) or return false
+    close
+
+    {:file => out_file, :width => new_geometry[0], :height => new_geometry[1]}
+  end
+
+  def to_s
+    image_data
+  end
+  
+  def to_a
+    to_response
+  end
+  
+  def inspect
+    geometry = get_new_geometry
+    "#<Dimension::Image:#{object_id} @width=#{geometry[0]}, @height=#{geometry[1]}>"
+  end
+
+  def to_response(env = nil)
+    [200, {'Content-Type' => "image/#{format}"}, image_data]
+  end
+
+  def log(msg)
+    puts "[Dimension::#{Dimension.processor}] #{msg}"
+  end
+
+end
+
+end

data/lib/dimension/processors/image_magick.rb

@@ -0,0 +1,75 @@
+module ImageMagickProcessor
+
+  def geometry
+    [image_details[:width], image_details[:height]]
+  end
+
+  def format
+    image_details[:format]
+  end
+
+  def image_data
+    IO.read(@temp_file)
+  end
+
+  def save_as(new_file_path)
+    return if new_file_path == @temp_file
+    FileUtils.mv(@temp_file, new_file_path)
+  end
+
+  def get_new_geometry
+    self.class.new(@temp_file).geometry
+  end
+
+  def save!
+    FileUtils.mv(@temp_file, file)
+  end
+
+  def close
+    log "Removing temp file: #{@temp_file}"
+    FileUtils.rm_f(@temp_file)
+  end
+
+  private
+
+  def resize(w, h)
+    convert "-resize #{w}x#{h}"
+  end
+
+  def resize_and_crop(w, h, gravity)
+    gravity = self.class::GRAVITIES[gravity || 'c']
+    convert "-resize #{w}x#{h}^^ -gravity #{gravity} -crop #{w}x#{h}+0+0 +repage"
+  end
+
+  def crop(width, height, x = 0, y = 0, gravity)
+    raise ArgumentError, "you can't give a crop offset and gravity at the same time" if x != 0 and gravity
+
+    x = '+' + x unless x[/^[+-]/]
+    y = '+' + y unless y[/^[+-]/]
+    args = "-crop #{w}x#{h}#{x}#{y} +repage"
+
+    if gravity and g = self.class::GRAVITIES[gravity]
+      args = "-gravity #{gravity} #{args}"
+    end
+
+    convert args
+  end
+
+  def convert(args)
+    @temp_file = "/tmp/#{$$}.#{File.basename(file)}"
+    out = `convert "#{file}" #{args} "#{@temp_file}"`
+  end
+
+  def image_details
+    @image_details ||= identify(file)
+  end
+
+  def identify(path)
+    out = `identify -ping -format '%m %w %h' "#{path}"`
+    format, width, height = out.split
+    { :format => format.downcase,
+      :width  => width.to_i,
+      :height => height.to_i }
+  end
+
+end

data/lib/dimension/processors/imlib2.rb

@@ -0,0 +1,141 @@
+require 'imlib2'
+
+module Imlib2Processor
+
+  def image
+    @image ||= Imlib2::Image.load(@file)
+  end
+
+  def geometry
+    [image.w, image.h]
+  end
+
+  def format
+    image.format # .gsub('jpeg', 'jpg')
+  rescue ArgumentError
+    File.extname(file).sub('.', '')
+  end
+
+  def to_rgba
+    bytes = data.bytes
+    (1..bytes.length).step(4).map { |i| bytes[i..i+2] << bytes[i-1] }.flatten
+  end
+
+  # transforms data (RGBA buffer) into a array of RGB values
+  def to_rgb
+    bytes = data.bytes
+    (1..bytes.length).step(4).map { |i| [bytes[i-1],bytes[i],bytes[i+1]] }.flatten
+  end
+
+  def image_data
+    unless @temp_file
+      @temp_file = "/tmp/#{$$}.#{File.basename(file)}"
+      save_as(@temp_file)
+    end
+    IO.read(@temp_file)
+  end
+
+  def save_as(new_file_path)
+    image.save(new_file_path)
+  end
+
+  def save!
+    image.save(file)
+  end
+
+  def close
+    log "Closing image."
+    FileUtils.rm(@temp_file) if @temp_file
+    image.delete!(true) # free image, and de-cache it too
+  end
+
+  def get_new_geometry
+    geometry
+  end
+
+#  http://pablotron.org/software/imlib2-ruby/doc/
+#
+#  iw, ih = old_image.width, old_image.height
+#  new_w, new_h = iw - 20, ih - 20
+#  values = [10, 10, iw - 10, iw - 10, new_w, new_h]
+#  new_image = old_image.crop_scaled values
+
+  def resize(w, h)
+    new_w, new_h = get_resize_geometry(w, h, false)
+    crop_scaled(0, 0, new_w, new_h)
+  end
+
+#  def resize_and_fill(w, h)
+#    new_w, new_h = get_resize_geometry(w, h, false)
+#    x = (w.to_i - new_w)
+#    y = (h.to_i - new_h)
+#    image.crop_scaled!(x*-1, y*-1, image.w + x*2, image.h + y*2, w.to_i, h.to_i)
+#  end
+
+  def resize_and_crop(w, h, gravity)
+    new_w, new_h = get_resize_geometry(w, h, true)
+    crop_scaled(0, 0, new_w, new_h)
+    # crop_scaled(0, 0, w, h)
+
+    offset = get_offset(w, h, gravity)
+    # original_height = image.h
+    # original_width  = image.w
+
+    image.crop!(offset[0], offset[1], w.to_i, h.to_i)
+    # crop_scaled(offset[0], offset[1], new_w, new_h)
+  end
+
+  def crop(width, height, x, y, gravity)
+    rect = [x || 0, y || 0, width.to_i, height.to_i]
+    image.crop!(rect)
+  end
+
+  def crop_scaled(x, y, new_w, new_h)
+    log "Resizing #{image.w}x#{image.h} to #{new_w}x#{new_h}. Offset at #{x},#{y}"
+    image.crop_scaled!(x, y, image.w, image.h, new_w.to_i, new_h.to_i)
+  end
+
+  def get_offset(w, h, gravity = 'c')
+    if gravity.nil? or gravity == '' or gravity == 'c'
+      return get_center_offset(w, h)
+    else
+      raise 'Not implemented'
+    end
+  end
+
+  def get_center_offset(w, h)
+    w_diff = image.w - w.to_i
+    h_diff = image.h - h.to_i
+    log "Width diff: #{w_diff}"
+    log "Height diff: #{h_diff}"
+
+    if w_diff == h_diff
+      return [0, 0]
+    elsif w_diff > h_diff
+      return [w_diff.to_f/2, 0]
+    else
+      return [0, h_diff.to_f/2]
+    end
+  end
+
+  def get_resize_geometry(w, h, to_longer = true)
+    if to_longer
+      if image.w < image.h
+        new_h = ((w.to_f / image.w) * image.h).round
+        return w.to_i, new_h
+      else
+        new_w = ((h.to_f / image.h) * image.w).round
+        return new_w, h.to_i
+      end
+    else
+      if w && image.w >= image.h
+        new_h = ((w.to_f / image.w) * image.h).round
+        return w.to_i, new_h
+      else
+        new_w = ((h.to_f / image.h) * image.w).round
+        return new_w, h.to_i
+      end
+    end
+  end
+
+end

data/lib/dimension/version.rb

@@ -0,0 +1,7 @@
+module Dimension
+  MAJOR = 0
+  MINOR = 0
+  PATCH = 1
+
+  VERSION = [MAJOR, MINOR, PATCH].join('.')
+end

data/lib/dimension.rb

@@ -0,0 +1,39 @@
+# require File.expand_path(File.dirname(__FILE__)) + '/image'
+require 'dimension/image'
+
+module Dimension
+
+  ROOT = File.expand_path(File.dirname(__FILE__))
+
+  PROCESSORS = {
+    'imlib2' => 'Imlib2Processor',
+    'image_magick' => 'ImageMagickProcessor'
+  }
+
+  def self.processor
+    @processor
+  end
+
+  def self.processor=(name)
+    @processor = PROCESSORS[name] or raise "Processor not found: #{name}"
+    # require File.join(ROOT, 'dimension', 'processors', name)
+    require_relative "dimension/processors/#{name}"
+    Image.include(Kernel.const_get(@processor))
+  end
+  
+  def self.open(file)
+    Image.new(file)
+  end
+  
+end
+
+begin
+  require 'imlib2'
+  Dimension.processor = 'imlib2'
+rescue LoadError
+  if system("convert -h")
+    Dimension.processor = 'image_magick'
+  else
+    puts "No available processors found. Please install ruby-imlib2 or ImageMagick."
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: dimension
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tomás Pollak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-04 00:00:00.000000000 Z
+dependencies: []
+description: Yes, there are other graphic libraries besides ImageMagick.
+email:
+- tomas@forkhq.com
+executables:
+- dimension
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- README.md
+- Rakefile
+- benchmark.rb
+- bin/dimension
+- dimension.gemspec
+- examples/assets/black.gif
+- examples/assets/chair.jpg
+- examples/assets/the-two-towers.png
+- examples/assets/window.jpg
+- examples/sinatra.rb
+- lib/dimension.rb
+- lib/dimension/image.rb
+- lib/dimension/processors/image_magick.rb
+- lib/dimension/processors/imlib2.rb
+- lib/dimension/version.rb
+homepage: https://github.com/tomas/dimension
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: dimension
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Native, in-process image resizing in Ruby.
+test_files: []