joonsrenderer 1.1-java

data/src/main/java/org/sunflow/image/formats/GenericBitmap.java

@@ -0,0 +1,73 @@
+package org.sunflow.image.formats;
+
+import java.io.IOException;
+
+import org.sunflow.PluginRegistry;
+import org.sunflow.image.Bitmap;
+import org.sunflow.image.BitmapWriter;
+import org.sunflow.image.Color;
+import org.sunflow.system.FileUtils;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+/**
+ * This is a generic and inefficient bitmap format which may be used for
+ * debugging purposes (dumping small images), when memory usage is not a
+ * concern.
+ */
+public class GenericBitmap extends Bitmap {
+
+    private final int w;
+    private final int h;
+    private final Color[] color;
+    private final float[] alpha;
+
+    public GenericBitmap(int w, int h) {
+        this.w = w;
+        this.h = h;
+        color = new Color[w * h];
+        alpha = new float[w * h];
+    }
+
+    @Override
+    public int getWidth() {
+        return w;
+    }
+
+    @Override
+    public int getHeight() {
+        return h;
+    }
+
+    @Override
+    public Color readColor(int x, int y) {
+        return color[x + y * w];
+    }
+
+    @Override
+    public float readAlpha(int x, int y) {
+        return alpha[x + y * w];
+    }
+
+    public void writePixel(int x, int y, Color c, float a) {
+        color[x + y * w] = c;
+        alpha[x + y * w] = a;
+    }
+
+    public void save(String filename) {
+        String extension = FileUtils.getExtension(filename);
+        BitmapWriter writer = PluginRegistry.BITMAP_WRITER_PLUGINS.createObject(extension);
+        if (writer == null) {
+            UI.printError(Module.IMG, "Unable to save file \"%s\" - unknown file format: %s", filename, extension);
+            return;
+        }
+        try {
+            writer.openFile(filename);
+            writer.writeHeader(w, h, Math.max(w, h));
+            writer.writeTile(0, 0, w, h, color, alpha);
+            writer.closeFile();
+        } catch (IOException e) {
+            UI.printError(Module.IMG, "Unable to save file \"%s\" - %s", filename, e.getLocalizedMessage());
+        }
+    }
+}

data/src/main/java/org/sunflow/image/readers/BMPBitmapReader.java

@@ -0,0 +1,39 @@
+package org.sunflow.image.readers;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+
+import org.sunflow.image.Bitmap;
+import org.sunflow.image.BitmapReader;
+import org.sunflow.image.Color;
+import org.sunflow.image.formats.BitmapRGB8;
+
+public class BMPBitmapReader implements BitmapReader {
+
+    public Bitmap load(String filename, boolean isLinear) throws IOException, BitmapFormatException {
+        // regular image, load using Java api - ignore alpha channel
+        BufferedImage bi = ImageIO.read(new File(filename));
+        int width = bi.getWidth();
+        int height = bi.getHeight();
+        byte[] pixels = new byte[3 * width * height];
+        for (int y = 0, index = 0; y < height; y++) {
+            for (int x = 0; x < width; x++, index += 3) {
+                int argb = bi.getRGB(x, height - 1 - y);
+                pixels[index + 0] = (byte) (argb >> 16);
+                pixels[index + 1] = (byte) (argb >> 8);
+                pixels[index + 2] = (byte) argb;
+            }
+        }
+        if (!isLinear) {
+            for (int index = 0; index < pixels.length; index += 3) {
+                pixels[index + 0] = Color.NATIVE_SPACE.rgbToLinear(pixels[index + 0]);
+                pixels[index + 1] = Color.NATIVE_SPACE.rgbToLinear(pixels[index + 1]);
+                pixels[index + 2] = Color.NATIVE_SPACE.rgbToLinear(pixels[index + 2]);
+            }
+        }
+        return new BitmapRGB8(width, height, pixels);
+    }
+}

data/src/main/java/org/sunflow/image/readers/HDRBitmapReader.java

@@ -0,0 +1,155 @@
+package org.sunflow.image.readers;
+
+import java.io.BufferedInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.sunflow.image.Bitmap;
+import org.sunflow.image.BitmapReader;
+import org.sunflow.image.formats.BitmapRGBE;
+
+public class HDRBitmapReader implements BitmapReader {
+
+    public Bitmap load(String filename, boolean isLinear) throws IOException, BitmapFormatException {
+        // load radiance rgbe file
+        InputStream f = new BufferedInputStream(new FileInputStream(filename));
+        // parse header
+        boolean parseWidth = false, parseHeight = false;
+        int width = 0, height = 0;
+        int last = 0;
+        while (width == 0 || height == 0 || last != '\n') {
+            int n = f.read();
+            switch (n) {
+                case 'Y':
+                    parseHeight = last == '-';
+                    parseWidth = false;
+                    break;
+                case 'X':
+                    parseHeight = false;
+                    parseWidth = last == '+';
+                    break;
+                case ' ':
+                    parseWidth &= width == 0;
+                    parseHeight &= height == 0;
+                    break;
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                    if (parseHeight) {
+                        height = 10 * height + (n - '0');
+                    } else if (parseWidth) {
+                        width = 10 * width + (n - '0');
+                    }
+                    break;
+                default:
+                    parseWidth = parseHeight = false;
+                    break;
+            }
+            last = n;
+        }
+        // allocate image
+        int[] pixels = new int[width * height];
+        if ((width < 8) || (width > 0x7fff)) {
+            // run length encoding is not allowed so read flat
+            readFlatRGBE(f, 0, width * height, pixels);
+        } else {
+            int rasterPos = 0;
+            int numScanlines = height;
+            int[] scanlineBuffer = new int[4 * width];
+            while (numScanlines > 0) {
+                int r = f.read();
+                int g = f.read();
+                int b = f.read();
+                int e = f.read();
+                if ((r != 2) || (g != 2) || ((b & 0x80) != 0)) {
+                    // this file is not run length encoded
+                    pixels[rasterPos] = (r << 24) | (g << 16) | (b << 8) | e;
+                    readFlatRGBE(f, rasterPos + 1, width * numScanlines - 1, pixels);
+                    break;
+                }
+
+                if (((b << 8) | e) != width) {
+                    throw new BitmapFormatException("Invalid scanline width");
+                }
+                int p = 0;
+                // read each of the four channels for the scanline into
+                // the buffer
+                for (int i = 0; i < 4; i++) {
+                    if (p % width != 0) {
+                        throw new BitmapFormatException("Unaligned access to scanline data");
+                    }
+                    int end = (i + 1) * width;
+                    while (p < end) {
+                        int b0 = f.read();
+                        int b1 = f.read();
+                        if (b0 > 128) {
+                            // a run of the same value
+                            int count = b0 - 128;
+                            if ((count == 0) || (count > (end - p))) {
+                                throw new BitmapFormatException("Bad scanline data - invalid RLE run");
+                            }
+
+                            while (count-- > 0) {
+                                scanlineBuffer[p] = b1;
+                                p++;
+                            }
+                        } else {
+                            // a non-run
+                            int count = b0;
+                            if ((count == 0) || (count > (end - p))) {
+                                throw new BitmapFormatException("Bad scanline data - invalid count");
+                            }
+                            scanlineBuffer[p] = b1;
+                            p++;
+                            if (--count > 0) {
+                                for (int x = 0; x < count; x++) {
+                                    scanlineBuffer[p + x] = f.read();
+                                }
+                                p += count;
+                            }
+                        }
+                    }
+                }
+                // now convert data from buffer into floats
+                for (int i = 0; i < width; i++) {
+                    r = scanlineBuffer[i];
+                    g = scanlineBuffer[i + width];
+                    b = scanlineBuffer[i + 2 * width];
+                    e = scanlineBuffer[i + 3 * width];
+                    pixels[rasterPos] = (r << 24) | (g << 16) | (b << 8) | e;
+                    rasterPos++;
+                }
+                numScanlines--;
+            }
+        }
+        f.close();
+        // flip image
+        for (int y = 0, i = 0, ir = (height - 1) * width; y < height / 2; y++, ir -= width) {
+            for (int x = 0, i2 = ir; x < width; x++, i++, i2++) {
+                int t = pixels[i];
+                pixels[i] = pixels[i2];
+                pixels[i2] = t;
+            }
+        }
+        return new BitmapRGBE(width, height, pixels);
+    }
+
+    private void readFlatRGBE(InputStream f, int rasterPos, int numPixels, int[] pixels) throws IOException {
+        while (numPixels-- > 0) {
+            int r = f.read();
+            int g = f.read();
+            int b = f.read();
+            int e = f.read();
+            pixels[rasterPos] = (r << 24) | (g << 16) | (b << 8) | e;
+            rasterPos++;
+        }
+    }
+}

data/src/main/java/org/sunflow/image/readers/IGIBitmapReader.java

@@ -0,0 +1,104 @@
+package org.sunflow.image.readers;
+
+import java.io.BufferedInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.sunflow.image.Bitmap;
+import org.sunflow.image.BitmapReader;
+import org.sunflow.image.formats.BitmapXYZ;
+
+/**
+ * Reads images in Indigo's native XYZ format.
+ * http://www2.indigorenderer.com/joomla/forum/viewtopic.php?p=11430
+ */
+public class IGIBitmapReader implements BitmapReader {
+
+    public Bitmap load(String filename, boolean isLinear) throws IOException, BitmapFormatException {
+        InputStream stream = new BufferedInputStream(new FileInputStream(filename));
+        // read header
+        int magic = read32i(stream);
+        int version = read32i(stream);
+        stream.skip(8); // skip number of samples (double value)
+        int width = read32i(stream);
+        int height = read32i(stream);
+        int superSample = read32i(stream); // super sample factor
+        int compression = read32i(stream);
+        int dataSize = read32i(stream);
+        int colorSpace = read32i(stream);
+        stream.skip(5000); // skip the rest of the header (unused for now)
+        // error checking
+        if (magic != 66613373) {
+            throw new BitmapFormatException("wrong magic: " + magic);
+        }
+        if (version != 1) {
+            throw new BitmapFormatException("unsupported version: " + version);
+        }
+        if (compression != 0) {
+            throw new BitmapFormatException("unsupported compression: " + compression);
+        }
+        if (colorSpace != 0) {
+            throw new BitmapFormatException("unsupported color space: " + colorSpace);
+        }
+        if (dataSize != (width * height * 12)) {
+            throw new BitmapFormatException("invalid data block size: " + dataSize);
+        }
+        if (width <= 0 || height <= 0) {
+            throw new BitmapFormatException("invalid image size: " + width + "x" + height);
+        }
+        if (superSample <= 0) {
+            throw new BitmapFormatException("invalid super sample factor: " + superSample);
+        }
+        if ((width % superSample) != 0 || (height % superSample) != 0) {
+            throw new BitmapFormatException("invalid image size: " + width + "x" + height);
+        }
+        float[] xyz = new float[width * height * 3];
+        for (int y = 0, i = 3 * (height - 1) * width; y < height; y++, i -= 6 * width) {
+            for (int x = 0; x < width; x++, i += 3) {
+                xyz[i + 0] = read32f(stream);
+                xyz[i + 1] = read32f(stream);
+                xyz[i + 2] = read32f(stream);
+            }
+        }
+        stream.close();
+        if (superSample > 1) {
+            // rescale image (basic box filtering)
+            float[] rescaled = new float[xyz.length / (superSample * superSample)];
+            float inv = 1.0f / (superSample * superSample);
+            for (int y = 0, i = 0; y < height; y += superSample) {
+                for (int x = 0; x < width; x += superSample, i += 3) {
+                    float X = 0;
+                    float Y = 0;
+                    float Z = 0;
+                    for (int sy = 0; sy < superSample; sy++) {
+                        for (int sx = 0; sx < superSample; sx++) {
+                            int offset = 3 * ((x + sx + (y + sy) * width));
+                            X += xyz[offset + 0];
+                            Y += xyz[offset + 1];
+                            Z += xyz[offset + 2];
+                        }
+                    }
+                    rescaled[i + 0] = X * inv;
+                    rescaled[i + 1] = Y * inv;
+                    rescaled[i + 2] = Z * inv;
+                }
+            }
+            return new BitmapXYZ(width / superSample, height / superSample, rescaled);
+        } else {
+            return new BitmapXYZ(width, height, xyz);
+        }
+    }
+
+    private static final int read32i(InputStream stream) throws IOException {
+        int i = stream.read();
+        i |= stream.read() << 8;
+        i |= stream.read() << 16;
+        i |= stream.read() << 24;
+        return i;
+    }
+
+    private static final float read32f(InputStream stream) throws IOException {
+        return Float.intBitsToFloat(read32i(stream));
+    }
+}

data/src/main/java/org/sunflow/image/readers/JPGBitmapReader.java

@@ -0,0 +1,39 @@
+package org.sunflow.image.readers;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+
+import org.sunflow.image.Bitmap;
+import org.sunflow.image.BitmapReader;
+import org.sunflow.image.Color;
+import org.sunflow.image.formats.BitmapRGB8;
+
+public class JPGBitmapReader implements BitmapReader {
+
+    public Bitmap load(String filename, boolean isLinear) throws IOException, BitmapFormatException {
+        // regular image, load using Java api - ignore alpha channel
+        BufferedImage bi = ImageIO.read(new File(filename));
+        int width = bi.getWidth();
+        int height = bi.getHeight();
+        byte[] pixels = new byte[3 * width * height];
+        for (int y = 0, index = 0; y < height; y++) {
+            for (int x = 0; x < width; x++, index += 3) {
+                int argb = bi.getRGB(x, height - 1 - y);
+                pixels[index + 0] = (byte) (argb >> 16);
+                pixels[index + 1] = (byte) (argb >> 8);
+                pixels[index + 2] = (byte) argb;
+            }
+        }
+        if (!isLinear) {
+            for (int index = 0; index < pixels.length; index += 3) {
+                pixels[index + 0] = Color.NATIVE_SPACE.rgbToLinear(pixels[index + 0]);
+                pixels[index + 1] = Color.NATIVE_SPACE.rgbToLinear(pixels[index + 1]);
+                pixels[index + 2] = Color.NATIVE_SPACE.rgbToLinear(pixels[index + 2]);
+            }
+        }
+        return new BitmapRGB8(width, height, pixels);
+    }
+}

data/src/main/java/org/sunflow/image/readers/PNGBitmapReader.java

@@ -0,0 +1,40 @@
+package org.sunflow.image.readers;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+
+import org.sunflow.image.Bitmap;
+import org.sunflow.image.BitmapReader;
+import org.sunflow.image.Color;
+import org.sunflow.image.formats.BitmapRGBA8;
+
+public class PNGBitmapReader implements BitmapReader {
+
+    public Bitmap load(String filename, boolean isLinear) throws IOException, BitmapFormatException {
+        // regular image, load using Java api
+        BufferedImage bi = ImageIO.read(new File(filename));
+        int width = bi.getWidth();
+        int height = bi.getHeight();
+        byte[] pixels = new byte[4 * width * height];
+        for (int y = 0, index = 0; y < height; y++) {
+            for (int x = 0; x < width; x++, index += 4) {
+                int argb = bi.getRGB(x, height - 1 - y);
+                pixels[index + 0] = (byte) (argb >> 16);
+                pixels[index + 1] = (byte) (argb >> 8);
+                pixels[index + 2] = (byte) argb;
+                pixels[index + 3] = (byte) (argb >> 24);
+            }
+        }
+        if (!isLinear) {
+            for (int index = 0; index < pixels.length; index += 4) {
+                pixels[index + 0] = Color.NATIVE_SPACE.rgbToLinear(pixels[index + 0]);
+                pixels[index + 1] = Color.NATIVE_SPACE.rgbToLinear(pixels[index + 1]);
+                pixels[index + 2] = Color.NATIVE_SPACE.rgbToLinear(pixels[index + 2]);
+            }
+        }
+        return new BitmapRGBA8(width, height, pixels);
+    }
+}