KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > blandware > atleap > webapp > util > core > ImageUtil


1 /*
2  * Copyright 2004 Blandware (http://www.blandware.com)
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.blandware.atleap.webapp.util.core;
17
18 import javax.imageio.IIOImage JavaDoc;
19 import javax.imageio.ImageIO JavaDoc;
20 import javax.imageio.ImageReadParam JavaDoc;
21 import javax.imageio.ImageReader JavaDoc;
22 import javax.imageio.ImageWriteParam JavaDoc;
23 import javax.imageio.ImageWriter JavaDoc;
24 import javax.imageio.metadata.IIOMetadata JavaDoc;
25 import javax.imageio.stream.ImageInputStream JavaDoc;
26 import javax.imageio.stream.ImageOutputStream JavaDoc;
27 import java.awt.geom.AffineTransform JavaDoc;
28 import java.awt.image.AffineTransformOp JavaDoc;
29 import java.awt.image.BufferedImage JavaDoc;
30 import java.io.ByteArrayInputStream JavaDoc;
31 import java.io.ByteArrayOutputStream JavaDoc;
32 import java.io.IOException JavaDoc;
33 import java.io.InputStream JavaDoc;
34 import java.io.OutputStream JavaDoc;
35 import java.util.Iterator JavaDoc;
36
37 /**
38  * <p>This class provides facilities to scale and convert images</p>
39  * <p><a HREF="ImageUtil.java.htm"><i>View Source</i></a></p>
40  *
41  * @author Andrey Grebnev <a HREF="mailto:andrey.grebnev@blandware.com">&lt;andrey.grebnev@blandware.com&gt;</a>
42  * @version $Revision: 1.3 $ $Date: 2005/08/04 17:25:24 $
43  */
44 public class ImageUtil {
45
46     public static final String JavaDoc MIMETYPE_JPEG = "image/jpeg";
47     public static final String JavaDoc MIMETYPE_GIF = "image/gif";
48     public static final String JavaDoc MIMETYPE_PNG = "image/png";
49
50     /**
51      * Creates new instance of ImageUtil
52      */
53     public ImageUtil() {
54     }
55
56     /**
57      * Decodes image of specified format where image data is given as an array
58      * of bytes
59      *
60      * @param imageData original image data
61      * @param mimeType mime type of source file e.g. <code>image/jpeg</code>
62      * @return <code>BufferedImage<code> and metadata bagged into <code>IIOImage</code>
63      * @throws IllegalArgumentException if this mime type is not supported
64      * @throws IOException if cannot perform decode operation
65      */
66     public static IIOImage JavaDoc decodeImage(byte[] imageData, String JavaDoc mimeType)
67             throws IllegalArgumentException JavaDoc, IOException JavaDoc {
68         return decodeImage(new ByteArrayInputStream JavaDoc(imageData), mimeType);
69     }
70
71     /**
72      * Decodes image of specified format where image data is given as an input
73      * stream
74      *
75      * @param imageData original image data
76      * @param mimeType mime type of source file e.g. <code>image/jpeg</code>
77      * @return <code>BufferedImage<code> and metadata bagged into <code>IIOImage</code>
78      * @throws IllegalArgumentException if this mime type is not supported
79      * @throws IOException if cannot perform decode operation
80      */
81     public static IIOImage JavaDoc decodeImage(InputStream JavaDoc imageData, String JavaDoc mimeType)
82             throws IllegalArgumentException JavaDoc, IOException JavaDoc {
83         Iterator JavaDoc imageReaders = ImageIO.getImageReadersByMIMEType(mimeType);
84         if ( imageReaders == null || !imageReaders.hasNext() ) {
85             throw new IllegalArgumentException JavaDoc("Unsupported mimetype: " + mimeType);
86         }
87         ImageReader JavaDoc reader = (ImageReader JavaDoc) imageReaders.next();
88         ImageReadParam JavaDoc param = reader.getDefaultReadParam();
89         ImageInputStream JavaDoc iis = ImageIO.createImageInputStream(imageData);
90         reader.setInput(iis, true, true);
91         int index = reader.getMinIndex();
92         BufferedImage JavaDoc image = reader.read(index, param);
93         IIOMetadata JavaDoc metadata = reader.getImageMetadata(index);
94         IIOImage JavaDoc iioImage = new IIOImage JavaDoc(image, null, metadata);
95         iis.close();
96         reader.dispose();
97         return iioImage;
98     }
99
100     /**
101      * Encodes image into specified format returning the resulting image data
102      * as an array of bytes
103      *
104      * @param image image to write, can has metadata to get source compression quality
105      * @param mimeType mime type of source file e.g. <code>image/jpeg</code>
106      * @return encoded image data
107      * @throws IllegalArgumentException if this mime type is not supported
108      * @throws IOException if cannot perform encode operation
109      */
110     public static byte[] encodeImage(IIOImage JavaDoc image, String JavaDoc mimeType)
111             throws IllegalArgumentException JavaDoc, IOException JavaDoc {
112         ByteArrayOutputStream JavaDoc out = new ByteArrayOutputStream JavaDoc();
113         encodeImage(image, out, mimeType);
114         byte[] result = out.toByteArray();
115         out.close();
116         return result;
117     }
118
119     /**
120      * Encodes image into specified format putting the resulting image data to
121      * a given stream
122      *
123      * @param image image to write, can has metadata to get source compression quality
124      * @param imageData storage to put encoded data
125      * @param mimeType mime type of source file e.g. <code>image/jpeg</code>
126      * @throws IllegalArgumentException if this mime type is not supported
127      * @throws IOException if cannot perform encode operation
128      */
129     public static void encodeImage(IIOImage JavaDoc image, OutputStream JavaDoc imageData, String JavaDoc mimeType)
130             throws IllegalArgumentException JavaDoc, IOException JavaDoc {
131         Iterator JavaDoc imageWriters = ImageIO.getImageWritersByMIMEType(mimeType);
132         if ( imageWriters == null || !imageWriters.hasNext() ) {
133             throw new IllegalArgumentException JavaDoc("Unsupported mimetype: " + mimeType);
134         }
135         ImageWriter JavaDoc writer = (ImageWriter JavaDoc) imageWriters.next();
136         ImageWriteParam JavaDoc param = writer.getDefaultWriteParam();
137         ImageOutputStream JavaDoc ios = ImageIO.createImageOutputStream(imageData);
138         if ( mimeType.equalsIgnoreCase(MIMETYPE_JPEG) && image.getMetadata() == null ) {
139             param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
140             param.setCompressionQuality(1.0f);
141         }
142         writer.setOutput(ios);
143         writer.write(image.getMetadata(), image, param);
144         ios.flush();
145         writer.dispose();
146     }
147
148     /**
149      * Scales image so it can be inscribed into rectangle with specified width
150      * and height. If the resulting image has the same size as a source one,
151      * then a source image is returned.
152      *
153      * @param iioSource original image
154      * @param maxWidth width of rectangle
155      * @param maxHeight height of rectangle
156      * @return scaled image
157      */
158     public static IIOImage JavaDoc scaleToRectangle(IIOImage JavaDoc iioSource, int maxWidth, int maxHeight) {
159         if ( !(iioSource.getRenderedImage() instanceof BufferedImage JavaDoc) ) {
160             throw new IllegalArgumentException JavaDoc("RenderedImage in IIOImage must be BufferedImage");
161         }
162
163         BufferedImage JavaDoc source = (BufferedImage JavaDoc) iioSource.getRenderedImage();
164
165         double scale = 1.0d;
166         if ( maxWidth == 0 && maxHeight == 0 ) {
167             scale = 1.0d;
168         } else if ( maxWidth == 0 ) {
169             scale = (double) maxHeight / (double) source.getHeight();
170         } else if ( maxHeight == 0 ) {
171             scale = (double) maxWidth / (double) source.getWidth();
172         } else {
173             double scaledWidth = (double) maxWidth / (double) source.getWidth();
174             double scaledHeight = (double) maxHeight / (double) source.getHeight();
175             scale = Math.min(scaledHeight, scaledWidth);
176         }
177         //do not enlarge image
178 if ( scale >= 1.0d ) {
179             return iioSource;
180         }
181
182         AffineTransform JavaDoc at = new AffineTransform JavaDoc();
183         at.scale(scale, scale);
184         AffineTransformOp JavaDoc atOp = new AffineTransformOp JavaDoc(at, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
185         BufferedImage JavaDoc destination = atOp.filter(source, null);
186
187         IIOImage JavaDoc iioDestination = new IIOImage JavaDoc(destination, null, null);
188         return iioDestination;
189     }
190
191 }
192
Popular Tags