image_resizer 0.1.4

data/lib/image_resizer/processor.rb

@@ -0,0 +1,220 @@
+module ImageResizer
+  class Processor
+
+    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'
+    THUMB_GEOMETRY = Regexp.union RESIZE_GEOMETRY, CROPPED_RESIZE_GEOMETRY, CROP_GEOMETRY
+
+    include Configurable
+    include Utils
+
+
+    def resize(temp_object, options={})
+      width = options[:width].to_i
+      height = options[:height].to_i
+
+      if height == 0 && width == 0
+        temp_object.file
+      elsif height == 0
+        _resize(temp_object, "#{width}x")
+      elsif width == 0
+        _resize(temp_object, "x#{height}")
+      else
+        if options[:crop_from_top_if_portrait]
+          analyzer = ImageResizer::Analyzer.new
+          center_of_gravity = analyzer.aspect_ratio(temp_object) >= 1 ? 'c' : 'n'
+        else
+          center_of_gravity = 'c'
+        end
+
+        resize_and_crop(temp_object, :width => width.to_i, :height => height.to_i, :gravity => center_of_gravity)
+      end
+    end
+
+    def _resize(temp_object, geometry)
+      convert(temp_object, "-resize #{geometry}")
+    end
+
+    def auto_orient(temp_object)
+      convert(temp_object, "-auto-orient")
+    end
+
+    def crop(temp_object, opts={})
+      width   = opts[:width]
+      height  = opts[:height]
+      gravity = GRAVITIES[opts[:gravity]]
+      x       = "#{opts[:x] || 0}"
+      x = '+' + x unless x[/^[+-]/]
+      y       = "#{opts[:y] || 0}"
+      y = '+' + y unless y[/^[+-]/]
+      repage  = opts[:repage] == false ? '' : '+repage'
+
+      resize = opts[:resize] ? "-resize #{opts[:resize]} " : ''
+      gravity = gravity ? "-gravity #{gravity} " : ''
+
+      convert(temp_object, "#{resize}#{gravity}-crop #{width}x#{height}#{x}#{y} #{repage}")
+    end
+
+    def resize_and_crop_around_point(temp_object, options)
+      analyzer = ImageResizer::Analyzer.new
+
+      desired_width = options[:width].to_i
+      desired_height = options[:height].to_i
+      desired_ratio = desired_height > 0 ? desired_width.to_f / desired_height : 0
+
+      original_width = analyzer.width(temp_object)
+      original_height = analyzer.height(temp_object)
+      original_ratio = original_width.to_f / original_height
+
+      if desired_ratio > original_ratio
+        width = original_width
+        height = width / desired_ratio
+      else
+        height = original_height
+        width = height * desired_ratio
+      end
+
+      focus_x = options[:point][0] * original_width
+      focus_y = options[:point][1] * original_height
+
+      half_width = width * 0.5
+      half_height = height * 0.5
+
+      upper_left_x = [focus_x - half_width, 0].max
+      upper_left_y = [focus_y - half_height, 0].max
+
+      lower_right_x = upper_left_x + width
+      lower_right_y = upper_left_y + height
+
+      x_offset = [lower_right_x - original_width, 0].max
+      y_offset = [lower_right_y - original_height, 0].max
+
+      upper_left_x -= x_offset
+      upper_left_y -= y_offset
+
+      lower_right_x -= x_offset
+      lower_right_y -= y_offset
+
+      upper_left_x_percent = upper_left_x / original_width
+      upper_left_y_percent = upper_left_y / original_height
+
+      lower_right_x_percent = lower_right_x / original_width
+      lower_right_y_percent = lower_right_y / original_height
+
+      crop_to_frame_and_resize(temp_object,
+                              :upper_left => [upper_left_x_percent, upper_left_y_percent],
+                              :lower_right => [lower_right_x_percent, lower_right_y_percent],
+                              :width => desired_width,
+                              :height => desired_height
+                              )
+    end
+
+
+    def crop_to_frame_and_resize(temp_object, options)
+      analyzer = ImageResizer::Analyzer.new
+
+      desired_width = options[:width].to_i
+      desired_height = options[:height].to_i
+
+      upper_left_x_percent = options[:upper_left].first
+      upper_left_y_percent = options[:upper_left].last
+
+      lower_right_x_percent = options[:lower_right].first
+      lower_right_y_percent = options[:lower_right].last
+
+      original_width = analyzer.width(temp_object)
+      original_height = analyzer.height(temp_object)
+
+      upper_left_x = (original_width * upper_left_x_percent).round
+      upper_left_y = (original_height * upper_left_y_percent).round
+      frame_width = (original_width * (lower_right_x_percent - upper_left_x_percent)).round
+      frame_height = (original_height * (lower_right_y_percent - upper_left_y_percent)).round
+
+      if desired_width == 0 && frame_height > 0
+        ratio = frame_width.to_f / frame_height
+        desired_width = (desired_height * ratio).round
+      end
+
+      if desired_height == 0 && frame_width > 0
+        ratio = frame_height.to_f / frame_width
+        desired_height = (desired_width * ratio).round
+      end
+
+
+      convert(temp_object, "-crop #{frame_width}x#{frame_height}+#{upper_left_x}+#{upper_left_y} -resize #{desired_width}x#{desired_height} +repage")
+    end
+
+    def flip(temp_object)
+      convert(temp_object, "-flip")
+    end
+
+    def flop(temp_object)
+      convert(temp_object, "-flop")
+    end
+
+    def greyscale(temp_object)
+      convert(temp_object, "-colorspace Gray")
+    end
+    alias grayscale greyscale
+
+    def resize_and_crop(temp_object, opts={})
+      if !opts[:width] && !opts[:height]
+        return temp_object
+      elsif !opts[:width] || !opts[:height]
+        attrs          = identify(temp_object)
+        opts[:width]   ||= attrs[:width]
+        opts[:height]  ||= attrs[:height]
+      end
+
+      opts[:gravity] ||= 'c'
+
+      opts[:resize]  = "#{opts[:width]}x#{opts[:height]}^^"
+      crop(temp_object, opts)
+    end
+
+    def rotate(temp_object, amount, opts={})
+      convert(temp_object, "-rotate #{amount}#{opts[:qualifier]}")
+    end
+
+    def strip(temp_object)
+      convert(temp_object, "-strip")
+    end
+
+    def thumb(temp_object, geometry)
+      case geometry
+      when RESIZE_GEOMETRY
+        resize(temp_object, geometry)
+      when CROPPED_RESIZE_GEOMETRY
+        resize_and_crop(temp_object, :width => $1, :height => $2, :gravity => $3)
+      when CROP_GEOMETRY
+        crop(temp_object,
+          :width => $1,
+          :height => $2,
+          :x => $3,
+          :y => $4,
+          :gravity => $5
+        )
+      else raise ArgumentError, "Didn't recognise the geometry string #{geometry}"
+      end
+    end
+
+    def convert(temp_object, args='', format=nil)
+      format ? [super, {:format => format.to_sym}] : super
+    end
+
+  end
+end

data/lib/image_resizer/shell.rb

@@ -0,0 +1,48 @@
+require 'shellwords'
+
+module ImageResizer
+  module Shell
+
+    include Configurable
+    configurable_attr :log_commands, false
+
+    # Exceptions
+    class CommandFailed < RuntimeError; end
+
+    def run(command, args="")
+      full_command = "#{command} #{escape_args(args)}"
+      log.debug("Running command: #{full_command}") if log_commands
+      begin
+        result = `#{full_command}`
+      rescue Errno::ENOENT
+        raise_shell_command_failed(full_command)
+      end
+      if $?.exitstatus == 1
+        throw :unable_to_handle
+      elsif !$?.success?
+        raise_shell_command_failed(full_command)
+      end
+      result
+    end
+
+    def raise_shell_command_failed(command)
+      raise CommandFailed, "Command failed (#{command}) with exit status #{$?.exitstatus}"
+    end
+
+    def escape_args(args)
+      args.shellsplit.map do |arg|
+        quote arg.gsub(/\\?'/, %q('\\\\''))
+      end.join(' ')
+    end
+
+    def quote(string)
+      q = running_on_windows? ? '"' : "'"
+      q + string + q
+    end
+
+    def running_on_windows?
+      ENV['OS'] && ENV['OS'].downcase == 'windows_nt'
+    end
+
+  end
+end

data/lib/image_resizer/temp_object.rb

@@ -0,0 +1,216 @@
+require 'stringio'
+require 'tempfile'
+require 'pathname'
+
+module ImageResizer
+
+  # A TempObject is used for HOLDING DATA.
+  # It's the thing that is passed between the datastore, the processor and the encoder, and is useful
+  # for separating how the data was created and how it is later accessed.
+  #
+  # You can initialize it various ways:
+  #
+  #   temp_object = ImageResizer::TempObject.new('this is the content')           # with a String
+  #   temp_object = ImageResizer::TempObject.new(Pathname.new('path/to/content')) # with a Pathname
+  #   temp_object = ImageResizer::TempObject.new(File.new('path/to/content'))     # with a File
+  #   temp_object = ImageResizer::TempObject.new(some_tempfile)                   # with a Tempfile
+  #   temp_object = ImageResizer::TempObject.new(some_other_temp_object)          # with another TempObject
+  #
+  # However, no matter how it was initialized, you can always access the data a number of ways:
+  #
+  #   temp_object.data      # returns a data string
+  #   temp_object.file      # returns a file object holding the data
+  #   temp_object.path      # returns a path for the file
+  #
+  # The data/file are created lazily, something which you may wish to take advantage of.
+  #
+  # For example, if a TempObject is initialized with a file, and temp_object.data is never called, then
+  # the data string will never be loaded into memory.
+  #
+  # Conversely, if the TempObject is initialized with a data string, and neither temp_object.file nor temp_object.path
+  # are ever called, then the filesystem will never be hit.
+  #
+  class TempObject
+
+    include HasFilename
+
+    # Exceptions
+    class Closed < RuntimeError; end
+
+    # Instance Methods
+
+    def initialize(obj, meta={})
+      if obj.is_a? TempObject
+        @data = obj.get_data
+        @tempfile = obj.get_tempfile
+        @pathname = obj.get_pathname
+      elsif obj.is_a? String
+        @data = obj
+      elsif obj.is_a? Tempfile
+        @tempfile = obj
+      elsif obj.is_a? File
+        @pathname = Pathname.new(obj.path)
+      elsif obj.is_a? Pathname
+        @pathname = obj
+      elsif obj.respond_to?(:tempfile)
+        @tempfile = obj.tempfile
+      elsif obj.respond_to?(:path) # e.g. Rack::Test::UploadedFile
+        @pathname = Pathname.new(obj.path)
+      else
+        raise ArgumentError, "#{self.class.name} must be initialized with a String, a Pathname, a File, a Tempfile, another TempObject, something that responds to .tempfile, or something that responds to .path"
+      end
+
+      @tempfile.close if @tempfile
+
+      # Original filename
+      @original_filename = if obj.respond_to?(:original_filename)
+        obj.original_filename
+      elsif @pathname
+        @pathname.basename.to_s
+      end
+
+      # Meta
+      @meta = meta
+      @meta[:name] ||= @original_filename if @original_filename
+    end
+
+    attr_reader :original_filename
+    attr_accessor :meta
+
+    def name
+      meta[:name]
+    end
+
+    def name=(name)
+      meta[:name] = name
+    end
+
+    def data
+      raise Closed, "can't read data as TempObject has been closed" if closed?
+      @data ||= file{|f| f.read }
+    end
+
+    def tempfile
+      raise Closed, "can't read from tempfile as TempObject has been closed" if closed?
+      @tempfile ||= begin
+        case
+        when @data
+          @tempfile = new_tempfile(@data)
+        when @pathname
+          @tempfile = copy_to_tempfile(@pathname.expand_path)
+        end
+        @tempfile
+      end
+    end
+
+    def file(&block)
+      f = tempfile.open
+      tempfile.binmode
+      if block_given?
+        ret = yield f
+        tempfile.close unless tempfile.closed?
+      else
+        ret = f
+      end
+      ret
+    end
+
+    def path
+      @pathname ? @pathname.expand_path.to_s : tempfile.path
+    end
+
+    def size
+      @data ? @data.bytesize : File.size(path)
+    end
+
+    def each(&block)
+      to_io do |io|
+        while part = io.read(block_size)
+          yield part
+        end
+      end
+    end
+
+    def to_file(path, opts={})
+      mode = opts[:mode] || 0644
+      prepare_path(path) unless opts[:mkdirs] == false
+      if @data
+        File.open(path, 'wb', mode){|f| f.write(@data) }
+      else
+        FileUtils.cp(self.path, path)
+        File.chmod(mode, path)
+      end
+      File.new(path, 'rb')
+    end
+
+    def to_io(&block)
+      @data ? StringIO.open(@data, 'rb', &block) : file(&block)
+    end
+
+    def close
+      @tempfile.close! if @tempfile
+      @data = nil
+      @closed = true
+    end
+
+    def closed?
+      !!@closed
+    end
+
+    def inspect
+      content_string = case
+      when @data
+        data_string = size > 20 ? "#{@data[0..20]}..." : @data
+        "data=#{data_string.inspect}"
+      when @pathname then "pathname=#{@pathname.inspect}"
+      when @tempfile then "tempfile=#{@tempfile.inspect}"
+      end
+      "<#{self.class.name} #{content_string} >"
+    end
+
+    def unique_id
+      @unique_id ||= "#{object_id}#{rand(1000000)}"
+    end
+
+    protected
+
+    # We don't use normal accessors here because #data etc. do more than just return the instance var
+    def get_data
+      @data
+    end
+
+    def get_pathname
+      @pathname
+    end
+
+    def get_tempfile
+      @tempfile
+    end
+
+    private
+
+    def block_size
+      8192
+    end
+
+    def copy_to_tempfile(path)
+      tempfile = new_tempfile
+      FileUtils.cp path, tempfile.path
+      tempfile
+    end
+
+    def new_tempfile(content=nil)
+      tempfile = ext ? Tempfile.new(['ImageResizer', ".#{ext}"]) : Tempfile.new('ImageResizer')
+      tempfile.binmode
+      tempfile.write(content) if content
+      tempfile.close
+      tempfile
+    end
+
+    def prepare_path(path)
+      dir = File.dirname(path)
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+    end
+
+  end
+end

data/lib/image_resizer/utils.rb

@@ -0,0 +1,44 @@
+require 'tempfile'
+
+module ImageResizer
+  module Utils
+
+    include Shell
+    include Loggable
+    include Configurable
+    configurable_attr :convert_command, "convert"
+    configurable_attr :identify_command, "identify"
+
+    private
+
+    def convert(temp_object=nil, args='', format=nil)
+      tempfile = new_tempfile(format)
+      run convert_command, %(#{quote(temp_object.path) if temp_object} #{args} #{quote(tempfile.path)})
+      tempfile
+    end
+
+    def identify(temp_object)
+      # example of details string:
+      # myimage.png PNG 200x100 200x100+0+0 8-bit DirectClass 31.2kb
+      format, width, height, depth = raw_identify(temp_object).scan(/([A-Z0-9]+) (\d+)x(\d+) .+ (\d+)-bit/)[0]
+      {
+        :format => format.downcase.to_sym,
+        :width => width.to_i,
+        :height => height.to_i,
+        :depth => depth.to_i
+      }
+    end
+
+    def raw_identify(temp_object, args='')
+      run identify_command, "#{args} #{quote(temp_object.path)}"
+    end
+
+    def new_tempfile(ext=nil)
+      tempfile = ext ? Tempfile.new(['ImageResizer', ".#{ext}"]) : Tempfile.new('ImageResizer')
+      tempfile.binmode
+      tempfile.close
+      tempfile
+    end
+
+  end
+end

data/lib/image_resizer.rb

@@ -0,0 +1,10 @@
+
+require 'image_resizer/has_filename'
+require 'image_resizer/loggable'
+require 'image_resizer/configurable'
+require 'image_resizer/shell'
+require 'image_resizer/utils'
+require 'image_resizer/analyzer'
+require 'image_resizer/encoder'
+require 'image_resizer/processor'
+require 'image_resizer/temp_object'

data/spec/image_resizer/analyzer_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe ImageResizer::Analyzer do
+
+  before(:each) do
+    @image = ImageResizer::TempObject.new(SAMPLES_DIR.join('beach.png'))
+    @analyzer = ImageResizer::Analyzer.new
+  end
+
+  it "should return the width" do
+    @analyzer.width(@image).should == 280
+  end
+
+  it "should return the height" do
+    @analyzer.height(@image).should == 355
+  end
+
+  it "should return the aspect ratio" do
+    @analyzer.aspect_ratio(@image).should == (280.0/355.0)
+  end
+
+  it "should say if it's portrait" do
+    @analyzer.portrait?(@image).should be_true
+  end
+
+  it "should say if it's landscape" do
+    @analyzer.landscape?(@image).should be_false
+  end
+
+  it "should return the number of colours" do
+    @analyzer.number_of_colours(@image).should == 34703
+  end
+
+  it "should return the depth" do
+    @analyzer.depth(@image).should == 8
+  end
+
+  it "should return the format" do
+    @analyzer.format(@image).should == :png
+  end
+
+  %w(width height aspect_ratio number_of_colours depth format portrait? landscape?).each do |meth|
+    it "should throw unable_to_handle in #{meth.inspect} if it's not an image file" do
+      suppressing_stderr do
+        temp_object = ImageResizer::TempObject.new('blah')
+        lambda{
+          @analyzer.send(meth, temp_object)
+        }.should throw_symbol(:unable_to_handle)
+      end
+    end
+  end
+
+  it "should say if it's an image" do
+    @analyzer.image?(@image).should == true
+  end
+
+  it "should say if it's not an image" do
+    suppressing_stderr do
+      @analyzer.image?(ImageResizer::TempObject.new('blah')).should == false
+    end
+  end
+
+  it "should work for images with spaces in the filename" do
+    image = ImageResizer::TempObject.new(SAMPLES_DIR.join('white pixel.png'))
+    @analyzer.width(image).should == 1
+  end
+
+  it "should work (width) for images with capital letter extensions" do
+    image = ImageResizer::TempObject.new(SAMPLES_DIR.join('DSC02119.JPG'))
+    @analyzer.width(image).should == 1
+  end
+
+  it "should work (width) for images with numbers in the format" do
+    image = ImageResizer::TempObject.new(SAMPLES_DIR.join('a.jp2'))
+    @analyzer.width(image).should == 1
+  end
+
+end