axon 0.1.1 → 0.2.0

data/ext/java/axon/AxonService.java

@@ -0,0 +1,15 @@
+package axon;
+
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class AxonService implements BasicLibraryService {
+    public boolean basicLoad(Ruby runtime) {
+        PNG.initPNG(runtime);
+        PNGReader.initPNGReader(runtime);
+        JPEG.initJPEG(runtime);
+        JPEGReader.initJPEGReader(runtime);
+        Interpolation.initInterpolation(runtime);
+        return true;
+    }
+}

data/ext/java/axon/Interpolation.java

@@ -0,0 +1,127 @@
+package axon;
+
+import org.jruby.Ruby;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+public class Interpolation {
+    @JRubyMethod(required = 5, meta = true)
+    public static IRubyObject bilinear(ThreadContext context, IRubyObject self,
+                                       IRubyObject[] args) {
+        ByteList scanline1, scanline2;
+        double ty;
+        int width, src_width, src_line_size, components;
+        byte[] scanline_out;
+        
+        width = RubyFixnum.num2int(args[2]);
+        components = RubyFixnum.num2int(args[4]);
+        ty = RubyNumeric.num2dbl(args[3]);
+        
+        scanline1 = args[0].convertToString().getByteList();
+        scanline2 = args[1].convertToString().getByteList();
+        
+        src_line_size = scanline1.getRealSize();
+        
+        src_width = src_line_size / components - 1;
+
+        scanline_out = calc_bilinear(width, src_width, components, ty,
+                scanline1.getUnsafeBytes(), scanline2.getUnsafeBytes());
+        
+        return(new RubyString(context.getRuntime(), context.getRuntime().getString(), scanline_out));
+    }
+    
+    private static byte[] calc_bilinear(int width, int src_width,
+            int components, double ty, byte[] scanline1, byte[] scanline2) {
+        byte[] dest_sl;
+        double width_ratio_inv, sample_x, tx, _tx, p00, p10, p01, p11;
+        int c0, c1, dest_pos, sample_x_i;
+        short c00, c10, c01, c11;
+        
+        dest_sl = new byte[width * components];
+        width_ratio_inv = (double)src_width / width;
+        
+        dest_pos = 0;
+        for (int i = 0; i < width; i++) {
+            sample_x = i * width_ratio_inv;
+            sample_x_i = (int)sample_x;
+            
+            tx = sample_x - sample_x_i;
+            _tx = 1 - tx;
+            
+            p11 = tx * ty;
+            p01 = _tx * ty;
+            p10 =  tx - p11;
+            p00 = _tx - p01;
+
+            c0 = sample_x_i * components;
+            c1 = c0 + components;
+            
+            for (int j = 0; j < components; j++) {
+                c00 = (short)(0x000000FF & (int)scanline1[c0 + j]);
+                c10 = (short)(0x000000FF & (int)scanline1[c1 + j]);
+                c01 = (short)(0x000000FF & (int)scanline2[c0 + j]);
+                c11 = (short)(0x000000FF & (int)scanline2[c1 + j]);
+
+                dest_sl[dest_pos] = (byte)(((short)(p00 * c00 + p10 * c10 + p01 * c01 + p11 * c11)) & 0xFF);
+                dest_pos += 1;
+            }
+        }
+        
+        return dest_sl;
+        
+    }
+    
+    @JRubyMethod(meta = true)
+    public static IRubyObject nearest(ThreadContext context, IRubyObject self,
+                                      IRubyObject rb_scanline,
+                                      IRubyObject rb_width,
+                                      IRubyObject rb_components) {
+        ByteList scanline_in;
+        byte[] scanline_out;
+        int width, src_width, src_line_size, components;
+        
+        width = RubyFixnum.num2int(rb_width);
+        components = RubyFixnum.num2int(rb_components);
+        
+        scanline_in = rb_scanline.convertToString().getByteList();
+        src_line_size = scanline_in.getRealSize();
+        
+        src_width = src_line_size / components;
+        scanline_out = calc_nearest(width, src_width, components, scanline_in.getUnsafeBytes());
+        
+        return(new RubyString(context.getRuntime(), context.getRuntime().getString(), scanline_out));
+    }
+    
+    private static byte[] calc_nearest(int width, int src_width,
+                                       int components, byte[] scanline) {
+        double inv_scale_x;
+        byte[] dest_sl;
+        int src_pos, dest_pos, i, j;
+        
+        inv_scale_x = (double)src_width / width;
+        dest_sl = new byte[width * components];
+        
+        dest_pos = 0;
+        for (i = 0; i < width; i++) {
+            src_pos = (int)(i * inv_scale_x) * components;
+            for (j = 0; j < components; j++) {
+                dest_sl[dest_pos] = scanline[src_pos + j];
+                dest_pos += 1;
+            }
+        }
+        
+        return dest_sl;
+    }
+    
+    static void initInterpolation(Ruby runtime) {
+        RubyModule axon = runtime.defineModule("Axon");
+        RubyModule interpolation = axon.defineModuleUnder("Interpolation");
+        interpolation.defineAnnotatedMethods(Interpolation.class);        
+    }
+}

data/ext/java/axon/JPEG.java

@@ -0,0 +1,119 @@
+package axon;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import javax.imageio.ImageIO;
+import javax.imageio.IIOImage;
+import javax.imageio.IIOException;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.ImageWriteParam;
+import javax.imageio.ImageWriter;
+import javax.imageio.stream.ImageOutputStream;
+
+import java.awt.image.ColorModel;
+import java.awt.image.SampleModel;
+
+import org.jruby.Ruby;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyString;
+import org.jruby.RubyModule;
+import org.jruby.RubySymbol;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.IOOutputStream;
+
+public class JPEG {
+    
+    /*
+     * OpenJDK (IcedTea6 1.9.10), has an implementation of JPEGImageReader that
+     * loads the entire image into memory via read() before compressing it. Not
+     * sure why it does this -- the PNGImageReader is much nicer and only
+     * buffers one scanline at a time.
+     * 
+     * Be warned -- large images can take up lots of memory here.
+     */
+    
+    @JRubyMethod(meta = true, required = 2, optional = 1)
+    public static IRubyObject write(ThreadContext context, IRubyObject self,
+                                   IRubyObject[] args) throws IOException {
+        IRubyObject img_in, ruby_io, rb_quality, rb_icc_profile;
+        RubyHash options;
+        Iterator writers;
+        ImageWriter writer;
+        IOOutputStream jruby_io;
+        ImageOutputStream ios;
+        RubyImage img;
+        ImageWriteParam iwp;
+        ImageTypeSpecifier dest_type;
+        ColorModel cm;
+        SampleModel sm;
+        int quality;
+        byte[] icc_profile;
+        
+        writers = ImageIO.getImageWritersByFormatName("jpeg");
+        writer = (ImageWriter)writers.next();
+        img_in = args[0];
+        ruby_io = args[1];
+        rb_quality = null;
+        rb_icc_profile = null;
+        
+        if (args.length > 2) {
+            options = (RubyHash)args[2];
+            rb_quality = options.fastARef(RubySymbol.newSymbol(context.getRuntime(),
+                    "quality"));
+            rb_icc_profile = options.fastARef(RubySymbol.newSymbol(context.getRuntime(),
+                    "icc_profile"));
+        }
+        
+        jruby_io = new IOOutputStream(ruby_io, false, false);
+        ios = ImageIO.createImageOutputStream(jruby_io);
+        writer.setOutput(ios);
+        img = new RubyImage(img_in);
+        iwp = writer.getDefaultWriteParam();
+
+        if (rb_quality != null && !rb_quality.isNil()) {
+            quality = RubyFixnum.num2int(rb_quality);
+            if (quality < 1)
+                quality = 1;
+            else if (quality > 100)
+                quality =  100;
+            iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
+            iwp.setCompressionQuality(quality / 100.0f);
+        }
+        
+        /* ImageWriteParam -> ImageTypeSpecifier -> ColorModel -> ColorSpace ->
+         * ICC_Profile
+         */
+        if (rb_icc_profile != null && !rb_icc_profile.isNil()) {
+            icc_profile = ((RubyString)rb_icc_profile).getBytes();
+            cm = img.getICCColorModel(icc_profile);
+            sm = cm.createCompatibleSampleModel(img.getWidth(), img.getHeight());
+                    
+            iwp.setDestinationType(new ImageTypeSpecifier(cm, sm));
+//            System.out.println(cs);
+//            iwp.setDestinationType()
+        }
+        
+        try {
+            writer.write(null, new IIOImage(img, null, null), iwp);
+        }
+        catch(NegativeArraySizeException nas) {
+            throw context.getRuntime().newRuntimeError("An exception occurred while writing.");            
+        }
+        catch(IIOException iioe) {
+            throw context.getRuntime().newRuntimeError("An exception occurred while writing.");            
+        }
+        ios.flush();
+        
+        return context.getRuntime().newFixnum(ios.getStreamPosition());
+    }
+
+    static void initJPEG(Ruby runtime) {
+        RubyModule axon = runtime.defineModule("Axon");
+        RubyModule jpeg = axon.defineModuleUnder("JPEG");
+        jpeg.defineAnnotatedMethods(JPEG.class);
+    }
+}

data/ext/java/axon/JPEGReader.java

@@ -0,0 +1,185 @@
+package axon;
+
+import java.awt.Rectangle;
+import java.awt.color.ICC_ColorSpace;
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferByte;
+import java.awt.image.WritableRaster;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.StringWriter;
+import java.util.Iterator;
+
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReadParam;
+import javax.imageio.ImageReader;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.metadata.IIOMetadataNode;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.stream.ImageInputStream;
+
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.TransformerException;
+
+import org.w3c.dom.Node;
+import org.w3c.dom.Document;
+
+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 JPEGReader 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 JPEGReader(runtime, klass);
+        }
+    };
+
+    public JPEGReader(Ruby runtime, RubyClass klass) {
+        super(runtime, klass);
+    }
+
+    @JRubyMethod
+    public IRubyObject initialize(IRubyObject io) {
+        Iterator readers;
+        ImageInputStream iis;
+        
+        rb_io_in = io;
+        lineno_i = 0;
+
+        readers = ImageIO.getImageReadersByFormatName("jpeg");
+        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.");
+        }
+        catch(ArrayIndexOutOfBoundsException oob) {
+            throw getRuntime().newRuntimeError("An index out of bounds error occurred 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;
+        WritableRaster raster;
+        DataBufferByte buffer;
+        byte[] data;
+        int numbands;
+        byte tmp;
+        
+        /* 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));
+        
+        image = reader.read(0, irp);
+
+        /* get the raw bytes from the scanline */
+        raster = image.getRaster();
+        
+        buffer = (DataBufferByte)raster.getDataBuffer();
+        data = buffer.getData();
+        
+        /* JPEGReader forces us to reorder BGR to RGB. */
+        numbands = getBands();
+        if (numbands == 3) {
+            for (int i = 0; i < data.length / 3; i++) {
+                tmp = data[i * 3];
+                data[i * 3] = data[i * 3 + 2];
+                data[i * 3 + 2] = tmp;
+            }
+        }
+
+        lineno_i += 1;
+        return(new RubyString(getRuntime(), getRuntime().getString(), data));
+    }
+    
+    @JRubyMethod
+    public IRubyObject lineno(ThreadContext context) {
+        return getRuntime().newFixnum(lineno_i);
+    }
+    
+    @JRubyMethod
+    public IRubyObject icc_profile(ThreadContext context) {
+        byte[] data;
+        data = ((ICC_ColorSpace)its.getColorModel().getColorSpace()).getProfile().getData();
+        return(new RubyString(getRuntime(), getRuntime().getString(), data));
+    }
+    
+    public static void initJPEGReader(Ruby runtime) {
+        RubyModule axon = runtime.defineModule("Axon");
+        RubyModule png = axon.defineModuleUnder("JPEG");
+        RubyClass jpegReader = png.defineClassUnder("Reader", runtime.getObject(), ALLOCATOR);
+        jpegReader.defineAnnotatedMethods(JPEGReader.class);
+    }    
+    
+    private int getBands() throws IOException {
+        return its.getNumComponents();
+    }
+}

data/ext/java/axon/PNG.java

@@ -0,0 +1,47 @@
+package axon;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import javax.imageio.ImageIO;
+import javax.imageio.ImageWriter;
+import javax.imageio.stream.ImageOutputStream;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.IOOutputStream;
+
+public class PNG {
+    @JRubyMethod(meta = true)
+    public static IRubyObject write(ThreadContext context, IRubyObject self,
+                                   IRubyObject img_in, IRubyObject ruby_io) throws IOException {
+        Iterator writers = ImageIO.getImageWritersByFormatName("png");
+        ImageWriter writer = (ImageWriter)writers.next();
+        IOOutputStream jruby_io = new IOOutputStream(ruby_io, false, false);
+        ImageOutputStream ios = ImageIO.createImageOutputStream(jruby_io);
+        writer.setOutput(ios);
+        RubyImage img = new RubyImage(img_in);
+        try {
+            writer.write(img);
+        }
+        catch(IllegalArgumentException iae) {
+            throw context.getRuntime().newRuntimeError("An Illegal Argument exception occurred while writing.");
+        }
+        catch(ArrayIndexOutOfBoundsException oob) {
+            throw context.getRuntime().newRuntimeError("An Out of Bounds exception occurred while writing.");            
+        }
+        catch(NegativeArraySizeException nas) {
+            throw context.getRuntime().newRuntimeError("An exception occurred while writing.");            
+        }
+        return context.getRuntime().newFixnum(ios.getStreamPosition());
+    }
+
+    static void initPNG(Ruby runtime) {
+        RubyModule axon = runtime.defineModule("Axon");
+        RubyModule png = axon.defineModuleUnder("PNG");
+        png.defineAnnotatedMethods(PNG.class);
+    }
+}