image_voodoo 0.8.8 → 0.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10db8a256e32e37a28b94c9246049f7029484a49
-  data.tar.gz: 27ec82a19aff0bc3171a2c0bff8338c1c7ef19e6
+  metadata.gz: 525eaa36345ce66a917c101be73299b04e2800cb
+  data.tar.gz: e851fe90c983c411388d7b1e37ef0c2e323f677b
 SHA512:
-  metadata.gz: 9bf960b9cd108f06ea22ba69a5f01f7d5ee3ca10dec63fe7a79cf6d2fe986f9a6753ef1969c8eabfa95af8509e0b19211b6ea7c0718d6106c42d998e255e6e36
-  data.tar.gz: 27e8b1a524c25f7a72b3b15c3a9e37e4bf983111410a8be64d78b45c55ce133ed185ec5cf47ab527b565828d106515fdf053ccc41ee0298b1b1b6df75fc923f3
+  metadata.gz: 02453c98b8e64606ecb01834cebd6d04ba96212377308ca3f4a36f2ab91ae79db59dee0ca1b8056d912b3e66eea71da20d120fb81935d98f6d3a1550e3e57b17
+  data.tar.gz: 204639d91890c6525a6bae30fd1db9fd61f999187576e5213ac064bc1b8b29e57d3b7412b4ae691e6c1caa9922bdf0659f5535c49a0ebfed9344af5721bdb4db

data/.rubocop.yml

@@ -0,0 +1,115 @@
+# Experiment to tweak source based on what rubocop wanted me to.  I basically
+# gave up and made the following exceptions.  Personally, I find the tool did
+# find many interesting/questionable code Qs in the project but it is soooo
+# opinionated in pretty unimportant ways (like who cares how I write my
+# comments, or why can't I use kind_of? or why give me a fail for a less
+# readable but more performant pattern).
+#
+# I can obviously tweak rules (like below) but I keep hearing of people pulling
+# their hair out over all the unimportant rules; I question why this project is
+# "all-in" on it's rules versus leaving most of the style rules as some preset
+# profiles people can opt in to.
+#
+# So I am committing this and I will try and run this every now and then to
+# see what it thinks about what I wrote but you will not see this as a
+# requirement for commits since I think by the time I configured it to my
+# liking I could have finished implementing this library.  Perhaps if I
+# continue using this here and there I will end up with a profile I find
+# acceptable?  I did find value but all the piddly shit just made me angry.
+# I will reflect on it some more...
+
+# This is a Java AWT call.  It is not what the tool thinks it is...which
+# might be an issue for users interacting with Java from JRuby.
+Lint/UselessSetterCall:
+  Exclude:
+    - 'lib/image_voodoo/awt.rb'
+
+# This is just impossible for them to call properly.  I am doing something
+# like rotate_impl and it is a bunch of reasonably simple math.  If you look
+# for this transformation in a text book it will look like this code.  Putting
+# a bunch of math within different methods would get the score down but
+# it would not help readability. (addendum: I did try and break it apart more
+# and never reached 15 but got closer.  I felt this rule is neat but the
+# score really depends on what it is.
+Metrics/AbcSize:
+  Max: 16.5
+
+# This is triggered for correct_orientation_impl.  I could put these transforms
+# in a table and then execute lambdas for each orientation but this is much
+# more clear.
+Metrics/CyclomaticComplexity:
+  Max: 9
+
+# A bunch of fields in a hash are basically generated data. Correcting them
+# for column seems much too pedantic.  I guess exclude is the right thing for
+# an unusual file?
+Metrics/LineLength:
+  Max: 132
+  Exclude:
+    - 'lib/image_voodoo/metadata.rb'
+
+# Metadata classes have data in them.  awt.rb is big and perhaps could be
+# shrunk but it is not a hard file to navigate and the cleaving points are
+# not super obvious.  These sorts of rules feel very arbitrary and if I have
+# n highly related things and they do not fit into a more restrictive
+# taxonomy why would the file being longer matter?  I do understand the
+# motivation here but as a default rule this feels wrong to me.
+Metrics/ClassLength:
+  Max: 250
+
+# I do not find this very useful.  There is no performance difference and
+# sometimes I want to highlight this string does not involve interpolation.
+# Other times it is not worth pointing out.
+Style/StringLiterals:
+  Enabled: false
+
+# require 'english' is a step too far for $! which is so baked into my
+# head I do not want to change :)
+Style/SpecialGlobalVars:
+  Enabled: false
+
+# I am grouping math and using lack of whitespace for separation.
+Style/SpaceAroundOperators:
+  Enabled: false
+
+# I prefer tight assignment for opt args.
+Style/SpaceAroundEqualsInParameterDefault:
+  Enabled: false
+
+# Java methods which override or implement Java method names cannot be switched
+# to snake case.  Do we really need this as a rule anyways?  I have never seen
+# a Rubyist do this as a preferred style?
+Style/MethodName:
+  Enabled: false
+
+# bin/image_voodoo main options block.
+Metrics/BlockLength:
+  Exclude:
+    - 'bin/image_voodoo'
+
+# casecmp for this case seems like it is much less readable in a place where
+# performance could never matter (a 3-4 char downcase before processing an
+# image :) ).  This could end up being important somewhere but as a default
+# on it feels weird since I find it less readable.
+Performance/Casecmp:
+  Exclude:
+    - 'lib/image_voodoo/awt.rb'
+
+# Hash rocket looks much more natural in a rakefile for its deps.
+Style/HashSyntax:
+  Exclude:
+    - 'Rakefile'
+
+# Forget it.  I do parallel assignment and you will have to peel it out of
+# my cold dead hands.
+Style/ParallelAssignment:
+  Enabled: false
+
+# FIXME: consider keywords for shapes.
+# I might switch these to keyword args if I ever revisit shapes support.
+# In general lots of params do suck and are hard to remember.  This library
+# still is supposed to work in 1.8 but I can probably soon major rev this
+# and switch over to keywords.
+Metrics/ParameterLists:
+  Exclude:
+    - 'lib/image_voodoo/awt/shapes.rb'

data/.travis.yml

@@ -1,2 +1,9 @@
+language: ruby
+
+sudo: false
+
 rvm:
   - jruby-19mode
+
+before_script:
+  - git clone https://github.com/drewnoakes/metadata-extractor-images.git ../metadata-extractor-images

data/Rakefile

@@ -4,10 +4,10 @@ Bundler::GemHelper.install_tasks
 
 task :default => :test
 
-desc "Run tests"
+desc 'Run tests'
 task :test do
   Rake::TestTask.new do |t|
-    t.libs << "lib:vendor"
+    t.libs << 'lib:vendor'
     t.test_files = FileList['test/test*.rb']
   end
 end

data/bin/image_voodoo

@@ -7,101 +7,91 @@ actions = []
 images = []
 original_image = nil
 
-opts = OptionParser.new do |opts|
-  opts.banner = "Usage: image_voodoo [actions] image_file"
-  opts.separator "Perform some actions on a source image."
-
-  opts.separator ""
-  opts.separator "Actions are meant to be chained. Examples:"
-  opts.separator "  # Print the dimensions"
-  opts.separator "  image_voodoo --dim small.jpg"
-  opts.separator ""
-  opts.separator "  # Convert to a thumbnail, preview, and then save the result"
-  opts.separator "  image_voodoo --thumbnail 50 --preview --save thumb.png large.jpg"
-  opts.separator ""
-  opts.separator "  # Convert source to 3 thumbnails, showing dimensions and"
-  opts.separator "  # previewing along the way"
-  opts.separator "  image_voodoo --dim --resize 50x50 --dim --preview --save t1.jpg"
-  opts.separator "    --pop --resize 40x40 --dim --preview --save t2.jpg"
-  opts.separator "    --pop --resize 30x30 --dim --preview --save t3.jpg image.jpg"
-
-  opts.separator ""
-  opts.separator "Actions:"
-
-  opts.on("-a", "--alpha color_value", "Make color transparent in image") do |c|
-    if c !~ /[[:xdigit:]]{6,6}/
-      opts.usage "color_value is rrggbb in hexidecimal format"
-    end
-    actions << lambda {|img| img.alpha(c) }
-  end
-
-  opts.on("-b", "--brightness SCALE,OFFSET", "Adjust brightness") do |args|
-    scale, offset = args.split(/,/).map {|v| v.to_f}
-    opts.usage "You need to specify proper scale and offset" unless scale && offset
-    actions << lambda {|img| img.adjust_brightness(scale, offset) }
-  end
-
-  opts.on("-B", "--border WIDTH,COLOR,STYLE", "Add a simple border") do |args|
+opts = OptionParser.new do |o|
+  o.banner = 'Usage: image_voodoo [actions] image_file'
+  o.separator 'Perform actions/transformations on an image.'
+  o.separator ''
+  o.separator 'Examples:'
+  o.separator '  image_voodoo --dim small.jpg     # Print the dimensions'
+  o.separator ''
+  o.separator '  # Make a thumbnail, preview it, and then save it.'
+  o.separator '  image_voodoo --thumbnail 50 --preview --save thumb.png large.jpg'
+  o.separator ''
+  o.separator '  # Make 2 thumbnails, showing dimensions and previewing them'
+  o.separator '  image_voodoo --dim --resize 50x50 --dim --preview --save t1.jpg'
+  o.separator '    --pop --resize 40x40 --dim --preview --save t2.jpg image.jpg'
+  o.separator ''
+  o.separator 'Actions:'
+
+  o.on('-a', '--alpha rrggbb', 'Make color transparent in image') do |c|
+    o.usage 'rrggbb is in hexidecimal format' if c !~ /[[:xdigit:]]{6,6}/
+    actions << ->(img) { img.alpha(c) }
+  end
+
+  o.on('-b', '--brightness SCALE,OFFSET', 'Adjust brightness') do |args|
+    scale, offset = args.split(/,/).map(&:to_f)
+    o.usage 'You need to specify proper scale and offset' unless scale && offset
+    actions << ->(img) { img.adjust_brightness(scale, offset) }
+  end
+
+  o.on('-B', '--border WIDTH,COLOR,STYLE', 'Add a simple border') do |args|
     width, color, style = args.split(/,/)
-    options = {:width => width, :color => color, :style => style }
-
-    actions << lambda {|img| img.add_border(options) }
+    options = { width: width, color: color, style: style }
+    actions << ->(img) { img.add_border(options) }
   end
 
-  opts.on("-d", "--dimensions", "Print the image dimensions") do
-    actions << lambda {|img| puts "#{img.width}x#{img.height}"; img }
+  o.on('-d', '--dimensions', 'Print the image dimensions') do
+    actions << ->(img) { img.tap { puts "#{img.width}x#{img.height}" } }
   end
 
-  opts.on("-g", "--greyscale", "Convert image to greyscale") do
-    actions << lambda {|img| img.greyscale }
+  o.on('-g', '--greyscale', 'Convert image to greyscale') do
+    actions << ->(img) { img.greyscale }
   end
 
-  opts.on("-h", "--flip_horizontally") do
-    actions << lambda {|img| img.flip_horizontally }
+  o.on('-h', '--flip_horizontally') do
+    actions << ->(img) { img.flip_horizontally }
   end
 
-  opts.on("-m", "--metadata") do
-    actions << lambda {|img| puts img.metadata }
+  o.on('-m', '--metadata') do
+    actions << ->(img) { img.tap { puts img.metadata } }
   end
 
-  opts.on("-n", "--negative", "Make a negative out of the image") do
-    actions << lambda {|img| img.negative }
+  o.on('-n', '--negative', 'Make a negative out of the image') do
+    actions << ->(img) { img.negative }
   end
 
-  opts.on("-o", "--orient", "Rotate image to orient it based on metadata") do
-    actions << lambda {|img| img.correct_orientation }
+  o.on('-o', '--orient', 'Rotate image to orient it based on metadata') do
+    actions << ->(img) { img.correct_orientation }
   end
 
-  opts.on("-q", "--quality 0..1", Float, "Set % of quality for lossy compression") do |quality|
-    actions << lambda {|img| img.quality(quality) }
+  o.on('-q', '--quality 0..1', Float, 'Set % of quality for lossy compression') do |quality|
+    actions << ->(img) { img.quality(quality) }
   end
 
-  opts.on("-R", "--rotate 0..360", Float, "Set angle to rotate image") do |angle|
-    actions << lambda {|img| img.rotate(angle.to_f) }
+  o.on('-R', '--rotate 0..360', Float, 'Set angle to rotate image') do |angle|
+    actions << ->(img) { img.rotate(angle.to_f) }
   end
 
-  opts.on("-r", "--resize WIDTHxHEIGHT", "Create a new image with the specified", "dimensions") do |dim|
-    width, height = dim.split(/x/i).map {|v| v.to_i}
-    opts.usage "You need to specify proper dimensions" unless width && width > 0 && height && height > 0
-    actions << lambda {|img| img.resize(width,height) }
+  o.on('-r', '--resize WIDTHxHEIGHT', 'Make a new resized image') do |dim|
+    width, height = dim.split(/x/i).map(&:to_i)
+    o.usage 'You need to specify proper dimensions' unless width && width > 0 && height && height > 0
+    actions << ->(img) { img.resize(width, height) }
   end
 
-
-  opts.on("-s", "--save FILENAME", "Save the results to a new file") do |f|
-    actions << lambda {|img| img.save(f); img }
+  o.on('-s', '--save FILENAME', 'Save the results to a new file') do |f|
+    actions << ->(img) { img.tap { img.save(f) } }
   end
 
-  opts.on("-t", "--thumbnail SIZE", Integer, "Create a thumbnail of the given size") do |size|
-    actions << lambda {|img| img.thumbnail(size) }
+  o.on('-t', '--thumbnail SIZE', Integer, 'Create a thumbnail of the given size') do |size|
+    actions << ->(img) { img.thumbnail(size) }
   end
 
-  opts.on("-v", "--flip_vertically") do
-    actions << lambda {|img| img.flip_vertically }
-  end
-
-  opts.on("-p", "--preview", "Preview the image. Close the frame window",
-    "to continue, or quit the application to", "abort the action pipeline") do
+  o.on('-v', '--flip_vertically') { actions << ->(img) { img.flip_vertically } }
 
+  o.on('-p', '--preview',
+       'Preview the image. Close the frame window',
+       'to continue, or quit the application to',
+       'abort the action pipeline') do
     headless = false
     actions << lambda do |img|
       done = false
@@ -111,36 +101,33 @@ opts = OptionParser.new do |opts|
     end
   end
 
-  opts.on("--push", "Save the current image to be popped later") do
-    actions << lambda {|img| images << img; img }
+  o.on('--push', 'Save the current image to be popped later') do
+    actions << ->(img) { img.tap { images << img } }
   end
 
-  opts.on("--pop", "Revert back to the previous saved image", "or the original source image") do
-    actions << lambda {|img| images.pop || original_image }
+  o.on('--pop', 'Revert back to the previous image') do
+    actions << ->() { images.pop || original_image }
   end
 
-  opts.on("-f", "--format", "Print the image format") do
-    actions << lambda {|img| puts img.format; img }
+  o.on('-f', '--format', 'Print the image format') do
+    actions << ->(img) { img.tap { img.format } }
   end
 
-  opts.on_tail("-h", "--help", "Show this message") do
-    puts opts
-    exit 0
-  end
+  o.on_tail('-h', '--help', 'Show this message') { o.usage }
 
-  def opts.usage(msg)
-    puts msg
+  def o.usage(msg=nil)
+    puts msg if msg
     puts self
     exit 1
   end
 end
 opts.parse!(ARGV)
-opts.usage("You need to supply a source image filename.") unless ARGV.first
-opts.usage("You need to supply one or more actions.") unless actions.size > 0
+opts.usage('You need to supply a source image filename.') unless ARGV.first
+opts.usage('You need to supply one or more actions.') if actions.empty?
 
 # For this binstub we only want to load non-headless if we are using
 # the preview feature. top of See lib/image_voodoo.rb for more info...
-class ImageVoodoo; NEEDS_HEAD = true; end unless headless
+require 'image_voodoo/needs_head' unless headless
 
 require 'image_voodoo'
 file_name = ARGV.first

data/image_voodoo.gemspec

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "image_voodoo/version"
+
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'image_voodoo/version'
 
 Gem::Specification.new do |s|
   s.name        = 'image_voodoo'
@@ -12,11 +13,11 @@ Gem::Specification.new do |s|
   s.summary     = 'Image manipulation in JRuby with ImageScience compatible API'
   s.description = 'Image manipulation in JRuby with ImageScience compatible API'
 
-  s.rubyforge_project = "image_voodoo"
+  s.rubyforge_project = 'image_voodoo'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib", "vendor"]
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = %w[lib vendor]
   s.has_rdoc      = true
 end

data/lib/image_science.rb

@@ -1,3 +1,3 @@
 require 'image_voodoo'
 # HA HA...let the pin-pricking begin
-ImageScience = ImageVoodoo
+ImageScience = ImageVoodoo

data/lib/image_voodoo.rb

@@ -5,10 +5,7 @@
 unless defined? ImageVoodoo::NEEDS_HEAD
   java.lang.System.set_property 'java.awt.headless', 'true'
 end
-  
 
-##
-#
 # = ImageVoodoo
 # == Description
 #
@@ -33,7 +30,6 @@ end
 #
 # img = ImageVoodoo.with_image(ARGV[0])
 # negative_img = img.negative
-#
 class ImageVoodoo
   attr_accessor :quality
 
@@ -41,16 +37,15 @@ class ImageVoodoo
 
   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(io, src, format=nil)
@@ -58,127 +53,107 @@ class ImageVoodoo
     @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_dimentions
     target = with_crop(l, t, r, b).thumbnail(size)
     block_given? ? yield(target) : target
   end
 
-  ##
-  #
+  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
+  private :calculate_thumbnail_dimensions
+
   # 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
@@ -186,135 +161,108 @@ class ImageVoodoo
     raise ArgumentError, ne.message
   end
 
-  ##
-  #
   # Rotates the image by angle (specified in degrees).
-  #
   def rotate(angle)
-    target = guard { rotate_impl(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: #{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
+    return 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