image_voodoo 0.8.7 → 0.9.1

data/lib/image_voodoo/needs_head.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+class ImageVoodoo; NEEDS_HEAD = true; end

data/lib/image_voodoo/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ImageVoodoo
-  VERSION = "0.8.7"
+  VERSION = '0.9.1'
 end

data/lib/image_voodoo.rb

@@ -1,5 +1,13 @@
-##
-#
+# frozen_string_literal: true
+
+# Before we load image_voodoo we can specify whether we want it to load full
+# AWT ala http://www.oracle.com/technetwork/articles/javase/headless-136834.html
+# Most users are using image_voodoo as a library for manipulation and do not
+# want a full peer window popping up.
+unless defined? ImageVoodoo::NEEDS_HEAD
+  java.lang.System.set_property 'java.awt.headless', 'true'
+end
+
 # = ImageVoodoo
 # == Description
 #
@@ -24,261 +32,240 @@
 #
 # img = ImageVoodoo.with_image(ARGV[0])
 # negative_img = img.negative
-#
 class ImageVoodoo
-  attr_accessor :quality
+  attr_writer :quality # used by quality(value)
 
   include Java
 
   JFile = java.io.File
 
-  ##
   # FIXME: This has an issue when used in test/unit where the classcastexception
   #   is throwing the stack trace to output.  This does not happen when used
   #   directly.  Not sure....
   # gae and awt define the technology-specific methods and more importantly
   # all the *_impl methods which you will see referenced in this file.
   begin
-     require 'image_voodoo/gae'
+    require 'image_voodoo/gae'
   rescue
-     require 'image_voodoo/awt'
+    require 'image_voodoo/awt'
   end
 
-  def initialize(src, format=nil)
-    @src = src
-    @format = format
+  def initialize(io, src, format=nil)
+    @io, @src, @format = io, src, format
     @quality = nil # nil means no specific quality ever specified
   end
 
-  ##
-  #
+  # Gets RGB value within the source image at [x, y].  If using AWT backend
+  # then consider using color_at as this is a Java signed int value of an
+  # unsigned value.
+  def pixel(x, y)
+    @src.getRGB(x, y)
+  end
+
   # Adjusts the brightness of each pixel in image by the following formula:
   # new_pixel = pixel * scale + offset
-  #
   def adjust_brightness(scale, offset)
     image = guard { adjust_brightness_impl(scale, offset) }
     block_given? ? yield(image) : image
   end
 
-  ##
-  #
   # Converts rgb hex color value to an alpha value an yields/returns the new
   # image.
-  #
   def alpha(rgb)
     target = guard { alpha_impl(rgb) }
     block_given? ? yield(target) : target
   end
 
-  ##
-  #
   # Get current image bytes as a String using provided format. Format parameter
   # is the informal name of an image type - for instance,
   # "bmp" or "jpg". If the backend is AWT the types available are listed in
   # javax.imageio.ImageIO.getWriterFormatNames()
-  #
   def bytes(format)
     java_bytes = guard { bytes_impl(format) }
     String.from_java_bytes java_bytes
   end
 
-  ##
-  #
+  # If current image was taken by a phone it might save the orientation
+  # in format it was physically taken and added IFD0 Orientation information
+  # instead of rotating it.  This method will perform that rotation based
+  # on Orientation metadata.
+  def correct_orientation
+    target = guard { correct_orientation_impl }
+    block_given? ? yield(target) : target
+  end
+
   # Creates a square thumbnail of the image cropping the longest edge to
   # match the shortest edge, resizes to size, and yields/returns the new image.
-  #
   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
-
+    l, t, r, b = calculate_thumbnail_dimensions
     target = with_crop(l, t, r, b).thumbnail(size)
     block_given? ? yield(target) : target
   end
 
-  ##
-  #
+  private def calculate_thumbnail_dimensions
+    half = (width - height).abs / 2
+    if width > height
+      [half, 0, half + height, height]
+    else
+      [0, half, width, half + width]
+    end
+  end
+
   # Flips the image horizontally and yields/returns the new image.
-  #
   def flip_horizontally
     target = guard { flip_horizontally_impl }
     block_given? ? yield(target) : target
   end
 
-  ##
-  #
   # Flips the image vertically and yields/returns the new image.
-  #
   def flip_vertically
     target = guard { flip_vertically_impl }
     block_given? ? yield(target) : target
   end
 
-  ##
-  #
   # Creates a grayscale version of image and yields/returns the new image.
-  #
   def greyscale
     target = guard { greyscale_impl }
     block_given? ? yield(target) : target
   end
-  alias_method :grayscale, :greyscale
+  alias grayscale greyscale
+
+  # Extracts metadata from an image.
+  def metadata
+    guard { metadata_impl }
+  end
 
-  ##
-  #
   # Creates a negative and yields/returns the new image.
-  #
   def negative
     target = guard { negative_impl }
     block_given? ? yield(target) : target
   end
 
-  ##
-  #
   # Set quality you want resulting image to be once you save or extract
   # bytes for the image.  Note: This will only work for lossy image
   # formats like PNG of JPEG.  For others it will be ignored.
   def quality(amount)
     if amount < 0.0 || amount > 1.0
-      raise ArgumentError.new "Quality must be between 0.0 and 1.0"
+      raise ArgumentError, 'Quality must be between 0.0 and 1.0'
     end
 
-    target = self.dup
+    target = dup
     target.quality = amount
     block_given? ? yield(target) : target
   end
 
-  ##
-  #
   # Resizes the image to width and height and yields/returns the new image.
-  #
   def resize(width, height)
     target = guard { resize_impl(width, height) }
     block_given? ? yield(target) : target
-  rescue NativeException => ne
-    raise ArgumentError, ne.message
+  rescue java.lang.Exception => e # figure out why this is here at all?
+    raise ArgumentError, e.message
+  end
+
+  # Rotates the image by angle (specified in degrees).
+  def rotate(angle)
+    target = guard { rotate_impl(to_radians(angle)) }
+    block_given? ? yield(target) : target
   end
 
-  ##
-  #
   # Saves the image out to path. Changing the file extension will convert
   # the file type to the appropriate format.
-  #
   def save(file)
     format = File.extname(file)
-    return false if format == ""
+    return false if format == ''
+
     format = format[1..-1].downcase
     guard { save_impl(format, JFile.new(file)) }
     true
   end
 
-  ##
-  #
   # Resize (scale) the current image by the provided ratio and yield/return
   # the new image.
-  #
   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
 
-  ##
-  #
   # Creates a proportional thumbnail of the image scaled so its longest
   # edge is resized to size and yields/returns the new image.
-  #
   def thumbnail(size)
     target = scale(size.to_f / (width > height ? width : height))
     block_given? ? yield(target) : target
   end
 
-  ##
-  #
   # Crops an image to left, top, right, and bottom and then yields/returns the
   # new image.
-  #
   def with_crop(left, top, right, bottom)
     image = guard { with_crop_impl(left, top, right, bottom) }
     block_given? ? yield(image) : image
   end
 
-  ##
-  #
+  # Creates a new (empty) image with a file name specified.
+  def self.new_image(width, height, file_name)
+    image = guard { new_image_impl(width, height, file_name) }
+    block_given? ? yield(image) : image
+  end
+
   # A top-level image loader opens path and then yields/returns the image.
-  #
   def self.with_image(path)
-    raise ArgumentError, "file does not exist" unless File.file?(path)
+    raise ArgumentError, "file does not exist: #{path}" unless File.file?(path)
+
     image = guard { with_image_impl(JFile.new(path)) }
     image && block_given? ? yield(image) : image
   end
 
-  ##
-  #
   # A top-level image loader reads bytes and then yields/returns the image.
-  #
   def self.with_bytes(bytes)
-    bytes = bytes.to_java_bytes if String === bytes
+    bytes = bytes.to_java_bytes if bytes.is_a? String
     image = guard { with_bytes_impl(bytes) }
     block_given? ? yield(image) : image
   end
 
   class << self
-    alias_method :with_image_from_memory, :with_bytes
+    alias with_image_from_memory with_bytes
   end
 
-  ##
-  #
   # *_impl providers only need provide the implementation if it can
   # support it.  Otherwise, this method will detect that the method is
   # missing.
-  #
   def self.guard(&block)
-    begin
-      return block.call
-    rescue NoMethodError => e
-      "Unimplemented Feature: #{e}"
-    end
+    block.call
+  rescue NoMethodError => e
+    "Unimplemented Feature: #{e}"
   end
+
   def guard(&block)
     ImageVoodoo.guard(&block)
   end
 
-  ##
-  #
   # Returns the height of the image, in pixels.
-  #
   def height
     @src.height
   end
 
-  ##
-  #
   # Returns the width of the image, in pixels.
-  #
   def width
     @src.width
   end
 
-  ##
-  #
   # Returns the underlying Java class associated with this object. Note:
   # Depending on whether you are using AWT or GAE/J you will get a totally
   # different Java class.  So caveat emptor!
-  #
   def to_java
     @src
   end
 
-  ##
-  #
   # Returns detected image format from binary representation of input data
   # as upper case string. Eg. JPEG, BMP, PNG. For GWT image representation
   # compatibility method name is :format. It also accepts block and returns
   # format as first block argument. When format not detected or not set it
   # returns nil
-  #
   def format
     @format && block_given? ? yield(@format) : @format
   end
+
+  def to_radians(degrees)
+    degrees * Math::PI / 180
+  end
 end

data/samples/bench.rb

@@ -1,4 +1,5 @@
 #!/usr/local/bin/ruby -w
+# frozen_string_literal: true
 
 require 'benchmark'
 require 'rbconfig'
@@ -6,59 +7,52 @@ require 'rubygems'
 require 'image_science'
 
 max = (ARGV.shift || 100).to_i
-ext = ARGV.shift || "png"
-
+ext = ARGV.shift || 'png'
 file = "blah_big.#{ext}"
 
-if Config::CONFIG['host_os'] =~ /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}"
+unless File.exist?(file)
+  if RbConfig::CONFIG['host_os'] =~ /darwin/i
+    puts 'taking screenshot for thumbnailing benchmarks'
+    system "screencapture -SC #{file}"
+  elsif RbConfig::CONFIG['host_os'] =~ /linux/i
+    puts 'taking screenshot for thumbnailing benchmarks'
+    system "gnome-screenshot -f #{file}"
+  else
+    abort "You need to save an image to #{file} since we cannot generate one"
+  end
+end
 
-ImageScience.with_image(file.sub(/#{ext}$/, 'png')) do |img|
-  img.save(file)
-end if ext != "png"
+if ext != 'png'
+  ImageScience.with_image(file.sub(/#{ext}$/, 'png')) { |img| img.save(file) }
+end
 
 puts "# of iterations = #{max}"
-Benchmark::bm(20) do |x|
-  x.report("null_time") {
-    for i in 0..max do
-      # do nothing
-    end
-  }
+Benchmark.bm(20) do |x|
+  x.report('null_time') { max.times {} }
 
-  x.report("cropped") {
-    for i in 0..max do
+  x.report('cropped') do
+    max.times do
       ImageScience.with_image(file) do |img|
-        img.cropped_thumbnail(100) do |thumb|
-          thumb.save("blah_cropped.#{ext}")
-        end
+        img.cropped_thumbnail(100) { |thumb| thumb.save("blah_cropped.#{ext}") }
       end
     end
-  }
+  end
 
-  x.report("proportional") {
-    for i in 0..max do
+  x.report('proportional') do
+    max.times do
       ImageScience.with_image(file) do |img|
-        img.thumbnail(100) do |thumb|
-          thumb.save("blah_thumb.#{ext}")
-        end
+        img.thumbnail(100) { |thumb| thumb.save("blah_thumb.#{ext}") }
       end
     end
-  }
+  end
 
-  x.report("resize") {
-    for i in 0..max do
+  x.report('resize') do
+    max.times do
       ImageScience.with_image(file) do |img|
-        img.resize(200, 200) do |resize|
-          resize.save("blah_resize.#{ext}")
-        end
+        img.resize(200, 200) { |resize| resize.save("blah_resize.#{ext}") }
       end
     end
-  }
+  end
 end
 
 # File.unlink(*Dir["blah*#{ext}"])

data/samples/file_greyscale.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'image_voodoo'
 
 # reads in the file specified by ARGV[0], transforming to greyscale and

data/samples/file_thumbnail.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'image_science'
 
 # reads in the file specified by ARGV[0], transforms it into a 32-pixel thumbnail,

data/samples/file_view.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'image_voodoo/needs_head'
 require 'image_voodoo'
 
-ImageVoodoo.with_image(ARGV[0]) { |img| img.preview }
+ImageVoodoo.with_image(ARGV[0], &:preview)

data/samples/{in-memory.rb → in_memory.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'image_voodoo'
 
 # reads in the image at ARGV[0], transforms it into a 32-pixel thumbnail in-memory,

data/samples/lossy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'image_voodoo'
 
 ImageVoodoo.with_image(ARGV[0]) do |img|

data/test/test_image_science.rb

@@ -1,9 +1,19 @@
+# frozen_string_literal: true
+
 require 'test/unit/testcase'
-require 'test/unit' if $0 == __FILE__
+require 'test/unit' if $PROGRAM_NAME == __FILE__
 require 'image_science'
 
 class TestImageScience < Test::Unit::TestCase
-  def deny x; assert ! x; end
+  def deny(x)
+    assert !x
+  end
+
+  def similar_image?(w, h, img)
+    assert_kind_of ImageScience, img
+    assert_equal h, img.height
+    assert_equal w, img.width
+  end
 
   def setup
     @path = 'test/pix.png'
@@ -17,118 +27,68 @@ class TestImageScience < Test::Unit::TestCase
 
   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
+      similar_image? @w, @h, img
       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
+    ImageScience.with_image(@tmppath) { |img| similar_image? @w, @h, img }
   end
 
   def test_class_with_image_missing
     assert_raises ArgumentError do
-      ImageScience.with_image @path + "nope" do |img|
-        flunk
-      end
+      ImageScience.with_image("#{@path}nope") { flunk }
     end
   end
 
   def test_class_with_image_missing_with_img_extension
     assert_raises ArgumentError do
-      ImageScience.with_image("nope#{@path}") do |img|
-        flunk
-      end
+      ImageScience.with_image("nope#{@path}") { flunk }
     end
   end
 
   def test_class_with_image_return_nil_on_bogus_image
-    File.open(@tmppath, "w") {|f| f << "bogus image file"}
-    assert_nil ImageScience.with_image(@tmppath) do |img|
-      flunk
-    end
+    File.open(@tmppath, 'w') { |f| f << 'bogus image file' }
+    assert_nil ImageScience.with_image(@tmppath) { flunk }
   end
 
   def test_resize
     ImageScience.with_image @path do |img|
-      img.resize(25, 25) do |thumb|
-        assert thumb.save(@tmppath)
-      end
+      img.resize(25, 25) { |thumb| assert thumb.save(@tmppath) }
     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
+    ImageScience.with_image(@tmppath) { |img| similar_image? 25, 25, img }
   end
 
   def test_resize_floats
     ImageScience.with_image @path do |img|
-      img.resize(25.2, 25.7) do |thumb|
-        assert thumb.save(@tmppath)
-      end
+      img.resize(25.2, 25.7) { |thumb| assert thumb.save(@tmppath) }
     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
+    ImageScience.with_image(@tmppath) { |img| similar_image? 25, 25, img }
   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)
+    [[0, 25], [25, 0], [0, 0]].each do |w, h|
+      assert_raises ArgumentError do
+        ImageScience.with_image @path do |img|
+          img.resize(w, h) { |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
+      deny File.exist?(@tmppath)
     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)
+    [[-25, 25], [25, -25], [-25, -25]].each do |w, h|
+      assert_raises ArgumentError do
+        ImageScience.with_image @path do |img|
+          img.resize(w, h) { |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
+      deny File.exist?(@tmppath)
     end
-
-    deny File.exists?(@tmppath)
   end
 
   def test_image_format_retrieval
@@ -147,7 +107,7 @@ class TestImageScience < Test::Unit::TestCase
   end
 
   def test_image_format_retrieval_fail_when_invalid_bytes
-    image = ImageScience.with_bytes("some invalid image bytes")
+    image = ImageScience.with_bytes('some invalid image bytes')
     assert_equal nil, image.format
   end
 
@@ -166,6 +126,6 @@ class TestImageScience < Test::Unit::TestCase
       assert new_img.save(@tmppath)
     end
 
-    assert File.exists?(@tmppath)
+    assert File.exist?(@tmppath)
   end
 end