001 //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/graphics/BlurImage.java $
002 /*----------------------------------------------------------------------------
003 This file is part of deegree, http://deegree.org/
004 Copyright (C) 2001-2009 by:
005 Department of Geography, University of Bonn
006 and
007 lat/lon GmbH
008
009 This library is free software; you can redistribute it and/or modify it under
010 the terms of the GNU Lesser General Public License as published by the Free
011 Software Foundation; either version 2.1 of the License, or (at your option)
012 any later version.
013 This library is distributed in the hope that it will be useful, but WITHOUT
014 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016 details.
017 You should have received a copy of the GNU Lesser General Public License
018 along with this library; if not, write to the Free Software Foundation, Inc.,
019 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020
021 Contact information:
022
023 lat/lon GmbH
024 Aennchenstr. 19, 53177 Bonn
025 Germany
026 http://lat-lon.de/
027
028 Department of Geography, University of Bonn
029 Prof. Dr. Klaus Greve
030 Postfach 1147, 53001 Bonn
031 Germany
032 http://www.geographie.uni-bonn.de/deegree/
033
034 e-mail: info@deegree.org
035 ----------------------------------------------------------------------------*/
036
037 package org.deegree.graphics;
038
039 import java.awt.AlphaComposite;
040 import java.awt.Composite;
041 import java.awt.Graphics2D;
042 import java.awt.Polygon;
043 import java.awt.color.ColorSpace;
044 import java.awt.image.BufferedImage;
045 import java.awt.image.ColorConvertOp;
046 import java.awt.image.ConvolveOp;
047 import java.awt.image.Kernel;
048 import java.util.ArrayList;
049 import java.util.List;
050
051 import org.deegree.framework.xml.XMLParsingException;
052 import org.deegree.graphics.transformation.WorldToScreenTransform;
053 import org.deegree.model.spatialschema.Envelope;
054 import org.deegree.model.spatialschema.GMLGeometryAdapter;
055 import org.deegree.model.spatialschema.Geometry;
056 import org.deegree.model.spatialschema.GeometryException;
057 import org.deegree.model.spatialschema.MultiSurface;
058 import org.deegree.model.spatialschema.Position;
059 import org.deegree.model.spatialschema.Ring;
060 import org.deegree.model.spatialschema.Surface;
061
062 /**
063 * Display map surface depending on the security parameters. The rest of the Map Image will be
064 * blurred allowing the user a clear view of only the allowed surface.
065 *
066 * @author <a href="mailto:deshmukh@lat-lon.de">Anup Deshmukh</a>
067 *
068 * @author last edited by: $Author: mschneider $
069 *
070 * @version 2.0, $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
071 *
072 * @since 2.0
073 */
074
075 public class BlurImage {
076
077
078 /**
079 * Render the surface geometry the user is allowed to see. The geometry must be within the
080 * bounding box of the map image.
081 *
082 * 1. Geometry contains bbox -> no need to blur the image 2. Geometry complety within bbox. 3.
083 * BBOX intersects Geometry a. Returns a MultiSurface b. Returns a Surface 4. BBOX disjunkt
084 * Geometry
085 *
086 * @param image
087 * @param bbox
088 * @param geom
089 * @return BufferedImage
090 * @throws GeometryException
091 * @throws XMLParsingException
092 */
093 public BufferedImage renderUserRealm( BufferedImage image, Envelope bbox, Geometry geom )
094 throws GeometryException, XMLParsingException {
095
096 int blurScale = 8;
097 float alpha = 0.2f;
098
099 // Create output image
100 BufferedImage output = null;
101 if ( image.getType() == BufferedImage.TYPE_INT_RGB ) {
102 System.out.println( "setting rgb" );
103 output = new BufferedImage( image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_RGB );
104 } else {
105 System.out.println( "setting rgba" );
106 output = new BufferedImage( image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB );
107 }
108
109 // Transform the world coordinates to screen coordinates.
110 WorldToScreenTransform wsTransform = new WorldToScreenTransform( bbox.getMin().getX(), bbox.getMin().getY(),
111 bbox.getMax().getX(), bbox.getMax().getY(),
112 image.getMinX(), image.getMinY(),
113 image.getWidth(), image.getHeight() );
114
115 Graphics2D graphics = output.createGraphics();
116 Composite composite = graphics.getComposite();
117 graphics.setComposite( AlphaComposite.getInstance( AlphaComposite.SRC_OVER, alpha ) );
118 // blur image, along with the blur scale.
119 graphics.drawImage( blur( grayScale( image ), blurScale ), null, image.getMinX(), image.getMinY() );
120 graphics.setComposite( composite );
121 try {
122 // convert bbox to geometry.
123 StringBuffer envelope = GMLGeometryAdapter.exportAsBox( bbox );
124 Geometry boundingBOX = GMLGeometryAdapter.wrap( envelope.toString(), null );
125 Geometry intersection = boundingBOX.intersection( geom );
126 if ( intersection instanceof Surface ) {
127 Surface surface = (Surface) intersection;
128 Polygon polygon = retrieveSurfacePolygon( surface, wsTransform );
129 graphics = renderClip( graphics, polygon, image );
130 } else if ( intersection instanceof MultiSurface ) {
131 MultiSurface multiSurface = (MultiSurface) intersection;
132 Surface[] surfaces = multiSurface.getAllSurfaces();
133 for ( int i = 0; i < surfaces.length; i++ ) {
134 Surface surface = surfaces[i];
135 Polygon polygon = retrieveSurfacePolygon( surface, wsTransform );
136 graphics = renderClip( graphics, polygon, image );
137 }
138 }
139 } catch ( GeometryException e ) {
140 throw new GeometryException( "Error creating a geometry from the bounding box. " + e );
141 } catch ( XMLParsingException e ) {
142 throw new XMLParsingException( "Error exporting the bounding box to its " + "string format. " + e );
143 }
144 graphics.dispose();
145 return output;
146 }
147
148 /**
149 * Render the clip image on the output graphics context.
150 *
151 * @param graphics
152 * @param polygon
153 * @param image
154 * @return Graphics2D
155 */
156 private Graphics2D renderClip( Graphics2D graphics, Polygon polygon, BufferedImage image ) {
157
158 // clip the region which the user is allowed to see
159 graphics.setClip( polygon );
160 // draw region
161 graphics.drawImage( image, null, image.getMinX(), image.getMinY() );
162
163 return graphics;
164
165 }
166
167 /**
168 * Retrieve the surface as a java.awt.Polygon. The exterior and interior rings are retrieved and
169 * the coordinates transformed to screen coordinates.
170 *
171 * @param surface
172 * @param wsTransform
173 * @return Polygon
174 */
175 private Polygon retrieveSurfacePolygon( Surface surface, WorldToScreenTransform wsTransform ) {
176
177 Ring exteriorRing = surface.getSurfaceBoundary().getExteriorRing();
178 Position[] exteriorPositions = exteriorRing.getPositions();
179 Ring[] interiorRings = surface.getSurfaceBoundary().getInteriorRings();
180
181 Position[][] interiorPositions;
182 if ( interiorRings != null ) {
183 interiorPositions = new Position[interiorRings.length][];
184 for ( int i = 0; i < interiorPositions.length; i++ ) {
185 interiorPositions[i] = interiorRings[i].getPositions();
186 }
187 } else {
188 interiorPositions = new Position[0][];
189 }
190
191 int[] xArray = getXArray( exteriorPositions, interiorPositions, wsTransform );
192 int[] yArray = getYArray( exteriorPositions, interiorPositions, wsTransform );
193
194 Polygon polygon = new Polygon( xArray, yArray, xArray.length );
195
196 return polygon;
197 }
198
199 /**
200 * Retrieve the array of x-coordinates after transformation to screen coordinates.
201 *
202 * @param exteriorRing
203 * @param interiorRing
204 * @param wsTransform
205 * @return int[]
206 */
207 private int[] getXArray( Position[] exteriorRing, Position[][] interiorRing, WorldToScreenTransform wsTransform ) {
208
209 List<Double> xList = new ArrayList<Double>();
210 for ( int i = 0; i < exteriorRing.length; i++ ) {
211 Position position = exteriorRing[i];
212 xList.add( wsTransform.getDestX( position.getX() ) );
213 }
214 for ( int i = 0; i < interiorRing.length; i++ ) {
215 Position[] positions = interiorRing[i];
216 for ( int j = 0; j < positions.length; j++ ) {
217 Position position = positions[j];
218 xList.add( wsTransform.getDestX( position.getX() ) );
219 }
220 }
221
222 int[] xArray = new int[xList.size()];
223 for ( int i = 0; i < xList.size(); i++ ) {
224 Double tmp = xList.get( i );
225 xArray[i] = tmp.intValue();
226 }
227 return xArray;
228 }
229
230 /**
231 * Retrieve the array of y-coordinates after transformation to screen coordinates.
232 *
233 * @param exteriorRing
234 * @param interiorRing
235 * @param wsTransform
236 * @return int[]
237 */
238 private int[] getYArray( Position[] exteriorRing, Position[][] interiorRing, WorldToScreenTransform wsTransform ) {
239
240 List<Double> yList = new ArrayList<Double>();
241 for ( int i = 0; i < exteriorRing.length; i++ ) {
242 Position position = exteriorRing[i];
243 yList.add( wsTransform.getDestY( position.getY() ) );
244 }
245 for ( int i = 0; i < interiorRing.length; i++ ) {
246 Position[] positions = interiorRing[i];
247 for ( int j = 0; j < positions.length; j++ ) {
248 Position position = positions[j];
249 yList.add( wsTransform.getDestY( position.getY() ) );
250 }
251 }
252
253 int[] yArray = new int[yList.size()];
254 for ( int i = 0; i < yList.size(); i++ ) {
255 Double tmp = yList.get( i );
256 yArray[i] = tmp.intValue();
257 }
258 return yArray;
259 }
260
261 /**
262 * Blur effect carried out on the image. The blur scale defines the intensity of the blur.
263 *
264 * @param image
265 * @param blurScale
266 * @return BufferedImage
267 */
268 private BufferedImage blur( BufferedImage image, int blurScale ) {
269
270 BufferedImage destination = null;
271 if ( image.getType() == BufferedImage.TYPE_INT_RGB ) {
272 destination = new BufferedImage( image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_RGB );
273 } else {
274 destination = new BufferedImage( image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB );
275 }
276
277 float[] data = new float[blurScale * blurScale];
278 float value = 1.0f / ( blurScale * blurScale );
279 for ( int i = 0; i < data.length; i++ ) {
280 data[i] = value;
281 }
282 Kernel kernel = new Kernel( blurScale, blurScale, data );
283 ConvolveOp convolve = new ConvolveOp( kernel, ConvolveOp.EDGE_NO_OP, null );
284 convolve.filter( image, destination );
285
286 return destination;
287 }
288
289 /**
290 * Convert BufferedImage RGB to black and white image
291 *
292 * @param image
293 * @return BufferedImage
294 */
295 private BufferedImage grayScale( BufferedImage image ) {
296
297 BufferedImage destination = null;
298 if ( image.getType() == BufferedImage.TYPE_INT_RGB ) {
299 destination = new BufferedImage( image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_RGB );
300 } else {
301 destination = new BufferedImage( image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB );
302 }
303 ColorConvertOp colorConvert = new ColorConvertOp( ColorSpace.getInstance( ColorSpace.CS_GRAY ), null );
304 colorConvert.filter( image, destination );
305
306 return destination;
307 }
308
309 }