bundles/org.simantics.scenegraph/src/org/simantics/scenegraph/utils/MipMapVRamBufferedImage.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
   3  * in Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.scenegraph.utils;
  13
  14 import java.awt.Color;
  15 import java.awt.Graphics2D;
  16 import java.awt.GraphicsConfiguration;
  17 import java.awt.Point;
  18 import java.awt.RenderingHints;
  19 import java.awt.geom.AffineTransform;
  20 import java.awt.geom.Rectangle2D;
  21 import java.awt.image.VolatileImage;
  22 import java.util.concurrent.atomic.AtomicInteger;
  23
  24 import com.kitfox.svg.SVGDiagram;
  25
  26 /**
  27  * Video-ram cache suitable for rasterized PaintableSymbols scalable vector graphics.
  28  * <p>
  29  * This implementation rasterizes the same symbol from different mip map levels.
  30  *
  31  * @see VRamImage
  32  * @author Toni Kalajainen
  33  */
  34 public class MipMapVRamBufferedImage extends MipMapBufferedImage {
  35
  36     /**
  37      * @param original
  38      * @param imageBounds
  39      * @param referenceSize a reference size for the rasterized images or
  40      *        <code>null</code> to not specify one in which case a default
  41      *        resolution is used
  42      * @param gc
  43      */
  44     public MipMapVRamBufferedImage(SVGDiagram original, Rectangle2D imageBounds, Point referenceSize)
  45     {
  46         super(original, imageBounds, referenceSize);
  47     }
  48
  49     @Override
  50     protected IRaster createRaster(double resolution) {
  51         return new VolatileRaster(resolution);
  52     }
  53
  54     @Override
  55     protected double getRasterRenderingThresholdResolution() {
  56         return maxResolution*1.5;
  57     }
  58
  59     @Override
  60     protected void setupSourceRender(Graphics2D g2d) {
  61 //        g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
  62 //        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
  63 //        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
  64 //        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
  65 //        g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
  66 //        g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
  67
  68         g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
  69         g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
  70         g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
  71         g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
  72         g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
  73         g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
  74     }
  75
  76     class VolatileRaster extends Raster {
  77         VolatileImageProvider imageProvider;
  78         int widMargin, heiMargin;
  79         int wid, hei;
  80         AtomicInteger validateResult = new AtomicInteger(VolatileImage.IMAGE_OK);
  81
  82         public VolatileRaster(double resolution) {
  83             super(resolution);
  84             double wid = imageBounds.getWidth();
  85             double hei = imageBounds.getHeight();
  86             this.wid = (int) (wid * resolution);
  87             this.hei = (int) (hei * resolution);
  88             widMargin = (int) (wid * resolution * (MARGIN_PERCENT/100)) +1;
  89             heiMargin = (int) (hei * resolution * (MARGIN_PERCENT/100)) +1;
  90             imageProvider = VolatileImageCache.getInstance().create(this.wid+widMargin*2, this.hei+heiMargin*2);
  91             //System.out.println("VolatileRaster(" + resolution + "): " + this.wid + " x " + this.hei);
  92         }
  93
  94         /**
  95          * @param image
  96          * @return
  97          */
  98         private VolatileImage sourceRender(VolatileImage image) {
  99             Graphics2D target = image.createGraphics();
 100             target.setBackground(new Color(255,255,255,0));
 101             target.clearRect(0, 0, image.getWidth(), image.getHeight());
 102
 103             target.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
 104             target.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 105             target.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
 106             target.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
 107
 108             target.translate(widMargin, heiMargin);
 109             target.scale(resolution, resolution);
 110             target.translate(-imageBounds.getMinX(), -imageBounds.getMinY());
 111             try {
 112                 source.render(target);
 113             } catch (Exception e) {
 114                 e.printStackTrace();
 115                 target.dispose();
 116                 image = null;
 117                 return null;
 118             }
 119             target.dispose();
 120             //JAI.create("filestore", image.getSnapshot(), "d:/test" + (koss++) + ".png", "png");
 121             return image;
 122         }
 123
 124         synchronized VolatileImage restore(GraphicsConfiguration gc2) {
 125             //System.out.println("restoring provider " + imageProvider);
 126             VolatileImage image = imageProvider.get(gc2, this.validateResult);
 127
 128             // If a new image was created, we always need to render from source.
 129             int validateResult = this.validateResult.get();
 130             //System.out.println("got VolatileImage " + image + " (validation result=" + validated + ")");
 131
 132             // Couldn't get image? This is not supposed to happen but happened anyway.
 133             if (image == null) {
 134                 System.err.println("BUG: VolatileImageProvider.get returned null!");
 135                 return null;
 136             }
 137
 138 //            if (validateResult != VolatileImage.IMAGE_OK) {
 139 //                System.out.println("NEED SOURCE RENDER FOR VOLATILE IMAGE PROVIDER " + imageProvider + " - " + image);
 140 //            }
 141
 142             boolean contentsLost = validateResult != VolatileImage.IMAGE_OK || image.contentsLost();
 143             return contentsLost ? sourceRender(image) : image;
 144             //return contentsLost ? sourceRender(image) : sourceRender(image);
 145         }
 146
 147         public void paint(Graphics2D g) {
 148             VolatileImage image = restore(g.getDeviceConfiguration());
 149             if (image==null)
 150             {
 151                 g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
 152                 g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
 153                 g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
 154                 g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
 155
 156                 try {
 157                     source.render(g);
 158                 } catch (Exception e) {
 159                     // TODO Auto-generated catch block
 160                     // NOTE: Catching Exception instead of SVGException due to an
 161                     // NPE when encountering invalid color SVG definitions (e.g.
 162                     // rgb(256,-1,0))
 163                     e.printStackTrace();
 164                 }
 165                 return;
 166             }
 167             AffineTransform af = g.getTransform();
 168             Object rh = g.getRenderingHint(RenderingHints.KEY_INTERPOLATION);
 169             try {
 170                 /// Bicubic interpolation is very slow with opengl pipeline
 171                 if (rh == RenderingHints.VALUE_INTERPOLATION_BICUBIC)
 172                     g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
 173                 g.translate(imageBounds.getMinX(), imageBounds.getMinY());
 174                 g.scale(1/resolution, 1/resolution);
 175                 g.translate(-widMargin, -heiMargin);
 176                 g.drawImage(image, 0, 0, null);
 177             } finally {
 178                 g.setTransform(af);
 179                 g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, rh);
 180             }
 181         }
 182
 183         public void release() {
 184             imageProvider.dispose();
 185         }
 186     }
 187
 188     //static long koss = 0;
 189
 190     /*
 191     @Override
 192     public int hashCode() {
 193         return gc.hashCode() ^original.hashCode();
 194     }
 195
 196     @Override
 197     public boolean equals(Object obj) {
 198         if (!(obj instanceof VRamBufferedImage)) return false;
 199         VRamBufferedImage o = (VRamBufferedImage) obj;
 200         return o.gc == gc && o.original.equals(original);
 201     }
 202      */
 203
 204 }