Changeset 10547 in josm for trunk/src/org/openstreetmap/josm/gui/layer/ImageryLayer.java

Timestamp:

2016-07-17T13:07:14+02:00 (8 years ago)

Author:

Don-vip

Message:

fix #13159 - Move image processors out of imagery layer (patch by michael2402) - gsoc-core + fix checkstyle violations

File:

• trunk/src/org/openstreetmap/josm/gui/layer/ImageryLayer.java (modified) (5 diffs)

trunk/src/org/openstreetmap/josm/gui/layer/ImageryLayer.java

@@ -9 +9 @@
 import java.awt.Component;
 import java.awt.GridBagLayout;
-import java.awt.Rectangle;
-import java.awt.RenderingHints;
-import java.awt.Transparency;
 import java.awt.event.ActionEvent;
-import java.awt.geom.Point2D;
-import java.awt.geom.Rectangle2D;
 import java.awt.image.BufferedImage;
 import java.awt.image.BufferedImageOp;
-import java.awt.image.ColorModel;
-import java.awt.image.ConvolveOp;
-import java.awt.image.DataBuffer;
-import java.awt.image.DataBufferByte;
-import java.awt.image.Kernel;
-import java.awt.image.LookupOp;
-import java.awt.image.ShortLookupTable;
 import java.util.ArrayList;
 import java.util.List;
@@ -46 +34 @@
 import org.openstreetmap.josm.data.preferences.IntegerProperty;
 import org.openstreetmap.josm.gui.MenuScroller;
+import org.openstreetmap.josm.gui.layer.imagery.ImageryFilterSettings;
 import org.openstreetmap.josm.gui.widgets.UrlLabel;
 import org.openstreetmap.josm.tools.GBC;
@@ -76 +65 @@
     protected double dy;
 
-    protected GammaImageProcessor gammaImageProcessor = new GammaImageProcessor();
-    protected SharpenImageProcessor sharpenImageProcessor = new SharpenImageProcessor();
-    protected ColorfulImageProcessor collorfulnessImageProcessor = new ColorfulImageProcessor();
-
     private final ImageryAdjustAction adjustAction = new ImageryAdjustAction(this);
+
+    private final ImageryFilterSettings filterSettings = new ImageryFilterSettings();
 
     /**
@@ -96 +83 @@
             icon = ImageProvider.get("imagery_small");
         }
-        addImageProcessor(collorfulnessImageProcessor);
-        addImageProcessor(gammaImageProcessor);
-        addImageProcessor(sharpenImageProcessor);
-        sharpenImageProcessor.setSharpenLevel(1 + PROP_SHARPEN_LEVEL.get() / 2f);
+        for (ImageProcessor processor : filterSettings.getProcessors()) {
+            addImageProcessor(processor);
+        }
+        filterSettings.setSharpenLevel(1 + PROP_SHARPEN_LEVEL.get() / 2f);
     }
 
@@ -259 +246 @@
 
     /**
-     * An image processor which adjusts the gamma value of an image.
-     */
-    public static class GammaImageProcessor implements ImageProcessor {
-        private double gamma = 1;
-        final short[] gammaChange = new short[256];
-        private final LookupOp op3 = new LookupOp(
-                new ShortLookupTable(0, new short[][]{gammaChange, gammaChange, gammaChange}), null);
-        private final LookupOp op4 = new LookupOp(
-                new ShortLookupTable(0, new short[][]{gammaChange, gammaChange, gammaChange, gammaChange}), null);
-
-        /**
-         * Returns the currently set gamma value.
-         * @return the currently set gamma value
-         */
-        public double getGamma() {
-            return gamma;
-        }
-
-        /**
-         * Sets a new gamma value, {@code 1} stands for no correction.
-         * @param gamma new gamma value
-         */
-        public void setGamma(double gamma) {
-            this.gamma = gamma;
-            for (int i = 0; i < 256; i++) {
-                gammaChange[i] = (short) (255 * Math.pow(i / 255., gamma));
-            }
-        }
-
-        @Override
-        public BufferedImage process(BufferedImage image) {
-            if (gamma == 1) {
-                return image;
-            }
-            try {
-                final int bands = image.getRaster().getNumBands();
-                if (image.getType() != BufferedImage.TYPE_CUSTOM && bands == 3) {
-                    return op3.filter(image, null);
-                } else if (image.getType() != BufferedImage.TYPE_CUSTOM && bands == 4) {
-                    return op4.filter(image, null);
-                }
-            } catch (IllegalArgumentException ignore) {
-                Main.trace(ignore);
-            }
-            final int type = image.getTransparency() == Transparency.OPAQUE ? BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
-            final BufferedImage to = new BufferedImage(image.getWidth(), image.getHeight(), type);
-            to.getGraphics().drawImage(image, 0, 0, null);
-            return process(to);
-        }
-
-        @Override
-        public String toString() {
-            return "GammaImageProcessor [gamma=" + gamma + ']';
-        }
-    }
-
-    /**
-     * Sharpens or blurs the image, depending on the sharpen value.
-     * <p>
-     * A positive sharpen level means that we sharpen the image.
-     * <p>
-     * A negative sharpen level let's us blur the image. -1 is the most useful value there.
-     *
-     * @author Michael Zangl
-     */
-    public static class SharpenImageProcessor implements ImageProcessor {
-        private float sharpenLevel;
-        private ConvolveOp op;
-
-        private static float[] KERNEL_IDENTITY = new float[] {
-            0, 0, 0,
-            0, 1, 0,
-            0, 0, 0
-        };
-
-        private static float[] KERNEL_BLUR = new float[] {
-            1f / 16, 2f / 16, 1f / 16,
-            2f / 16, 4f / 16, 2f / 16,
-            1f / 16, 2f / 16, 1f / 16
-        };
-
-        private static float[] KERNEL_SHARPEN = new float[] {
-            -.5f, -1f, -.5f,
-             -1f, 7, -1f,
-            -.5f, -1f, -.5f
-        };
-
-        /**
-         * Gets the current sharpen level.
-         * @return The level.
-         */
-        public float getSharpenLevel() {
-            return sharpenLevel;
-        }
-
-        /**
-         * Sets the sharpening level.
-         * @param sharpenLevel The level. Clamped to be positive or 0.
-         */
-        public void setSharpenLevel(float sharpenLevel) {
-            if (sharpenLevel < 0) {
-                this.sharpenLevel = 0;
-            } else {
-                this.sharpenLevel = sharpenLevel;
-            }
-
-            if (this.sharpenLevel < 0.95) {
-                op = generateMixed(this.sharpenLevel, KERNEL_IDENTITY, KERNEL_BLUR);
-            } else if (this.sharpenLevel > 1.05) {
-                op = generateMixed(this.sharpenLevel - 1, KERNEL_SHARPEN, KERNEL_IDENTITY);
-            } else {
-                op = null;
-            }
-        }
-
-        private ConvolveOp generateMixed(float aFactor, float[] a, float[] b) {
-            if (a.length != 9 || b.length != 9) {
-                throw new IllegalArgumentException("Illegal kernel array length.");
-            }
-            float[] values = new float[9];
-            for (int i = 0; i < values.length; i++) {
-                values[i] = aFactor * a[i] + (1 - aFactor) * b[i];
-            }
-            return new ConvolveOp(new Kernel(3, 3, values), ConvolveOp.EDGE_NO_OP, null);
-        }
-
-        @Override
-        public BufferedImage process(BufferedImage image) {
-            if (op != null) {
-                return op.filter(image, null);
-            } else {
-                return image;
-            }
-        }
-
-        @Override
-        public String toString() {
-            return "SharpenImageProcessor [sharpenLevel=" + sharpenLevel + ']';
-        }
-    }
-
-    /**
-     * Adds or removes the colorfulness of the image.
-     *
-     * @author Michael Zangl
-     */
-    public static class ColorfulImageProcessor implements ImageProcessor {
-        private ColorfulFilter op;
-        private double colorfulness = 1;
-
-        /**
-         * Gets the colorfulness value.
-         * @return The value
-         */
-        public double getColorfulness() {
-            return colorfulness;
-        }
-
-        /**
-         * Sets the colorfulness value. Clamps it to 0+
-         * @param colorfulness The value
-         */
-        public void setColorfulness(double colorfulness) {
-            if (colorfulness < 0) {
-                this.colorfulness = 0;
-            } else {
-                this.colorfulness = colorfulness;
-            }
-
-            if (this.colorfulness < .95 || this.colorfulness > 1.05) {
-                op = new ColorfulFilter(this.colorfulness);
-            } else {
-                op = null;
-            }
-        }
-
-        @Override
-        public BufferedImage process(BufferedImage image) {
-            if (op != null) {
-                return op.filter(image, null);
-            } else {
-                return image;
-            }
-        }
-
-        @Override
-        public String toString() {
-            return "ColorfulImageProcessor [colorfulness=" + colorfulness + ']';
-        }
-    }
-
-    private static class ColorfulFilter implements BufferedImageOp {
-        private final double colorfulness;
-
-        /**
-         * Create a new colorful filter.
-         * @param colorfulness The colorfulness as defined in the {@link ColorfulImageProcessor} class.
-         */
-        ColorfulFilter(double colorfulness) {
-            this.colorfulness = colorfulness;
-        }
-
-        @Override
-        public BufferedImage filter(BufferedImage src, BufferedImage dest) {
-            if (src.getWidth() == 0 || src.getHeight() == 0) {
-                return src;
-            }
-
-            if (dest == null) {
-                dest = createCompatibleDestImage(src, null);
-            }
-            DataBuffer srcBuffer = src.getRaster().getDataBuffer();
-            DataBuffer destBuffer = dest.getRaster().getDataBuffer();
-            if (!(srcBuffer instanceof DataBufferByte) || !(destBuffer instanceof DataBufferByte)) {
-                Main.trace("Cannot apply color filter: Images do not use DataBufferByte.");
-                return src;
-            }
-
-            int type = src.getType();
-            if (type != dest.getType()) {
-                Main.trace("Cannot apply color filter: Src / Dest differ in type (" + type + '/' + dest.getType() + ')');
-                return src;
-            }
-            int redOffset, greenOffset, blueOffset, alphaOffset = 0;
-            switch (type) {
-            case BufferedImage.TYPE_3BYTE_BGR:
-                blueOffset = 0;
-                greenOffset = 1;
-                redOffset = 2;
-                break;
-            case BufferedImage.TYPE_4BYTE_ABGR:
-            case BufferedImage.TYPE_4BYTE_ABGR_PRE:
-                blueOffset = 1;
-                greenOffset = 2;
-                redOffset = 3;
-                break;
-            case BufferedImage.TYPE_INT_ARGB:
-            case BufferedImage.TYPE_INT_ARGB_PRE:
-                redOffset = 0;
-                greenOffset = 1;
-                blueOffset = 2;
-                alphaOffset = 3;
-                break;
-            default:
-                Main.trace("Cannot apply color filter: Source image is of wrong type (" + type + ").");
-                return src;
-            }
-            doFilter((DataBufferByte) srcBuffer, (DataBufferByte) destBuffer, redOffset, greenOffset, blueOffset,
-                    alphaOffset, src.getAlphaRaster() != null);
-            return dest;
-        }
-
-        private void doFilter(DataBufferByte src, DataBufferByte dest, int redOffset, int greenOffset, int blueOffset,
-                int alphaOffset, boolean hasAlpha) {
-            byte[] srcPixels = src.getData();
-            byte[] destPixels = dest.getData();
-            if (srcPixels.length != destPixels.length) {
-                Main.trace("Cannot apply color filter: Source/Dest lengths differ.");
-                return;
-            }
-            int entries = hasAlpha ? 4 : 3;
-            for (int i = 0; i < srcPixels.length; i += entries) {
-                int r = srcPixels[i + redOffset] & 0xff;
-                int g = srcPixels[i + greenOffset] & 0xff;
-                int b = srcPixels[i + blueOffset] & 0xff;
-                double luminosity = r * .21d + g * .72d + b * .07d;
-                destPixels[i + redOffset] = mix(r, luminosity);
-                destPixels[i + greenOffset] = mix(g, luminosity);
-                destPixels[i + blueOffset] = mix(b, luminosity);
-                if (hasAlpha) {
-                    destPixels[i + alphaOffset] = srcPixels[i + alphaOffset];
-                }
-            }
-        }
-
-        private byte mix(int color, double luminosity) {
-            int val = (int) (colorfulness * color + (1 - colorfulness) * luminosity);
-            if (val < 0) {
-                return 0;
-            } else if (val > 0xff) {
-                return (byte) 0xff;
-            } else {
-                return (byte) val;
-            }
-        }
-
-        @Override
-        public Rectangle2D getBounds2D(BufferedImage src) {
-            return new Rectangle(src.getWidth(), src.getHeight());
-        }
-
-        @Override
-        public BufferedImage createCompatibleDestImage(BufferedImage src, ColorModel destCM) {
-            return new BufferedImage(src.getWidth(), src.getHeight(), src.getType());
-        }
-
-        @Override
-        public Point2D getPoint2D(Point2D srcPt, Point2D dstPt) {
-            return (Point2D) srcPt.clone();
-        }
-
-        @Override
-        public RenderingHints getRenderingHints() {
-            return null;
-        }
-
-    }
-
-    /**
-     * Returns the currently set gamma value.
-     * @return the currently set gamma value
-     */
-    public double getGamma() {
-        return gammaImageProcessor.getGamma();
-    }
-
-    /**
-     * Sets a new gamma value, {@code 1} stands for no correction.
-     * @param gamma new gamma value
-     */
-    public void setGamma(double gamma) {
-        gammaImageProcessor.setGamma(gamma);
-    }
-
-    /**
-     * Gets the current sharpen level.
-     * @return The sharpen level.
-     */
-    public double getSharpenLevel() {
-        return sharpenImageProcessor.getSharpenLevel();
-    }
-
-    /**
-     * Sets the sharpen level for the layer.
-     * <code>1</code> means no change in sharpness.
-     * Values in range 0..1 blur the image.
-     * Values above 1 are used to sharpen the image.
-     * @param sharpenLevel The sharpen level.
-     */
-    public void setSharpenLevel(double sharpenLevel) {
-        sharpenImageProcessor.setSharpenLevel((float) sharpenLevel);
-    }
-
-    /**
-     * Gets the colorfulness of this image.
-     * @return The colorfulness
-     */
-    public double getColorfulness() {
-        return collorfulnessImageProcessor.getColorfulness();
-    }
-
-    /**
-     * Sets the colorfulness of this image.
-     * 0 means grayscale.
-     * 1 means normal colorfulness.
-     * Values greater than 1 are allowed.
-     * @param colorfulness The colorfulness.
-     */
-    public void setColorfulness(double colorfulness) {
-        collorfulnessImageProcessor.setColorfulness(colorfulness);
+     * Gets the settings for the filter that is applied to this layer.
+     * @return The filter settings.
+     * @since 10547
+     */
+    public ImageryFilterSettings getFilterSettings() {
+        return filterSettings;
     }