image_voodoo 0.5 → 0.6

data/Manifest.txt

@@ -5,6 +5,8 @@ README.txt
 LICENSE.txt
 lib/image_science.rb
 lib/image_voodoo
+lib/image_voodoo/awt.rb
+lib/image_voodoo/gae.rb
 lib/image_voodoo/version.rb
 lib/image_voodoo.rb
 samples/bench.rb

data/lib/image_voodoo.rb

@@ -27,62 +27,29 @@
 class ImageVoodoo
   include Java
 
-  import java.awt.RenderingHints
-  import java.awt.color.ColorSpace
-  import java.awt.geom.AffineTransform
-  import java.awt.image.BufferedImage
-  import java.awt.image.ByteLookupTable
-  import java.awt.image.ColorConvertOp
-  import java.awt.image.LookupOp
-  import java.awt.image.RescaleOp
   JFile = java.io.File
-  import java.io.ByteArrayInputStream
-  import java.io.ByteArrayOutputStream
-  import javax.imageio.ImageIO
-  import javax.swing.JFrame
 
-  NEGATIVE_OP = LookupOp.new(ByteLookupTable.new(0, (0...254).to_a.reverse.to_java(:byte)), nil)
-  GREY_OP = ColorConvertOp.new(ColorSpace.getInstance(ColorSpace::CS_GRAY), nil)
-  ARGB = BufferedImage::TYPE_INT_ARGB
-  RGB = BufferedImage::TYPE_INT_RGB
-  SCALE_SMOOTH = java.awt.Image::SCALE_SMOOTH
+  # 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'
+  rescue
+     require 'image_voodoo/awt'
+  end
 
   def initialize(src)
     @src = src
   end
 
-  #
-  # Add a border to the image and yield/return a new image.  The following
-  # options are supported:
-  #   - width: How thick is the border (default: 3)
-  #   - color: Which color is the border (in rrggbb hex value) 
-  #   - style: etched, raised, plain (default: plain)
-  #
-  def add_border(options = {})
-    border_width = options[:width].to_i || 2
-    color = hex_to_color(options[:color]) || hex_to_color("000000")
-    style = options[:style]
-    style = nil if style.to_sym == :plain
-    new_width, new_height = width + 2*border_width, height + 2*border_width
-    target = paint(BufferedImage.new(new_width, new_height, color_type)) do |g|
-      g.color = color
-      if style
-        raised = style.to_sym == :raised ? true : false
-        g.fill3DRect(0, 0, new_width, new_height, raised)
-      else
-        g.fill_rect(0, 0, new_width, new_height)
-      end
-      g.draw_image(@src, nil, border_width, border_width)
-    end
-    block_given? ? yield(target) : target
-  end
-
   #
   # Adjusts the brightness of each pixel in image by the following formula:
   # new_pixel = pixel * scale + offset
   #
   def adjust_brightness(scale, offset)
-    image = internal_transform(RescaleOp.new(scale, offset, nil))
+    image = guard { adjust_brightness_impl(scale, offset) }
     block_given? ? yield(image) : image
   end
 
@@ -91,16 +58,7 @@ class ImageVoodoo
   # image.
   #
   def alpha(rgb)
-    color = hex_to_color(rgb)
-    target = paint(BufferedImage.new(width, height, ARGB)) do |g|
-      g.set_composite(java.awt.AlphaComposite::Src)
-      g.draw_image(@src, nil, 0, 0)
-      0.upto(height-1) do |i|
-        0.upto(width-1) do |j|
-          target.setRGB(j, i, 0x8F1C1C) if target.getRGB(j, i) == color.getRGB
-        end
-      end
-    end
+    target = guard { alpha_impl(rgb) }
     block_given? ? yield(target) : target
   end
 
@@ -108,9 +66,8 @@ class ImageVoodoo
   # Write current image out as a stream of bytes using provided format.
   # 
   def bytes(format)
-    out = ByteArrayOutputStream.new
-    ImageIO.write(@src, format, out)
-    String.from_java_bytes(out.to_byte_array)
+    java_bytes = guard { bytes_impl(format) }
+    String.from_java_bytes java_bytes
   end
 
   #
@@ -130,9 +87,7 @@ class ImageVoodoo
   # Flips the image horizontally and yields/returns the new image.
   #
   def flip_horizontally
-    target = paint do |g|
-      g.draw_image @src, 0, 0, width, height, width, 0, 0, height, nil
-    end
+    target = guard { flip_horizontally_impl }
     block_given? ? yield(target) : target
   end
 
@@ -140,9 +95,7 @@ class ImageVoodoo
   # Flips the image vertically and yields/returns the new image.
   #
   def flip_vertically
-    target = paint do |g|
-      g.draw_image @src, 0, 0, width, height, 0, height, width, 0, nil
-    end
+    target = guard { flip_vertically_impl }
     block_given? ? yield(target) : target
   end
 
@@ -150,7 +103,7 @@ class ImageVoodoo
   # Creates a grayscale version of image and yields/returns the new image.
   #
   def greyscale
-    target = internal_transform(GREY_OP)
+    target = guard { greyscale_impl }
     block_given? ? yield(target) : target
   end
   alias_method :grayscale, :greyscale
@@ -159,19 +112,15 @@ class ImageVoodoo
   # Creates a negative and yields/returns the new image.
   #
   def negative
-    target = internal_transform(NEGATIVE_OP)
+    target = guard { negative_impl }
     block_given? ? yield(target) : target
   end
 
   #
-  # Resizes the image to width and height using bicubic interpolation and 
-  # yields/returns the new image. 
+  # Resizes the image to width and height and yields/returns the new image. 
   #
   def resize(width, height)
-    target = paint(BufferedImage.new(width, height, color_type)) do |g|
-      scaled_image = @src.get_scaled_instance width, height, SCALE_SMOOTH
-      g.draw_image scaled_image, 0, 0, nil
-    end
+    target = guard { resize_impl(width, height) }
     block_given? ? yield(target) : target
   rescue NativeException => ne
     raise ArgumentError, ne.message
@@ -185,7 +134,7 @@ class ImageVoodoo
     format = File.extname(file)
     return false if format == ""
     format = format[1..-1].downcase
-    ImageIO.write(@src, format, JFile.new(file))
+    guard { save_impl(format, JFile.new(file)) }
     true
   end
 
@@ -213,79 +162,16 @@ class ImageVoodoo
   # new image. 
   #
   def with_crop(left, top, right, bottom)
-    image = ImageVoodoo.new @src.get_subimage(left, top, right-left, bottom-top)
+    image = guard { with_crop_impl(left, top, right, bottom) }
     block_given? ? yield(image) : image
   end
 
-  # 
-  # A simple swing wrapper around an image voodoo object.
-  #
-  class JImagePanel < javax.swing.JPanel
-    def initialize(image, x=0, y=0)
-      super()
-      @image, @x, @y = image, x, y
-    end
-
-    def image=(image)
-      @image = image
-      invalidate
-    end
-
-    def getPreferredSize
-      java.awt.Dimension.new(@image.width, @image.height)
-    end
-
-    def paintComponent(graphics)
-      graphics.draw_image(@image.to_java, @x, @y, nil)
-    end
-  end
-
-  # Internal class for closing preview window
-  class WindowClosed
-    def initialize(block = nil)
-      @block = block || proc { java.lang.System.exit(0) }
-    end
-    def method_missing(meth,*args); end
-    def windowClosing(event); @block.call; end
-  end
-
-  #
-  # Creates a viewable frame displaying current image within it.
-  #
-  def preview(&block)
-    frame = JFrame.new("Preview")
-    frame.add_window_listener WindowClosed.new(block)
-    frame.set_bounds 0, 0, width + 20, height + 40
-    frame.add JImagePanel.new(self, 10, 10)
-    frame.visible = true
-  end
-
-  #
-  # TODO: Figure out how to determine whether source has alpha or not
-  # Experimental: Read an image from the url source and yield/return that
-  # image.
-  #
-  def self.from_url(source)
-    url = java.net.URL.new(source)
-    image = java.awt.Toolkit.default_toolkit.create_image(url)
-    tracker = java.awt.MediaTracker.new(java.awt.Label.new(""))
-    tracker.addImage(image, 0);
-    tracker.waitForID(0)
-    target = paint(BufferedImage.new(image.width, image.height, RGB)) do |g| 
-      g.draw_image image, 0, 0, nil
-    end
-    block_given? ? yield(target) : target
-  rescue java.io.IOException, java.net.MalformedURLException
-    raise ArgumentError.new "Trouble retrieving image: #{$!.message}"
-  end
-
   # 
   # A top-level image loader opens path and then yields/returns the image.
   #
   def self.with_image(file)
     raise ArgumentError, "file does not exist" unless File.file?(file)
-    buffered_image = ImageIO.read(JFile.new(file))
-    image = ImageVoodoo.new(buffered_image) if buffered_image
+    image = guard { with_image_impl(JFile.new(file)) }
     image && block_given? ? yield(image) : image
   end
 
@@ -294,10 +180,26 @@ class ImageVoodoo
   #
   def self.with_bytes(bytes)
     bytes = bytes.to_java_bytes if String === bytes
-    image = ImageVoodoo.new ImageIO.read(ByteArrayInputStream.new(bytes))
+    image = guard { with_bytes_impl(bytes) }
     block_given? ? yield(image) : image
   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
+  end
+  def guard(&block)
+    ImageVoodoo.guard(&block)
+  end
+
   #
   # Returns the height of the image, in pixels. 
   #
@@ -313,55 +215,11 @@ class ImageVoodoo
   end
 
   #
-  # Returns the underlying Java BufferedImage associated with this object.
+  # 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
-
-  private
-
-  #
-  # Converts a RGB hex value into a java.awt.Color object or dies trying
-  # with an ArgumentError.
-  #
-  def hex_to_color(rgb)
-    raise ArgumentError.new "hex rrggbb needed" if rgb !~ /[[:xdigit:]]{6,6}/
-
-    java.awt.Color.new(rgb[0,2].to_i(16), rgb[2,2].to_i(16), rgb[4,2].to_i(16))
-  end
-
-  # 
-  # Determines the best colorspace for a new image based on whether the
-  # existing image contains an alpha channel or not.
-  #
-  def color_type
-    @src.color_model.has_alpha ? ARGB : RGB
-  end
-
-  #
-  # DRY up drawing setup+teardown
-  # 
-  def paint(src=dup_src)
-    yield src.graphics
-    src.graphics.dispose
-    ImageVoodoo.new src
-  end
-
-  # 
-  # Make a duplicate of the underlying Java src image
-  #
-  def dup_src
-    BufferedImage.new width, height, color_type
-  end
-
-  #
-  # Do simple AWT operation transformation to target.
-  #
-  def internal_transform(operation, target=dup_src)
-    paint(target) do |g|
-      g.draw_image(@src, 0, 0, nil)
-      g.draw_image(operation.filter(target, nil), 0, 0, nil)
-    end
-  end
 end

data/lib/image_voodoo/awt.rb

@@ -0,0 +1,223 @@
+class ImageVoodoo
+  java_import java.awt.RenderingHints
+  java_import java.awt.color.ColorSpace
+  java_import java.awt.geom.AffineTransform
+  java_import java.awt.image.BufferedImage
+  java_import java.awt.image.ByteLookupTable
+  java_import java.awt.image.ColorConvertOp
+  java_import java.awt.image.LookupOp
+  java_import java.awt.image.RescaleOp
+  java_import java.io.ByteArrayInputStream
+  java_import java.io.ByteArrayOutputStream
+  java_import javax.imageio.ImageIO
+  java_import javax.swing.JFrame
+
+  NEGATIVE_OP = LookupOp.new(ByteLookupTable.new(0, (0...254).to_a.reverse.to_java(:byte)), nil)
+  GREY_OP = ColorConvertOp.new(ColorSpace.getInstance(ColorSpace::CS_GRAY), nil)
+  ARGB = BufferedImage::TYPE_INT_ARGB
+  RGB = BufferedImage::TYPE_INT_RGB
+  SCALE_SMOOTH = java.awt.Image::SCALE_SMOOTH
+
+  #
+  # AWT-only (experimental)
+  # Add a border to the image and yield/return a new image.  The following
+  # options are supported:
+  #   - width: How thick is the border (default: 3)
+  #   - color: Which color is the border (in rrggbb hex value) 
+  #   - style: etched, raised, plain (default: plain)
+  #
+  def add_border(options = {})
+    border_width = options[:width].to_i || 2
+    color = hex_to_color(options[:color]) || hex_to_color("000000")
+    style = options[:style]
+    style = nil if style.to_sym == :plain
+    new_width, new_height = width + 2*border_width, height + 2*border_width
+    target = paint(BufferedImage.new(new_width, new_height, color_type)) do |g|
+      g.color = color
+      if style
+        raised = style.to_sym == :raised ? true : false
+        g.fill3DRect(0, 0, new_width, new_height, raised)
+      else
+        g.fill_rect(0, 0, new_width, new_height)
+      end
+      g.draw_image(@src, nil, border_width, border_width)
+    end
+    block_given? ? yield(target) : target
+  end
+
+  def adjust_brightness_impl(scale, offset)
+    transform(RescaleOp.new(scale, offset, nil))
+  end
+
+  # AWT-only
+  def alpha_impl(rgb)
+    color = hex_to_color(rgb)
+    target = paint(BufferedImage.new(width, height, ARGB)) do |g|
+      g.set_composite(java.awt.AlphaComposite::Src)
+      g.draw_image(@src, nil, 0, 0)
+      0.upto(height-1) do |i|
+        0.upto(width-1) do |j|
+          target.setRGB(j, i, 0x8F1C1C) if target.getRGB(j, i) == color.getRGB
+        end
+      end
+    end
+  end
+
+  def bytes_impl(format)
+    out = ByteArrayOutputStream.new
+    ImageIO.write(@src, format, out)
+    out.to_byte_array
+  end
+
+  def flip_horizontally_impl
+    paint {|g| g.draw_image @src, 0, 0, width, height, width, 0, 0, height, nil}
+  end
+
+  def flip_vertically_impl
+    paint {|g| g.draw_image @src, 0, 0, width, height, 0, height, width, 0, nil}
+  end
+
+  def greyscale_impl
+    transform(GREY_OP)
+  end
+
+  def negative_impl
+    transform(NEGATIVE_OP)
+  end
+
+  def resize_impl(width, height)
+    paint(BufferedImage.new(width, height, color_type)) do |g|
+      scaled_image = @src.get_scaled_instance width, height, SCALE_SMOOTH
+      g.draw_image scaled_image, 0, 0, nil
+    end
+  end
+
+  #
+  # Save using the format string (jpg, gif, etc..) to the open Java File
+  # instance passed in.
+  #
+  def save_impl(format, file)
+    ImageIO.write(@src, format, file)
+  end
+
+  def with_crop_impl(left, top, right, bottom)
+    ImageVoodoo.new @src.get_subimage(left, top, right-left, bottom-top)
+  end
+
+  # 
+  # A simple swing wrapper around an image voodoo object.
+  #
+  class JImagePanel < javax.swing.JPanel
+    def initialize(image, x=0, y=0)
+      super()
+      @image, @x, @y = image, x, y
+    end
+
+    def image=(image)
+      @image = image
+      invalidate
+    end
+
+    def getPreferredSize
+      java.awt.Dimension.new(@image.width, @image.height)
+    end
+
+    def paintComponent(graphics)
+      graphics.draw_image(@image.to_java, @x, @y, nil)
+    end
+  end
+
+  # Internal class for closing preview window
+  class WindowClosed
+    def initialize(block = nil)
+      @block = block || proc { java.lang.System.exit(0) }
+    end
+    def method_missing(meth,*args); end
+    def windowClosing(event); @block.call; end
+  end
+
+  #
+  # Creates a viewable frame displaying current image within it.
+  #
+  def preview(&block)
+    frame = JFrame.new("Preview")
+    frame.add_window_listener WindowClosed.new(block)
+    frame.set_bounds 0, 0, width + 20, height + 40
+    frame.add JImagePanel.new(self, 10, 10)
+    frame.visible = true
+  end
+
+  #
+  # TODO: Figure out how to determine whether source has alpha or not
+  # Experimental: Read an image from the url source and yield/return that
+  # image.
+  #
+  def self.from_url(source)
+    url = java.net.URL.new(source)
+    image = java.awt.Toolkit.default_toolkit.create_image(url)
+    tracker = java.awt.MediaTracker.new(java.awt.Label.new(""))
+    tracker.addImage(image, 0);
+    tracker.waitForID(0)
+    target = paint(BufferedImage.new(image.width, image.height, RGB)) do |g| 
+      g.draw_image image, 0, 0, nil
+    end
+    block_given? ? yield(target) : target
+  rescue java.io.IOException, java.net.MalformedURLException
+    raise ArgumentError.new "Trouble retrieving image: #{$!.message}"
+  end
+
+  def self.with_image_impl(file)
+    buffered_image = ImageIO.read(file)
+    buffered_image ? ImageVoodoo.new(buffered_image) : nil
+  end
+
+  def self.with_bytes_impl(bytes)
+    ImageVoodoo.new ImageIO.read(ByteArrayInputStream.new(bytes))
+  end
+
+  private
+
+  #
+  # Converts a RGB hex value into a java.awt.Color object or dies trying
+  # with an ArgumentError.
+  #
+  def hex_to_color(rgb)
+    raise ArgumentError.new "hex rrggbb needed" if rgb !~ /[[:xdigit:]]{6,6}/
+
+    java.awt.Color.new(rgb[0,2].to_i(16), rgb[2,2].to_i(16), rgb[4,2].to_i(16))
+  end
+
+  # 
+  # Determines the best colorspace for a new image based on whether the
+  # existing image contains an alpha channel or not.
+  #
+  def color_type
+    @src.color_model.has_alpha ? ARGB : RGB
+  end
+
+  # 
+  # Make a duplicate of the underlying Java src image
+  #
+  def dup_src
+    BufferedImage.new width, height, color_type
+  end
+
+  #
+  # Do simple AWT operation transformation to target.
+  #
+  def transform(operation, target=dup_src)
+    paint(target) do |g|
+      g.draw_image(@src, 0, 0, nil)
+      g.draw_image(operation.filter(target, nil), 0, 0, nil)
+    end
+  end
+
+  #
+  # DRY up drawing setup+teardown
+  # 
+  def paint(src=dup_src)
+    yield src.graphics
+    src.graphics.dispose
+    ImageVoodoo.new src
+  end
+end

data/lib/image_voodoo/gae.rb

@@ -0,0 +1,53 @@
+class ImageVoodoo
+  java_import com.google.appengine.api.images.Image
+  java_import com.google.appengine.api.images.ImagesService
+  java_import com.google.appengine.api.images.ImagesServiceFactory
+  java_import com.google.appengine.api.images.Transform
+
+  ImageService = ImagesServiceFactory.images_service
+
+  # Value Add methods for this backend
+
+  def i_am_feeling_lucky
+    transform(ImagesServiceFactory.make_im_feeling_lucky)
+  end
+
+  # Implementations of standard features
+
+  def flip_horizontally_impl
+    transform(ImagesServiceFactory.make_horizontal_flip)
+  end
+
+  def flip_vertically_impl
+    transform(ImagesServiceFactory.make_vertical_flip)
+  end
+
+  def resize_impl(width, height)
+    transform(ImagesServiceFactory.make_resize(width, height))
+  end
+
+  def with_crop_impl(left, top, right, bottom)
+    transform(ImagesServiceFactory.make_crop(left, top, right, bottom))
+  end
+
+  def self.with_bytes_impl(bytes)
+    ImageVoodoo.new ImageServicesFactory.make_image(bytes)
+  end
+
+  private
+
+  def from_java_bytes
+    String.from_java_bytes @src.image_data
+  end
+
+  # 
+  # Make a duplicate of the underlying src image
+  #
+  def dup_src
+    ImageServicesFactory.make_image(from_java_bytes)
+  end
+
+  def transform(transform, target=dup_src)
+    ImageService.apply_transform(transform, target)
+  end
+end

data/lib/image_voodoo/version.rb

@@ -1,3 +1,3 @@
 class ImageVoodoo
-  VERSION = "0.5"
+  VERSION = "0.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: image_voodoo
 version: !ruby/object:Gem::Version 
-  version: "0.5"
+  version: "0.6"
 platform: ruby
 authors: 
 - Thomas Enebo, Charles Nutter and JRuby contributors
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-13 00:00:00 -05:00
+date: 2009-06-17 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -31,6 +31,8 @@ files:
 - LICENSE.txt
 - lib/image_science.rb
 - lib/image_voodoo
+- lib/image_voodoo/awt.rb
+- lib/image_voodoo/gae.rb
 - lib/image_voodoo/version.rb
 - lib/image_voodoo.rb
 - samples/bench.rb