axon 0.1.1 → 0.2.0

data/ext/java/axon/PNGReader.java

@@ -0,0 +1,164 @@
+package axon;
+
+import java.awt.Rectangle;
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferByte;
+import java.awt.image.Raster;
+import java.io.IOException;
+import java.util.Iterator;
+
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReadParam;
+import javax.imageio.ImageReader;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.stream.ImageInputStream;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.IOInputStream;
+
+public class PNGReader extends RubyObject {
+    private ImageReader reader;
+    private IRubyObject rb_io_in;
+    private ImageTypeSpecifier its;
+    private int lineno_i;
+    
+    private static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new PNGReader(runtime, klass);
+        }
+    };
+    
+    @JRubyMethod
+    public IRubyObject initialize(IRubyObject io) {
+        Iterator readers;
+        ImageInputStream iis;
+        
+        rb_io_in = io;
+        lineno_i = 0;
+
+        readers = ImageIO.getImageReadersByFormatName("png");
+        reader = (ImageReader)readers.next();
+        
+        try {
+            iis = ImageIO.createImageInputStream(new IOInputStream(rb_io_in));
+        }
+        catch(IOException ioe) {
+            throw getRuntime().newIOErrorFromException(ioe);
+        }
+        
+        reader.setInput(iis, true);
+        try {
+            its = reader.getImageTypes(0).next();
+        }
+        catch(IOException ioe) {
+            throw getRuntime().newRuntimeError("An IO error occured while reading.");
+        }
+
+        return this;
+    }
+    
+    @JRubyMethod
+    public IRubyObject width(ThreadContext context) {
+        try {
+            return getRuntime().newFixnum(reader.getWidth(0));
+        }
+        catch(IOException ioe) {
+            throw getRuntime().newIOErrorFromException(ioe);
+        }
+    }
+    
+    @JRubyMethod
+    public IRubyObject height(ThreadContext context) {
+        try {
+            return getRuntime().newFixnum(reader.getHeight(0));
+        }
+        catch(IOException ioe) {
+            throw getRuntime().newIOErrorFromException(ioe);
+        }
+    }
+    
+    @JRubyMethod
+    public IRubyObject components(ThreadContext context) {
+        try {
+            return getRuntime().newFixnum(getBands());
+        }
+        catch(IOException ioe) {
+            throw getRuntime().newIOErrorFromException(ioe);
+        }
+    }
+    
+    @JRubyMethod
+    public IRubyObject gets(ThreadContext context) throws IOException {
+        BufferedImage image;
+        ImageReadParam irp;
+        Raster raster;
+        DataBufferByte buffer;
+        byte[] data;
+        int numbands;
+        int[] bands;
+        
+        /* Return nil if we are already at the bottom of the image */
+        if (lineno_i >= reader.getHeight(0))
+            return(context.nil);
+
+        /* request one scanline */
+        irp = reader.getDefaultReadParam();
+        irp.setSourceRegion(new Rectangle(0, lineno_i, reader.getWidth(0), 1));
+        
+        numbands = getBands();
+        switch (numbands) {
+            case 3:
+                bands = new int[3];
+                bands[0] = 2;
+                bands[1] = 1;
+                bands[2] = 0;
+                irp.setDestinationBands(bands);
+                break;
+            case 4:
+                bands = new int[4];
+                bands[0] = 2;
+                bands[1] = 1;
+                bands[2] = 0;
+                bands[3] = 3;
+                irp.setDestinationBands(bands);
+                break;
+        }
+        image = reader.read(0, irp);
+
+        /* get the raw bytes from the scanline */
+        raster = image.getRaster();
+        buffer = (DataBufferByte)raster.getDataBuffer();
+        data = buffer.getData();
+
+        lineno_i += 1;
+        return(new RubyString(getRuntime(), getRuntime().getString(), data));
+    }
+    
+    @JRubyMethod
+    public IRubyObject lineno(ThreadContext context) {
+        return getRuntime().newFixnum(lineno_i);
+    }
+    
+    static void initPNGReader(Ruby runtime) {
+        RubyModule axon = runtime.defineModule("Axon");
+        RubyModule png = axon.defineModuleUnder("PNG");
+        RubyClass pngReader = png.defineClassUnder("Reader", runtime.getObject(), ALLOCATOR);
+        pngReader.defineAnnotatedMethods(PNGReader.class);
+    }
+    
+    public PNGReader(Ruby runtime, RubyClass klass) {
+        super(runtime, klass);
+    }
+    
+    private int getBands() throws IOException {
+        return its.getNumComponents();
+    }
+}

data/ext/java/axon/RubyImage.java

@@ -0,0 +1,216 @@
+package axon;
+
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.Transparency;
+import java.awt.color.ColorSpace;
+import java.awt.color.ICC_ColorSpace;
+import java.awt.color.ICC_Profile;
+import java.awt.image.DataBuffer;
+import java.awt.image.DataBufferByte;
+import java.awt.image.ColorModel;
+import java.awt.image.ComponentColorModel;
+import java.awt.image.Raster;
+import java.awt.image.RenderedImage;
+import java.awt.image.SampleModel;
+import java.awt.image.BandedSampleModel;
+import java.awt.image.WritableRaster;
+import java.io.ByteArrayOutputStream;
+import java.util.Vector;
+
+import org.jruby.Ruby;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyString;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class RubyImage implements RenderedImage {
+    private IRubyObject rb_image;
+    
+    public RubyImage(IRubyObject img) {
+        rb_image = img;
+    }
+
+    public WritableRaster copyData(WritableRaster raster) {
+        throw new UnsupportedOperationException("copyData");
+    }
+    
+    public ColorModel getColorModel() {
+        int components, cs_type;
+        boolean has_alpha;
+        
+        components = components();
+
+        if (components == 1 || components == 2)
+            cs_type = ColorSpace.CS_GRAY;
+        else if (components == 3 || components == 4)
+            cs_type = ColorSpace.CS_sRGB;
+        else
+            cs_type = ColorSpace.TYPE_RGB; // FIXME: Raise an exception instead
+        
+        has_alpha = components == 2 || components == 4;
+        
+        return(new ComponentColorModel(ColorSpace.getInstance(cs_type),
+                has_alpha, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE));
+    }
+    
+    public ColorModel getICCColorModel(byte[] data) {
+        int components;
+        ICC_ColorSpace cs;
+        boolean has_alpha;
+        
+        components = components();
+
+        cs = new ICC_ColorSpace(ICC_Profile.getInstance(data));
+        
+        has_alpha = components == 2 || components == 4;
+        
+        return(new ComponentColorModel(cs, has_alpha, false,
+                Transparency.OPAQUE, DataBuffer.TYPE_BYTE));
+    }
+    
+    public Raster getTile(int tileX, int tileY) {
+        throw new UnsupportedOperationException("getTile");        
+    }
+
+    public Raster getData() {
+        return getData(new Rectangle(getWidth(), getHeight()));
+    }
+
+    public Raster getData(Rectangle rect) {
+        DataBuffer dataBuffer;
+        int w, h, numbands, lineno, sl_size;
+        RubyString sl;
+        ByteArrayOutputStream stream;
+        byte[] sl_bytes;
+        int[] bandOffsets;
+        Raster raster;
+        
+        w = getWidth();
+        h = getHeight();
+        numbands = components();
+        lineno = lineno();
+        sl_size = w * numbands;
+        
+        bandOffsets = new int[numbands];
+        for (int i=0; i<numbands; i++)
+            bandOffsets[i] = i;
+        
+        if (rect.height < 1 || rect.width < 1)
+            throw runtime().newRuntimeError("Requested image region has invalid size.");
+
+        stream = new ByteArrayOutputStream(rect.height * rect.width);
+        
+        for (int j=0; j<rect.height; j++) {
+            sl = RubyString.objAsString(context(), callMethod("gets"));
+            sl_bytes = sl.getBytes();
+            
+            if(sl_bytes.length != sl_size)
+                throw runtime().newRuntimeError("Image returned a scanline with a bad size.");
+            
+            try {
+                stream.write(sl_bytes, 0, sl_size);
+            }
+            catch(IndexOutOfBoundsException iob) {
+                throw runtime().newRuntimeError("An index out of bounds error occurred while writing.");
+            }
+        }
+
+        dataBuffer = new DataBufferByte(stream.toByteArray(), stream.size());
+        try {
+            raster = Raster.createInterleavedRaster(dataBuffer, w, rect.height,
+                sl_size, numbands, bandOffsets, new Point(0, lineno));
+        }
+        catch(IllegalArgumentException iae) {
+            throw runtime().newRuntimeError("An argument exception occurred while preparing image data.");
+        }
+        
+        return(raster);
+    }
+    
+    public Vector<RenderedImage> getSources() {
+        throw new UnsupportedOperationException("getSources");
+    }
+
+    public Object getProperty(String name) {
+        throw new UnsupportedOperationException("getProperty");
+    }
+
+    public String[] getPropertyNames() {
+        throw new UnsupportedOperationException("getPropertyNames");
+    }
+
+    public SampleModel getSampleModel() {
+        int w;
+        w = getWidth();
+        return new BandedSampleModel(DataBuffer.TYPE_BYTE, w, 1, components());
+    }
+
+    public int getWidth() {
+        return RubyFixnum.num2int(callMethod("width"));
+    }
+
+    public int getHeight() {
+        return RubyFixnum.num2int(callMethod("height"));
+    }
+
+    public int getMinX() {
+        return 0;
+    }
+
+    public int getMinY() {
+        return lineno();
+    }
+
+    public int getNumXTiles() {
+        return 1;
+    }
+
+    public int getNumYTiles() {
+        return getHeight();
+    }
+
+    public int getMinTileX() {
+        return 1;
+    }
+
+    public int getMinTileY() {
+        return getMinY();
+    }
+
+    public int getTileWidth() {
+        throw new UnsupportedOperationException("getTileWidth");
+    }
+
+    public int getTileHeight() {
+        throw new UnsupportedOperationException("getTileHeight");
+    }
+
+    public int getTileGridXOffset() {
+        throw new UnsupportedOperationException("getTileGridXOffset");
+    }
+
+    public int getTileGridYOffset() {
+        throw new UnsupportedOperationException("getTileGridYOffset");
+    }
+    
+    private int lineno() {
+        return RubyFixnum.num2int(callMethod("lineno"));
+    }
+    
+    private int components() {
+        return RubyFixnum.num2int(callMethod("components"));
+    }
+
+    private IRubyObject callMethod(String name) {
+        return rb_image.callMethod(context(), name);
+    }
+    
+    private ThreadContext context() {
+        return runtime().getCurrentContext();
+    }
+    
+    private Ruby runtime() {
+        return rb_image.getRuntime();
+    }
+}

data/lib/axon.rb

@@ -5,10 +5,11 @@ require 'axon/cropper'
 require 'axon/fit'
 require 'axon/scalers'
 require 'axon/generators'
+require 'axon/alpha_stripper'
 require 'stringio'
 
 module Axon
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 
   # :call-seq:
   #   Axon.jpeg(thing [, markers]) -> image
@@ -39,6 +40,31 @@ module Axon
     Image.new(reader)
   end
 
+  # :call-seq:
+  #   Axon.jpeg_file(path [, markers], &block) -> block_result
+  #
+  # Opens the file located at +path+ and reads it as a compressed JPEG image.
+  #
+  # +markers+ should be an array of valid JPEG header marker symbols. Valid
+  # symbols are :APP0 through :APP15 and :COM.
+  #
+  # If performance is important and you don't care about any markers, you can
+  # avaoid reading any header markers by supplying an empty array for +markers+.
+  #
+  # When +markers+ is not given, all known JPEG markers will be read.
+  # 
+  # This method returns the result of the block.
+  #
+  #   Axon.jpeg_file("image.jpg", [:APP2]) do |image|
+  #     image.png_file("image.png") # saves "image.jpg" to "image.png"
+  #   end
+  #
+  def self.jpeg_file(path, *args)
+    File.open(path, 'rb') do |f|
+      yield jpeg(f, *args)
+    end
+  end
+
   # :call-seq:
   #   Axon.png(thing) -> image
   #
@@ -57,6 +83,23 @@ module Axon
     Image.new(reader)
   end
 
+  # :call-seq:
+  #   Axon.png_file(path, &block) -> block_result
+  #
+  # Opens the file located at +path+ and reads it as a compressed PNG image.
+  #
+  # This method returns the result of the block.
+  #
+  #   Axon.png_file("image.png") do |image|
+  #     image.jpeg_file("image.jpg") # saves "image.png" to "image.jpeg"
+  #   end
+  #
+  def self.png_file(path, *args)
+    File.open(path, 'rb') do |f|
+      yield png(f, *args)
+    end
+  end
+
   class Image
     # :call-seq:
     #   Image.new(image_in)
@@ -176,6 +219,8 @@ module Axon
     # Writes the image to +io_out+ as compressed JPEG data. Returns the number
     # of bytes written.
     #
+    # If the image has an alpha channel it will be stripped.
+    #
     # +options+ may contain the following symbols:
     #
     # * :bufsize     -- the maximum size in bytes of the writes that will be
@@ -191,9 +236,34 @@ module Axon
     #   i.jpeg(io_out, :quality => 88) # writes the image to output.jpg
     #
     def jpeg(*args)
+      case @source.components
+      when 2,4 then @source = AlphaStripper.new(@source)
+      end
       JPEG.write(@source, *args)
     end
 
+    # :call-seq:
+    #   jpeg_file(path [, options])
+    #
+    # Writes the image to a new file at +path+ as compressed JPEG data.
+    # Returns the number of bytes written.
+    #
+    # If the image has an alpha channel it will be stripped.
+    # 
+    # See Axon#jpeg for a description of +options+.
+    #
+    # == Example
+    #
+    #   Axon.png_file("image.png") do |image|
+    #     image.jpeg_file("image.jpg") # saves the image to "image.jpeg"
+    #   end
+    #
+    def jpeg_file(path, *args)
+      File.open(path, 'wb') do |f|
+        jpeg(f, *args)
+      end
+    end
+
     # :call-seq:
     #   png(io_out)
     #
@@ -210,16 +280,28 @@ module Axon
       PNG.write(@source, *args)
     end
 
-    # Gets the components in the image.
+    # :call-seq:
+    #   png_file(path)
     #
-    def components
-      @source.components
+    # Writes the image to a new file at +path+ as compressed PNG data. Returns
+    # the number of bytes written.
+    #
+    # == Example
+    #
+    #   Axon.jpeg_file("image.jpg") do |image|
+    #     image.png_file("image.png") # saves the image to "image.jpeg"
+    #   end
+    #
+    def png_file(path, *args)
+      File.open(path, 'wb') do |f|
+        png(f, *args)
+      end
     end
 
-    # Gets the color model of the image.
+    # Gets the components in the image.
     #
-    def color_model
-      @source.color_model
+    def components
+      @source.components
     end
 
     # Gets the width of the image.
@@ -245,5 +327,9 @@ module Axon
     def gets
       @source.gets
     end
+    
+    def method_missing(name, *args)
+      @source.send(name, *args)
+    end
   end
 end