一个JAVA图形缩放处理工具类

 调用的例子

1. import java.io.FileOutputStream;
2. import java.io.IOException;
3. 
   
4. import javax.imageio.ImageIO;
5. 
   
6. public class T {
7.   public static void main(String[] args) throws Exception, IOException {
8.     ImageIO.write(ImageUtils.resizeImage("d:/www.java2000.net.gif", ImageUtils.IMAGE_GIF, 30, 20),
9.         "JPEG", new FileOutputStream("d:/test.jpg"));
10.   }
11. }

源代码，如果你复制源代码不方便，来这里：http://www.java2000.net/p10821

1. import java.awt.Dimension;
2. import java.awt.Image;
3. import java.awt.image.BufferedImage;
4. import java.awt.image.PixelGrabber;
5. import java.io.File;
6. import java.io.IOException;
7. import java.util.Iterator;
8. import java.util.Locale;
10. import javax.imageio.IIOImage;
11. import javax.imageio.ImageIO;
12. import javax.imageio.ImageWriteParam;
13. import javax.imageio.ImageWriter;
14. import javax.imageio.plugins.jpeg.JPEGImageWriteParam;
15. import javax.imageio.stream.ImageOutputStream;
18. public class ImageUtils {
19.   public static final int IMAGE_UNKNOWN = -1;
20.   public static final int IMAGE_JPEG = 0;
21.   public static final int IMAGE_PNG = 1;
22.   public static final int IMAGE_GIF = 2;
24.   /**
25.    * Resizes an image
26.    * 
27.    * @param imgName
28.    *          The image name to resize. Must be the complet path to the file
29.    * @param type
30.    *          int
31.    * @param maxWidth
32.    *          The image's max width
33.    * @param maxHeight
34.    *          The image's max height
35.    * @return A resized <code>BufferedImage</code>
36.    */
37.   public static BufferedImage resizeImage(String imgName, int type, int maxWidth, int maxHeight) {
38.     try {
39.       return resizeImage(ImageIO.read(new File(imgName)), type, maxWidth, maxHeight);
40.     } catch (IOException e) {
41.       e.printStackTrace();
42.       return null;
43.     }
44.   }
46.   /**
47.    * Resizes an image.
48.    * 
49.    * @param image
50.    *          The image to resize
51.    * @param maxWidth
52.    *          The image's max width
53.    * @param maxHeight
54.    *          The image's max height
55.    * @return A resized <code>BufferedImage</code>
56.    * @param type
57.    *          int
58.    */
59.   public static BufferedImage resizeImage(BufferedImage image, int type, int maxWidth, int maxHeight) {
60.     Dimension largestDimension = new Dimension(maxWidth, maxHeight);
62.     // Original size
63.     int imageWidth = image.getWidth(null);
64.     int imageHeight = image.getHeight(null);
66.     float aspectRatio = (float) imageWidth / imageHeight;
68.     if (imageWidth > maxWidth || imageHeight > maxHeight) {
69.       if ((float) largestDimension.width / largestDimension.height > aspectRatio) {
70.         largestDimension.width = (int) Math.ceil(largestDimension.height * aspectRatio);
71.       } else {
72.         largestDimension.height = (int) Math.ceil(largestDimension.width / aspectRatio);
73.       }
75.       imageWidth = largestDimension.width;
76.       imageHeight = largestDimension.height;
77.     }
79.     return createHeadlessSmoothBufferedImage(image, type, imageWidth, imageHeight);
80.   }
82.   /**
83.    * Saves an image to the disk.
84.    * 
85.    * @param image
86.    *          The image to save
87.    * @param toFileName
88.    *          The filename to use
89.    * @param type
90.    *          The image type. Use <code>ImageUtils.IMAGE_JPEG</code> to save as
91.    *          JPEG images, or <code>ImageUtils.IMAGE_PNG</code> to save as PNG.
92.    * @return <code>false</code> if no appropriate writer is found
93.    */
94.   public static boolean saveImage(BufferedImage image, String toFileName, int type) {
95.     try {
96.       return ImageIO.write(image, type == IMAGE_JPEG ? "jpg" : "png", new File(toFileName));
97.     } catch (IOException e) {
98.       e.printStackTrace();
99.       return false;
100.     }
101.   }
103.   /**
104.    * Compress and save an image to the disk. Currently this method only supports
105.    * JPEG images.
106.    * 
107.    * @param image
108.    *          The image to save
109.    * @param toFileName
110.    *          The filename to use
111.    * @param type
112.    *          The image type. Use <code>ImageUtils.IMAGE_JPEG</code> to save as
113.    *          JPEG images, or <code>ImageUtils.IMAGE_PNG</code> to save as PNG.
114.    */
115.   public static void saveCompressedImage(BufferedImage image, String toFileName, int type) {
116.     try {
117.       if (type == IMAGE_PNG) {
118.         throw new UnsupportedOperationException("PNG compression not implemented");
119.       }
121.       Iterator iter = ImageIO.getImageWritersByFormatName("jpg");
122.       ImageWriter writer;
123.       writer = (ImageWriter) iter.next();
125.       ImageOutputStream ios = ImageIO.createImageOutputStream(new File(toFileName));
126.       writer.setOutput(ios);
128.       ImageWriteParam iwparam = new JPEGImageWriteParam(Locale.getDefault());
130.       iwparam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
131.       iwparam.setCompressionQuality(0.7F);
133.       writer.write(null, new IIOImage(image, null, null), iwparam);
135.       ios.flush();
136.       writer.dispose();
137.       ios.close();
138.     } catch (IOException e) {
139.       e.printStackTrace();
140.     }
141.   }
143.   /**
144.    * Creates a <code>BufferedImage</code> from an <code>Image</code>. This
145.    * method can function on a completely headless system. This especially
146.    * includes Linux and Unix systems that do not have the X11 libraries
147.    * installed, which are required for the AWT subsystem to operate. This method
148.    * uses nearest neighbor approximation, so it's quite fast. Unfortunately, the
149.    * result is nowhere near as nice looking as the
150.    * createHeadlessSmoothBufferedImage method.
151.    * 
152.    * @param image
153.    *          The image to convert
154.    * @param w
155.    *          The desired image width
156.    * @param h
157.    *          The desired image height
158.    * @return The converted image
159.    * @param type
160.    *          int
161.    */
162.   public static BufferedImage createHeadlessBufferedImage(BufferedImage image, int type, int width,
163.       int height) {
164.     if (type == ImageUtils.IMAGE_PNG && hasAlpha(image)) {
165.       type = BufferedImage.TYPE_INT_ARGB;
166.     } else {
167.       type = BufferedImage.TYPE_INT_RGB;
168.     }
170.     BufferedImage bi = new BufferedImage(width, height, type);
172.     for (int y = 0; y < height; y++) {
173.       for (int x = 0; x < width; x++) {
174.         bi.setRGB(x, y, image.getRGB(x * image.getWidth() / width, y * image.getHeight() / height));
175.       }
176.     }
178.     return bi;
179.   }
181.   /**
182.    * Creates a <code>BufferedImage</code> from an <code>Image</code>. This
183.    * method can function on a completely headless system. This especially
184.    * includes Linux and Unix systems that do not have the X11 libraries
185.    * installed, which are required for the AWT subsystem to operate. The
186.    * resulting image will be smoothly scaled using bilinear filtering.
187.    * 
188.    * @param source
189.    *          The image to convert
190.    * @param w
191.    *          The desired image width
192.    * @param h
193.    *          The desired image height
194.    * @return The converted image
195.    * @param type
196.    *          int
197.    */
198.   public static BufferedImage createHeadlessSmoothBufferedImage(BufferedImage source, int type,
199.       int width, int height) {
200.     if (type == ImageUtils.IMAGE_PNG && hasAlpha(source)) {
201.       type = BufferedImage.TYPE_INT_ARGB;
202.     } else {
203.       type = BufferedImage.TYPE_INT_RGB;
204.     }
206.     BufferedImage dest = new BufferedImage(width, height, type);
208.     int sourcex;
209.     int sourcey;
211.     double scalex = (double) width / source.getWidth();
212.     double scaley = (double) height / source.getHeight();
214.     int x1;
215.     int y1;
217.     double xdiff;
218.     double ydiff;
220.     int rgb;
221.     int rgb1;
222.     int rgb2;
224.     for (int y = 0; y < height; y++) {
225.       sourcey = y * source.getHeight() / dest.getHeight();
226.       ydiff = scale(y, scaley) - sourcey;
228.       for (int x = 0; x < width; x++) {
229.         sourcex = x * source.getWidth() / dest.getWidth();
230.         xdiff = scale(x, scalex) - sourcex;
232.         x1 = Math.min(source.getWidth() - 1, sourcex + 1);
233.         y1 = Math.min(source.getHeight() - 1, sourcey + 1);
235.         rgb1 = getRGBInterpolation(source.getRGB(sourcex, sourcey), source.getRGB(x1, sourcey),
236.             xdiff);
237.         rgb2 = getRGBInterpolation(source.getRGB(sourcex, y1), source.getRGB(x1, y1), xdiff);
239.         rgb = getRGBInterpolation(rgb1, rgb2, ydiff);
241.         dest.setRGB(x, y, rgb);
242.       }
243.     }
245.     return dest;
246.   }
248.   private static double scale(int point, double scale) {
249.     return point / scale;
250.   }
252.   private static int getRGBInterpolation(int value1, int value2, double distance) {
253.     int alpha1 = (value1 & 0xFF000000) >>> 24;
254.     int red1 = (value1 & 0x00FF0000) >> 16;
255.     int green1 = (value1 & 0x0000FF00) >> 8;
256.     int blue1 = (value1 & 0x000000FF);
258.     int alpha2 = (value2 & 0xFF000000) >>> 24;
259.     int red2 = (value2 & 0x00FF0000) >> 16;
260.     int green2 = (value2 & 0x0000FF00) >> 8;
261.     int blue2 = (value2 & 0x000000FF);
263.     int rgb = ((int) (alpha1 * (1.0 - distance) + alpha2 * distance) << 24)
264.         | ((int) (red1 * (1.0 - distance) + red2 * distance) << 16)
265.         | ((int) (green1 * (1.0 - distance) + green2 * distance) << 8)
266.         | (int) (blue1 * (1.0 - distance) + blue2 * distance);
268.     return rgb;
269.   }
271.   /**
272.    * Determines if the image has transparent pixels.
273.    * 
274.    * @param image
275.    *          The image to check for transparent pixel.s
276.    * @return <code>true</code> of <code>false</code>, according to the result
277.    */
278.   public static boolean hasAlpha(Image image) {
279.     try {
280.       PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);
281.       pg.grabPixels();
283.       return pg.getColorModel().hasAlpha();
284.     } catch (InterruptedException e) {
285.       return false;
286.     }
287.   }
288. }