joonsrenderer 1.1-java

data/src/main/java/org/sunflow/core/display/FileDisplay.java

@@ -0,0 +1,83 @@
+package org.sunflow.core.display;
+
+import java.io.IOException;
+
+import org.sunflow.PluginRegistry;
+import org.sunflow.core.Display;
+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;
+
+public class FileDisplay implements Display {
+
+    private BitmapWriter writer;
+    private String filename;
+
+    public FileDisplay(boolean saveImage) {
+        this(saveImage ? "output.png" : ".none");
+    }
+
+    public FileDisplay(String filename) {
+        this.filename = filename == null ? "output.png" : filename;
+        String extension = FileUtils.getExtension(filename);
+        writer = PluginRegistry.BITMAP_WRITER_PLUGINS.createObject(extension);
+    }
+
+    @Override
+    public void imageBegin(int w, int h, int bucketSize) {
+        if (writer == null) {
+            return;
+        }
+        try {
+            writer.openFile(filename);
+            writer.writeHeader(w, h, bucketSize);
+        } catch (IOException e) {
+            UI.printError(Module.IMG, "I/O error occured while preparing image for display: %s", e.getMessage());
+        }
+    }
+
+    @Override
+    public void imagePrepare(int x, int y, int w, int h, int id) {
+        // does nothing for files
+    }
+
+    @Override
+    public void imageUpdate(int x, int y, int w, int h, Color[] data, float[] alpha) {
+        if (writer == null) {
+            return;
+        }
+        try {
+            writer.writeTile(x, y, w, h, data, alpha);
+        } catch (IOException e) {
+            UI.printError(Module.IMG, "I/O error occured while writing image tile [(%d,%d) %dx%d] image for display: %s", x, y, w, h, e.getMessage());
+        }
+    }
+
+    @Override
+    public void imageFill(int x, int y, int w, int h, Color c, float alpha) {
+        if (writer == null) {
+            return;
+        }
+        Color[] colorTile = new Color[w * h];
+        float[] alphaTile = new float[w * h];
+        for (int i = 0; i < colorTile.length; i++) {
+            colorTile[i] = c;
+            alphaTile[i] = alpha;
+        }
+        imageUpdate(x, y, w, h, colorTile, alphaTile);
+    }
+
+    @Override
+    public void imageEnd() {
+        if (writer == null) {
+            return;
+        }
+        try {
+            writer.closeFile();
+        } catch (IOException e) {
+            UI.printError(Module.IMG, "I/O error occured while closing the display: %s", e.getMessage());
+        }
+    }
+}

data/src/main/java/org/sunflow/core/display/FrameDisplay.java

@@ -0,0 +1,97 @@
+package org.sunflow.core.display;
+
+import java.awt.Dimension;
+import java.awt.Toolkit;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+
+import javax.swing.JFrame;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.Display;
+import org.sunflow.image.Color;
+import org.sunflow.system.ImagePanel;
+
+public class FrameDisplay implements Display {
+
+    private String filename;
+    private RenderFrame frame;
+
+    public FrameDisplay() {
+        this(null);
+    }
+
+    public FrameDisplay(String filename) {
+        this.filename = filename;
+        frame = null;
+    }
+
+    @Override
+    public void imageBegin(int w, int h, int bucketSize) {
+        if (frame == null) {
+            frame = new RenderFrame();
+            frame.imagePanel.imageBegin(w, h, bucketSize);
+            Dimension screenRes = Toolkit.getDefaultToolkit().getScreenSize();
+            boolean needFit = false;
+            if (w >= (screenRes.getWidth() - 200) || h >= (screenRes.getHeight() - 200)) {
+                frame.imagePanel.setPreferredSize(new Dimension((int) screenRes.getWidth() - 200, (int) screenRes.getHeight() - 200));
+                needFit = true;
+            } else {
+                frame.imagePanel.setPreferredSize(new Dimension(w, h));
+            }
+            frame.pack();
+            frame.setLocationRelativeTo(null);
+            frame.setVisible(true);
+            if (needFit) {
+                frame.imagePanel.fit();
+            }
+        } else {
+            frame.imagePanel.imageBegin(w, h, bucketSize);
+        }
+    }
+
+    @Override
+    public void imagePrepare(int x, int y, int w, int h, int id) {
+        frame.imagePanel.imagePrepare(x, y, w, h, id);
+    }
+
+    @Override
+    public void imageUpdate(int x, int y, int w, int h, Color[] data, float[] alpha) {
+        frame.imagePanel.imageUpdate(x, y, w, h, data, alpha);
+    }
+
+    @Override
+    public void imageFill(int x, int y, int w, int h, Color c, float alpha) {
+        frame.imagePanel.imageFill(x, y, w, h, c, alpha);
+    }
+
+    @Override
+    public void imageEnd() {
+        frame.imagePanel.imageEnd();
+        if (filename != null) {
+            frame.imagePanel.save(filename);
+        }
+    }
+
+    @SuppressWarnings("serial")
+    private static class RenderFrame extends JFrame {
+
+        ImagePanel imagePanel;
+
+        RenderFrame() {
+            super("Sunflow v" + SunflowAPI.VERSION);
+            setDefaultCloseOperation(EXIT_ON_CLOSE);
+            addKeyListener(new KeyAdapter() {
+                @Override
+                public void keyPressed(KeyEvent e) {
+                    if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
+                        System.exit(0);
+                    }
+                }
+            });
+            imagePanel = new ImagePanel();
+            setContentPane(imagePanel);
+            pack();
+        }
+    }
+}

data/src/main/java/org/sunflow/core/display/ImgPipeDisplay.java

@@ -0,0 +1,109 @@
+package org.sunflow.core.display;
+
+import java.io.IOException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.swing.JPanel;
+
+import org.sunflow.core.Display;
+import org.sunflow.image.Color;
+
+@SuppressWarnings("serial")
+public class ImgPipeDisplay extends JPanel implements Display {
+
+    private int ih;
+
+    /**
+     * Render to stdout using the imgpipe protocol used in mental image's
+     * imf_disp viewer. http://www.lamrug.org/resources/stubtips.html
+     */
+    public ImgPipeDisplay() {
+    }
+
+    @Override
+    public synchronized void imageBegin(int w, int h, int bucketSize) {
+        ih = h;
+        outputPacket(5, w, h, Float.floatToRawIntBits(1.0f), 0);
+        System.out.flush();
+    }
+
+    @Override
+    public synchronized void imagePrepare(int x, int y, int w, int h, int id) {
+    }
+
+    @Override
+    public synchronized void imageUpdate(int x, int y, int w, int h, Color[] data, float[] alpha) {
+        int xl = x;
+        int xh = x + w - 1;
+        int yl = ih - 1 - (y + h - 1);
+        int yh = ih - 1 - y;
+        outputPacket(2, xl, xh, yl, yh);
+        byte[] rgba = new byte[4 * (yh - yl + 1) * (xh - xl + 1)];
+        for (int j = 0, idx = 0; j < h; j++) {
+            for (int i = 0; i < w; i++, idx += 4) {
+                int rgb = data[(h - j - 1) * w + i].toNonLinear().toRGB();
+                int cr = (rgb >> 16) & 0xFF;
+                int cg = (rgb >> 8) & 0xFF;
+                int cb = rgb & 0xFF;
+                rgba[idx + 0] = (byte) (cr & 0xFF);
+                rgba[idx + 1] = (byte) (cg & 0xFF);
+                rgba[idx + 2] = (byte) (cb & 0xFF);
+                rgba[idx + 3] = (byte) (0xFF);
+            }
+        }
+        try {
+            System.out.write(rgba);
+        } catch (IOException ex) {
+            Logger.getLogger(ImgPipeDisplay.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    @Override
+    public synchronized void imageFill(int x, int y, int w, int h, Color c, float alpha) {
+        int xl = x;
+        int xh = x + w - 1;
+        int yl = ih - 1 - (y + h - 1);
+        int yh = ih - 1 - y;
+        outputPacket(2, xl, xh, yl, yh);
+        int rgb = c.toNonLinear().toRGB();
+        int cr = (rgb >> 16) & 0xFF;
+        int cg = (rgb >> 8) & 0xFF;
+        int cb = rgb & 0xFF;
+        byte[] rgba = new byte[4 * (yh - yl + 1) * (xh - xl + 1)];
+        for (int j = 0, idx = 0; j < h; j++) {
+            for (int i = 0; i < w; i++, idx += 4) {
+                rgba[idx + 0] = (byte) (cr & 0xFF);
+                rgba[idx + 1] = (byte) (cg & 0xFF);
+                rgba[idx + 2] = (byte) (cb & 0xFF);
+                rgba[idx + 3] = (byte) (0xFF);
+            }
+        }
+        try {
+            System.out.write(rgba);
+        } catch (IOException ex) {
+            Logger.getLogger(ImgPipeDisplay.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    @Override
+    public synchronized void imageEnd() {
+        outputPacket(4, 0, 0, 0, 0);
+        System.out.flush();
+    }
+
+    private void outputPacket(int type, int d0, int d1, int d2, int d3) {
+        outputInt32(type);
+        outputInt32(d0);
+        outputInt32(d1);
+        outputInt32(d2);
+        outputInt32(d3);
+    }
+
+    private void outputInt32(int i) {
+        System.out.write((i >> 24) & 0xFF);
+        System.out.write((i >> 16) & 0xFF);
+        System.out.write((i >> 8) & 0xFF);
+        System.out.write(i & 0xFF);
+    }
+}

data/src/main/java/org/sunflow/core/filter/BlackmanHarrisFilter.java

@@ -0,0 +1,28 @@
+package org.sunflow.core.filter;
+
+import org.sunflow.core.Filter;
+
+public class BlackmanHarrisFilter implements Filter {
+
+    @Override
+    public float getSize() {
+        return 4.0f;
+    }
+
+    @Override
+    public float get(float x, float y) {
+        return bh1d(x * 0.5f) * bh1d(y * 0.5f);
+    }
+
+    private float bh1d(float x) {
+        if (x < -1.0f || x > 1.0f) {
+            return 0.0f;
+        }
+        x = (x + 1) * 0.5f;
+        final double A0 = 0.35875;
+        final double A1 = -0.48829;
+        final double A2 = 0.14128;
+        final double A3 = -0.01168;
+        return (float) (A0 + A1 * Math.cos(2 * Math.PI * x) + A2 * Math.cos(4 * Math.PI * x) + A3 * Math.cos(6 * Math.PI * x));
+    }
+}

data/src/main/java/org/sunflow/core/filter/BoxFilter.java

@@ -0,0 +1,16 @@
+package org.sunflow.core.filter;
+
+import org.sunflow.core.Filter;
+
+public class BoxFilter implements Filter {
+
+    @Override
+    public float getSize() {
+        return 1.0f;
+    }
+
+    @Override
+    public float get(float x, float y) {
+        return 1.0f;
+    }
+}

data/src/main/java/org/sunflow/core/filter/CatmullRomFilter.java

@@ -0,0 +1,29 @@
+package org.sunflow.core.filter;
+
+import org.sunflow.core.Filter;
+
+public class CatmullRomFilter implements Filter {
+
+    @Override
+    public float getSize() {
+        return 4.0f;
+    }
+
+    @Override
+    public float get(float x, float y) {
+        return catrom1d(x) * catrom1d(y);
+    }
+
+    private float catrom1d(float x) {
+        x = Math.abs(x);
+        float x2 = x * x;
+        float x3 = x * x2;
+        if (x >= 2) {
+            return 0;
+        }
+        if (x < 1) {
+            return 3 * x3 - 5 * x2 + 2;
+        }
+        return -x3 + 5 * x2 - 8 * x + 4;
+    }
+}

data/src/main/java/org/sunflow/core/filter/CubicBSpline.java

@@ -0,0 +1,32 @@
+package org.sunflow.core.filter;
+
+import org.sunflow.core.Filter;
+
+public class CubicBSpline implements Filter {
+
+    @Override
+    public float get(float x, float y) {
+        return B3(x) * B3(y);
+    }
+
+    @Override
+    public float getSize() {
+        return 4.0f;
+    }
+
+    private float B3(float t) {
+        t = Math.abs(t);
+        if (t <= 1) {
+            return b1(1 - t);
+        }
+        return b0(2 - t);
+    }
+
+    private float b0(float t) {
+        return t * t * t * (1.0f / 6);
+    }
+
+    private float b1(float t) {
+        return (1.0f / 6) * (-3 * t * t * t + 3 * t * t + 3 * t + 1);
+    }
+}

data/src/main/java/org/sunflow/core/filter/GaussianFilter.java

@@ -0,0 +1,24 @@
+package org.sunflow.core.filter;
+
+import org.sunflow.core.Filter;
+
+public class GaussianFilter implements Filter {
+
+    private float es2;
+
+    public GaussianFilter() {
+        es2 = (float) -Math.exp(-getSize() * getSize());
+    }
+
+    @Override
+    public final float getSize() {
+        return 3.0f;
+    }
+
+    @Override
+    public float get(float x, float y) {
+        float gx = (float) Math.exp(-x * x) + es2;
+        float gy = (float) Math.exp(-y * y) + es2;
+        return gx * gy;
+    }
+}

data/src/main/java/org/sunflow/core/filter/LanczosFilter.java

@@ -0,0 +1,30 @@
+package org.sunflow.core.filter;
+
+import org.sunflow.core.Filter;
+
+public class LanczosFilter implements Filter {
+
+    @Override
+    public float getSize() {
+        return 4.0f;
+    }
+
+    @Override
+    public float get(float x, float y) {
+        return sinc1d(x * 0.5f) * sinc1d(y * 0.5f);
+    }
+
+    private float sinc1d(float x) {
+        x = Math.abs(x);
+        if (x < 1e-5f) {
+            return 1;
+        }
+        if (x > 1.0f) {
+            return 0;
+        }
+        x *= Math.PI;
+        float sinc = (float) Math.sin(3 * x) / (3 * x);
+        float lanczos = (float) Math.sin(x) / x;
+        return sinc * lanczos;
+    }
+}