001    // $HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/framework/util/ImageUtils.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    package org.deegree.framework.util;
037    
038    import static org.deegree.enterprise.WebUtils.enableProxyUsage;
039    
040    import java.awt.image.BufferedImage;
041    import java.io.File;
042    import java.io.FileOutputStream;
043    import java.io.IOException;
044    import java.io.InputStream;
045    import java.io.OutputStream;
046    import java.net.URL;
047    
048    import javax.imageio.ImageIO;
049    import javax.media.jai.JAI;
050    import javax.media.jai.PlanarImage;
051    import javax.media.jai.RenderedOp;
052    
053    import org.apache.batik.ext.awt.image.codec.ImageDecoderImpl;
054    import org.apache.batik.ext.awt.image.codec.PNGDecodeParam;
055    import org.apache.batik.ext.awt.image.codec.PNGImageDecoder;
056    import org.apache.batik.ext.awt.image.codec.tiff.TIFFDecodeParam;
057    import org.apache.batik.ext.awt.image.codec.tiff.TIFFImage;
058    import org.apache.commons.httpclient.HttpClient;
059    import org.apache.commons.httpclient.methods.GetMethod;
060    
061    import Acme.JPM.Encoders.GifEncoder;
062    
063    import com.sun.image.codec.jpeg.JPEGCodec;
064    import com.sun.image.codec.jpeg.JPEGImageEncoder;
065    import com.sun.media.jai.codec.BMPEncodeParam;
066    import com.sun.media.jai.codec.ImageCodec;
067    import com.sun.media.jai.codec.MemoryCacheSeekableStream;
068    import com.sun.media.jai.codec.PNGEncodeParam;
069    import com.sun.media.jai.codec.SeekableStream;
070    import com.sun.media.jai.codec.TIFFEncodeParam;
071    
072    /**
073     * Some utility methods for reading standard images
074     *
075     * @author <a href="mailto:poth@lat-lon.de">Andreas Poth</a>
076     * @author last edited by: $Author: mschneider $
077     *
078     * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
079     */
080    public class ImageUtils {
081    
082        /**
083         * reads an image from the passed <tt>URL</tt> using JAI mechanism
084         *
085         * @param url
086         *            address of the image
087         *
088         * @return read image
089         *
090         * @throws IOException
091         */
092        public static BufferedImage loadImage( URL url )
093                                throws IOException {
094            if ( url.toExternalForm().startsWith( "file" ) ) {
095                return loadImage( url.openStream() );
096            }
097    
098            String uri = url.toExternalForm();
099            HttpClient httpclient = new HttpClient();
100            enableProxyUsage( httpclient, url );
101            httpclient.getHttpConnectionManager().getParams().setSoTimeout( 25000 );
102            GetMethod httpget = new GetMethod( uri );
103            httpclient.executeMethod( httpget );
104            return loadImage( httpget.getResponseBodyAsStream() );
105    
106        }
107    
108        /**
109         * reads an image from the passed <tt>InputStream</tt> using JAI mechanism
110         *
111         * @param is
112         *
113         * @return read image
114         *
115         * @throws IOException
116         */
117        public static BufferedImage loadImage( InputStream is )
118                                throws IOException {
119            SeekableStream fss = new MemoryCacheSeekableStream( is );
120            RenderedOp ro = JAI.create( "stream", fss );
121            BufferedImage img = ro.getAsBufferedImage();
122            fss.close();
123            is.close();
124            return img;
125        }
126    
127        /**
128         * reads an image from the passed file location using JAI mechanism
129         *
130         * @param fileName
131         *
132         * @return read imagey
133         *
134         * @throws IOException
135         */
136        public static BufferedImage loadImage( String fileName )
137                                throws IOException {
138            return loadImage( new File( fileName ) );
139        }
140    
141        /**
142         * reads an image from the passed file location using JAI mechanism
143         *
144         * @param file
145         *
146         * @return read image
147         *
148         * @throws IOException
149         */
150        public static BufferedImage loadImage( File file )
151                                throws IOException {
152    
153            BufferedImage img = null;
154            String tmp = file.getName().toLowerCase();
155            if ( tmp.endsWith( ".tif" ) || tmp.endsWith( ".tiff" ) ) {
156                InputStream is = file.toURL().openStream();
157                org.apache.batik.ext.awt.image.codec.SeekableStream fss = new org.apache.batik.ext.awt.image.codec.MemoryCacheSeekableStream(
158                                                                                                                                              is );
159                TIFFImage tiff = new TIFFImage( fss, new TIFFDecodeParam(), 0 );
160                img = PlanarImage.wrapRenderedImage( tiff ).getAsBufferedImage();
161                fss.close();
162            } else if ( tmp.endsWith( ".png" ) ) {
163                InputStream is = file.toURL().openStream();
164                ImageDecoderImpl dec = new PNGImageDecoder( is, new PNGDecodeParam() );
165                img = PlanarImage.wrapRenderedImage( dec.decodeAsRenderedImage() ).getAsBufferedImage();
166                is.close();
167            } else {
168                img = ImageIO.read( file );
169            }
170    
171            return img;
172        }
173    
174        /**
175         * stores the passed image in the passed file name with defined quality
176         *
177         * @param image
178         * @param fileName
179         * @param quality
180         *            just supported for jpeg (0..1)
181         * @throws IOException
182         */
183        public static void saveImage( BufferedImage image, String fileName, float quality )
184                                throws IOException {
185            File file = new File( fileName );
186            saveImage( image, file, quality );
187        }
188    
189        /**
190         * stores the passed image in the passed file with defined quality
191         *
192         * @param image
193         * @param file
194         * @param quality
195         *            just supported for jpeg (0..1)
196         * @throws IOException
197         */
198        public static void saveImage( BufferedImage image, File file, float quality )
199                                throws IOException {
200            int pos = file.getName().lastIndexOf( '.' );
201            String ext = file.getName().substring( pos + 1, file.getName().length() ).toLowerCase();
202    
203            FileOutputStream fos = new FileOutputStream( file );
204            saveImage( image, fos, ext, quality );
205    
206        }
207    
208        /**
209         * write an image into the passed output stream. after writing the image the stream will be closed.
210         *
211         * @param image
212         * @param os
213         * @param format
214         * @param quality
215         * @throws IOException
216         */
217        public static void saveImage( BufferedImage image, OutputStream os, String format, float quality )
218                                throws IOException {
219            try {
220    
221                if ( "jpeg".equalsIgnoreCase( format ) || "jpg".equalsIgnoreCase( format ) ) {
222                    encodeJpeg( os, image, quality );
223                } else if ( "tif".equalsIgnoreCase( format ) || "tiff".equalsIgnoreCase( format ) ) {
224                    encodeTiff( os, image );
225                } else if ( "png".equalsIgnoreCase( format ) ) {
226                    encodePng( os, image );
227                } else if ( "gif".equalsIgnoreCase( format ) ) {
228                    encodeGif( os, image );
229                } else if ( "bmp".equalsIgnoreCase( format ) ) {
230                    encodeBmp( os, image );
231                } else {
232                    throw new IOException( "invalid image format: " + format );
233                }
234            } catch ( IOException e ) {
235                throw e;
236            } finally {
237                os.flush();
238                os.close();
239            }
240    
241        }
242    
243        /**
244         *
245         *
246         * @param out
247         * @param img
248         *
249         * @throws IOException
250         */
251        public static void encodeGif( OutputStream out, BufferedImage img )
252                                throws IOException {
253            GifEncoder encoder = new GifEncoder( img, out );
254            encoder.encode();
255        }
256    
257        /**
258         *
259         *
260         * @param out
261         * @param img
262         *
263         * @throws IOException
264         */
265        private static void encodeBmp( OutputStream out, BufferedImage img )
266                                throws IOException {
267            BMPEncodeParam encodeParam = new BMPEncodeParam();
268    
269            com.sun.media.jai.codec.ImageEncoder encoder = ImageCodec.createImageEncoder( "BMP", out, encodeParam );
270    
271            encoder.encode( img );
272        }
273    
274        /**
275         *
276         *
277         * @param out
278         * @param img
279         *
280         * @throws IOException
281         */
282        private static void encodePng( OutputStream out, BufferedImage img )
283                                throws IOException {
284            PNGEncodeParam encodeParam = PNGEncodeParam.getDefaultEncodeParam( img );
285    
286            if ( encodeParam instanceof PNGEncodeParam.Palette ) {
287                PNGEncodeParam.Palette p = (PNGEncodeParam.Palette) encodeParam;
288                byte[] b = new byte[] { -127 };
289                p.setPaletteTransparency( b );
290            }
291    
292            com.sun.media.jai.codec.ImageEncoder encoder = ImageCodec.createImageEncoder( "PNG", out, encodeParam );
293            encoder.encode( img.getData(), img.getColorModel() );
294        }
295    
296        /**
297         *
298         *
299         * @param out
300         * @param img
301         *
302         * @throws IOException
303         */
304        private static void encodeTiff( OutputStream out, BufferedImage img )
305                                throws IOException {
306            TIFFEncodeParam encodeParam = new TIFFEncodeParam();
307    
308            com.sun.media.jai.codec.ImageEncoder encoder = ImageCodec.createImageEncoder( "TIFF", out, encodeParam );
309    
310            encoder.encode( img );
311        }
312    
313        /**
314         *
315         *
316         * @param out
317         * @param img
318         * @param quality
319         *
320         * @throws IOException
321         */
322        private static void encodeJpeg( OutputStream out, BufferedImage img, float quality )
323                                throws IOException {
324    
325            // encode JPEG
326            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder( out );
327            com.sun.image.codec.jpeg.JPEGEncodeParam jpegParams = encoder.getDefaultJPEGEncodeParam( img );
328            jpegParams.setQuality( quality, false );
329            encoder.setJPEGEncodeParam( jpegParams );
330    
331            encoder.encode( img );
332        }
333    
334    }