-/*******************************************************************************\r
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
- * in Industry THTH ry.\r
- * All rights reserved. This program and the accompanying materials\r
- * are made available under the terms of the Eclipse Public License v1.0\r
- * which accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- *\r
- * Contributors:\r
- * VTT Technical Research Centre of Finland - initial API and implementation\r
- *******************************************************************************/\r
-package org.simantics.scenegraph.utils;\r
-\r
-import java.awt.Color;\r
-import java.awt.Graphics2D;\r
-import java.awt.GraphicsConfiguration;\r
-import java.awt.Point;\r
-import java.awt.RenderingHints;\r
-import java.awt.geom.AffineTransform;\r
-import java.awt.geom.Rectangle2D;\r
-import java.awt.image.VolatileImage;\r
-import java.util.concurrent.atomic.AtomicInteger;\r
-\r
-import com.kitfox.svg.SVGDiagram;\r
-\r
-/**\r
- * Video-ram cache suitable for rasterized PaintableSymbols scalable vector graphics.\r
- * <p>\r
- * This implementation rasterizes the same symbol from different mip map levels.\r
- * \r
- * @see VRamImage\r
- * @author Toni Kalajainen\r
- */\r
-public class MipMapVRamBufferedImage extends MipMapBufferedImage {\r
-\r
- /**\r
- * @param original\r
- * @param imageBounds\r
- * @param referenceSize a reference size for the rasterized images or\r
- * <code>null</code> to not specify one in which case a default\r
- * resolution is used\r
- * @param gc\r
- */\r
- public MipMapVRamBufferedImage(SVGDiagram original, Rectangle2D imageBounds, Point referenceSize)\r
- {\r
- super(original, imageBounds, referenceSize);\r
- }\r
-\r
- @Override\r
- protected IRaster createRaster(double resolution) {\r
- return new VolatileRaster(resolution);\r
- }\r
-\r
- @Override\r
- protected double getRasterRenderingThresholdResolution() {\r
- return maxResolution*1.5;\r
- }\r
-\r
- @Override\r
- protected void setupSourceRender(Graphics2D g2d) {\r
-// g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);\r
-// g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);\r
-// g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);\r
-// g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);\r
-// g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);\r
-// g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);\r
-\r
- g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);\r
- g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);\r
- g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);\r
- g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);\r
- g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);\r
- g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);\r
- }\r
-\r
- class VolatileRaster extends Raster {\r
- VolatileImageProvider imageProvider;\r
- int widMargin, heiMargin;\r
- int wid, hei;\r
- AtomicInteger validateResult = new AtomicInteger(VolatileImage.IMAGE_OK);\r
-\r
- public VolatileRaster(double resolution) {\r
- super(resolution);\r
- double wid = imageBounds.getWidth();\r
- double hei = imageBounds.getHeight();\r
- this.wid = (int) (wid * resolution);\r
- this.hei = (int) (hei * resolution);\r
- widMargin = (int) (wid * resolution * (MARGIN_PERCENT/100)) +1;\r
- heiMargin = (int) (hei * resolution * (MARGIN_PERCENT/100)) +1;\r
- imageProvider = VolatileImageCache.getInstance().create(this.wid+widMargin*2, this.hei+heiMargin*2);\r
- //System.out.println("VolatileRaster(" + resolution + "): " + this.wid + " x " + this.hei);\r
- }\r
-\r
- /**\r
- * @param image\r
- * @return\r
- */\r
- private VolatileImage sourceRender(VolatileImage image) {\r
- Graphics2D target = image.createGraphics();\r
- target.setBackground(new Color(255,255,255,0));\r
- target.clearRect(0, 0, image.getWidth(), image.getHeight());\r
-\r
- target.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);\r
- target.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);\r
- target.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);\r
- target.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);\r
-\r
- target.translate(widMargin, heiMargin);\r
- target.scale(resolution, resolution);\r
- target.translate(-imageBounds.getMinX(), -imageBounds.getMinY());\r
- try {\r
- source.render(target);\r
- } catch (Exception e) {\r
- e.printStackTrace();\r
- target.dispose();\r
- image = null;\r
- return null;\r
- }\r
- target.dispose();\r
- //JAI.create("filestore", image.getSnapshot(), "d:/test" + (koss++) + ".png", "png");\r
- return image;\r
- }\r
-\r
- synchronized VolatileImage restore(GraphicsConfiguration gc2) {\r
- //System.out.println("restoring provider " + imageProvider);\r
- VolatileImage image = imageProvider.get(gc2, this.validateResult);\r
-\r
- // If a new image was created, we always need to render from source.\r
- int validateResult = this.validateResult.get();\r
- //System.out.println("got VolatileImage " + image + " (validation result=" + validated + ")");\r
-\r
- // Couldn't get image? This is not supposed to happen but happened anyway.\r
- if (image == null) {\r
- System.err.println("BUG: VolatileImageProvider.get returned null!");\r
- return null;\r
- }\r
-\r
-// if (validateResult != VolatileImage.IMAGE_OK) {\r
-// System.out.println("NEED SOURCE RENDER FOR VOLATILE IMAGE PROVIDER " + imageProvider + " - " + image);\r
-// }\r
-\r
- boolean contentsLost = validateResult != VolatileImage.IMAGE_OK || image.contentsLost();\r
- return contentsLost ? sourceRender(image) : image;\r
- //return contentsLost ? sourceRender(image) : sourceRender(image);\r
- }\r
-\r
- public void paint(Graphics2D g) {\r
- VolatileImage image = restore(g.getDeviceConfiguration());\r
- if (image==null)\r
- {\r
- g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);\r
- g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);\r
- g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);\r
- g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);\r
-\r
- try {\r
- source.render(g);\r
- } catch (Exception e) {\r
- // TODO Auto-generated catch block\r
- // NOTE: Catching Exception instead of SVGException due to an\r
- // NPE when encountering invalid color SVG definitions (e.g.\r
- // rgb(256,-1,0))\r
- e.printStackTrace();\r
- }\r
- return;\r
- }\r
- AffineTransform af = g.getTransform();\r
- Object rh = g.getRenderingHint(RenderingHints.KEY_INTERPOLATION);\r
- try {\r
- /// Bicubic interpolation is very slow with opengl pipeline\r
- if (rh == RenderingHints.VALUE_INTERPOLATION_BICUBIC)\r
- g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);\r
- g.translate(imageBounds.getMinX(), imageBounds.getMinY());\r
- g.scale(1/resolution, 1/resolution);\r
- g.translate(-widMargin, -heiMargin);\r
- g.drawImage(image, 0, 0, null);\r
- } finally {\r
- g.setTransform(af);\r
- g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, rh);\r
- }\r
- }\r
-\r
- public void release() {\r
- imageProvider.dispose();\r
- }\r
- }\r
-\r
- //static long koss = 0;\r
-\r
- /*\r
- @Override\r
- public int hashCode() {\r
- return gc.hashCode() ^original.hashCode();\r
- }\r
-\r
- @Override\r
- public boolean equals(Object obj) {\r
- if (!(obj instanceof VRamBufferedImage)) return false;\r
- VRamBufferedImage o = (VRamBufferedImage) obj;\r
- return o.gc == gc && o.original.equals(original);\r
- }\r
- */\r
-\r
-}\r
+/*******************************************************************************
+ * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.scenegraph.utils;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.GraphicsConfiguration;
+import java.awt.Point;
+import java.awt.RenderingHints;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.VolatileImage;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import com.kitfox.svg.SVGDiagram;
+
+/**
+ * Video-ram cache suitable for rasterized PaintableSymbols scalable vector graphics.
+ * <p>
+ * This implementation rasterizes the same symbol from different mip map levels.
+ *
+ * @see VRamImage
+ * @author Toni Kalajainen
+ */
+public class MipMapVRamBufferedImage extends MipMapBufferedImage {
+
+ /**
+ * @param original
+ * @param imageBounds
+ * @param referenceSize a reference size for the rasterized images or
+ * <code>null</code> to not specify one in which case a default
+ * resolution is used
+ * @param gc
+ */
+ public MipMapVRamBufferedImage(SVGDiagram original, Rectangle2D imageBounds, Point referenceSize)
+ {
+ super(original, imageBounds, referenceSize);
+ }
+
+ @Override
+ protected IRaster createRaster(double resolution) {
+ return new VolatileRaster(resolution);
+ }
+
+ @Override
+ protected double getRasterRenderingThresholdResolution() {
+ return maxResolution*1.5;
+ }
+
+ @Override
+ protected void setupSourceRender(Graphics2D g2d) {
+// g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
+// g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
+// g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+// g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+// g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+// g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
+
+ g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
+ g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+ g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
+ g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+ g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+ g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
+ }
+
+ class VolatileRaster extends Raster {
+ VolatileImageProvider imageProvider;
+ int widMargin, heiMargin;
+ int wid, hei;
+ AtomicInteger validateResult = new AtomicInteger(VolatileImage.IMAGE_OK);
+
+ public VolatileRaster(double resolution) {
+ super(resolution);
+ double wid = imageBounds.getWidth();
+ double hei = imageBounds.getHeight();
+ this.wid = (int) (wid * resolution);
+ this.hei = (int) (hei * resolution);
+ widMargin = (int) (wid * resolution * (MARGIN_PERCENT/100)) +1;
+ heiMargin = (int) (hei * resolution * (MARGIN_PERCENT/100)) +1;
+ imageProvider = VolatileImageCache.getInstance().create(this.wid+widMargin*2, this.hei+heiMargin*2);
+ //System.out.println("VolatileRaster(" + resolution + "): " + this.wid + " x " + this.hei);
+ }
+
+ /**
+ * @param image
+ * @return
+ */
+ private VolatileImage sourceRender(VolatileImage image) {
+ Graphics2D target = image.createGraphics();
+ target.setBackground(new Color(255,255,255,0));
+ target.clearRect(0, 0, image.getWidth(), image.getHeight());
+
+ target.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+ target.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+ target.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+ target.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
+
+ target.translate(widMargin, heiMargin);
+ target.scale(resolution, resolution);
+ target.translate(-imageBounds.getMinX(), -imageBounds.getMinY());
+ try {
+ source.render(target);
+ } catch (Exception e) {
+ e.printStackTrace();
+ target.dispose();
+ image = null;
+ return null;
+ }
+ target.dispose();
+ //JAI.create("filestore", image.getSnapshot(), "d:/test" + (koss++) + ".png", "png");
+ return image;
+ }
+
+ synchronized VolatileImage restore(GraphicsConfiguration gc2) {
+ //System.out.println("restoring provider " + imageProvider);
+ VolatileImage image = imageProvider.get(gc2, this.validateResult);
+
+ // If a new image was created, we always need to render from source.
+ int validateResult = this.validateResult.get();
+ //System.out.println("got VolatileImage " + image + " (validation result=" + validated + ")");
+
+ // Couldn't get image? This is not supposed to happen but happened anyway.
+ if (image == null) {
+ System.err.println("BUG: VolatileImageProvider.get returned null!");
+ return null;
+ }
+
+// if (validateResult != VolatileImage.IMAGE_OK) {
+// System.out.println("NEED SOURCE RENDER FOR VOLATILE IMAGE PROVIDER " + imageProvider + " - " + image);
+// }
+
+ boolean contentsLost = validateResult != VolatileImage.IMAGE_OK || image.contentsLost();
+ return contentsLost ? sourceRender(image) : image;
+ //return contentsLost ? sourceRender(image) : sourceRender(image);
+ }
+
+ public void paint(Graphics2D g) {
+ VolatileImage image = restore(g.getDeviceConfiguration());
+ if (image==null)
+ {
+ g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
+ g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
+ g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+ g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
+
+ try {
+ source.render(g);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ // NOTE: Catching Exception instead of SVGException due to an
+ // NPE when encountering invalid color SVG definitions (e.g.
+ // rgb(256,-1,0))
+ e.printStackTrace();
+ }
+ return;
+ }
+ AffineTransform af = g.getTransform();
+ Object rh = g.getRenderingHint(RenderingHints.KEY_INTERPOLATION);
+ try {
+ /// Bicubic interpolation is very slow with opengl pipeline
+ if (rh == RenderingHints.VALUE_INTERPOLATION_BICUBIC)
+ g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+ g.translate(imageBounds.getMinX(), imageBounds.getMinY());
+ g.scale(1/resolution, 1/resolution);
+ g.translate(-widMargin, -heiMargin);
+ g.drawImage(image, 0, 0, null);
+ } finally {
+ g.setTransform(af);
+ g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, rh);
+ }
+ }
+
+ public void release() {
+ imageProvider.dispose();
+ }
+ }
+
+ //static long koss = 0;
+
+ /*
+ @Override
+ public int hashCode() {
+ return gc.hashCode() ^original.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (!(obj instanceof VRamBufferedImage)) return false;
+ VRamBufferedImage o = (VRamBufferedImage) obj;
+ return o.gc == gc && o.original.equals(original);
+ }
+ */
+
+}
Code Review / simantics / platform.git / blobdiff