java实用工具（图片）

package com.omg.web.util;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.awt.image.CropImageFilter;
import java.awt.image.FilteredImageSource;
import java.awt.image.ImageFilter;
import java.awt.image.ImageProducer;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Iterator;

import javax.imageio.ImageIO;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.stream.ImageInputStream;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import sun.misc.BASE64Encoder;

import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

public class ImageUtil {

private static final Log LOG = LogFactory.getLog(ImageUtil.class);

/**
* 缩放
*
* @param filePath
* 图片路径
* @param savePath
* 保存路径
* @param width
* 宽度
* @param height
* 高度
* @param bb
* 比例不对时是否需要补白
*/
public static void resize(String filePath, String savePath, int width,
int height, boolean bb) {
try {
double ratio = 0.0; // 缩放比例
File f = new File(filePath);
BufferedImage bi = ImageIO.read(f);
Image itemp = bi.getScaledInstance(width, height, bi.SCALE_SMOOTH);
// 计算比例
if ((bi.getHeight() > height) || (bi.getWidth() > width)) {
if (bi.getHeight() > bi.getWidth()) {
ratio = (new Integer(height)).doubleValue()
/ bi.getHeight();
} else {
ratio = (new Integer(width)).doubleValue() / bi.getWidth();
}
AffineTransformOp op = new AffineTransformOp(
AffineTransform.getScaleInstance(ratio, ratio), null);
itemp = op.filter(bi, null);
}
if (bb) {
BufferedImage image = new BufferedImage(width, height,
BufferedImage.TYPE_INT_RGB);
Graphics2D g = image.createGraphics();
g.setColor(Color.white);
g.fillRect(0, 0, width, height);
if (width == itemp.getWidth(null))
g.drawImage(itemp, 0, (height - itemp.getHeight(null)) / 2,
itemp.getWidth(null), itemp.getHeight(null),
Color.white, null);
else
g.drawImage(itemp, (width - itemp.getWidth(null)) / 2, 0,
itemp.getWidth(null), itemp.getHeight(null),
Color.white, null);
g.dispose();
itemp = image;
}
ImageIO.write((BufferedImage) itemp,
FileUtil.getFileExtention(filePath).substring(1), new File(
savePath));
} catch (Exception e) {
LOG.error(new ImageUtil(), e);
}
}

/**
* 图片处理（只能生产JPG文件）
* 先缩放到规定尺寸，再裁剪多余部分
*
* @param srcFile 源文件路径
* @param smallFile 保存文件路径
* @param width 裁剪的宽度
* @param height 裁剪的高度
*/
public static void cutImage(String srcFile, String smallFile, int width,
int height) {
try {
// 1.获得原始图象Image对象
File file = new File(srcFile);
// baseImage =ImageIO.read(file);
BufferedImage image = ImageIO.read(file);

if (null != image) {
double ratio = 0.0; // 缩放比例

// 计算比例
if ((image.getHeight() > height) || (image.getWidth() > width)) {
if (image.getHeight() < image.getWidth()) {
ratio = (new Integer(height)).doubleValue()
/ image.getHeight();
} else {
ratio = (new Integer(width)).doubleValue() / image.getWidth();
}
AffineTransformOp op = new AffineTransformOp(
AffineTransform.getScaleInstance(ratio, ratio), null);
image = op.filter(image, null);
}

/******************** 文件裁剪 ********************/
// 2.获得剪切后的Image对象
if (width > image.getWidth() && height > image.getHeight()) {
// 如果要求尺寸大于实际尺寸，不做裁剪
FileUtil.copy(file, new File(smallFile));
return;
}

// 大于要求的部分进行裁剪
width = width < image.getWidth() ? width : image.getWidth();
height = height < image.getHeight() ? height : image
.getHeight();

// 根据图像裁剪过滤器产生过滤器
ImageFilter filter = new CropImageFilter(0, 0, width, height);
// 下面根据过滤器产生图像生产者
ImageProducer producer = new FilteredImageSource(
image.getSource(), filter);
// 根据图像生产者产生新图像
Image croppedImage = Toolkit.getDefaultToolkit().createImage(
producer);

// 3.生成图片文件
BufferedImage tag = new BufferedImage(width, height,
BufferedImage.TYPE_INT_RGB);
tag.getGraphics().drawImage(croppedImage, 0, 0, width, height,
null);
FileOutputStream fos = new FileOutputStream(smallFile);
BufferedOutputStream bos = new BufferedOutputStream(fos);
JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(bos);
encoder.encode(tag);
bos.close();
}
} catch (Exception e) {
LOG.error(new ImageUtil(), e);
}
}

/**
* 方型图片切割
*
* @param srcFile
* 原图路径
* @param smallFile
* 新图路径
* @throws Exception
*/
public static void cutImage(String srcFile, String smallFile) {
try {
// 1.获得原始图象Image对象
File file = new File(srcFile);
// baseImage =ImageIO.read(file);
BufferedImage image = ImageIO.read(file);

if (null != image) {
// 2.获得剪切后的Image对象
int size = 0;
if (image.getWidth() < image.getHeight()) {
size = image.getWidth();
} else {
size = image.getHeight();
}
// 根据图像裁剪过滤器产生过滤器
ImageFilter filter = new CropImageFilter(0, 0, size, size);
// 下面根据过滤器产生图像生产者
ImageProducer producer = new FilteredImageSource(
image.getSource(), filter);
// 根据图像生产者产生新图像
Image croppedImage = Toolkit.getDefaultToolkit().createImage(
producer);

// croppedImage = cropImage(0, 0, WIDTH, HEIGHT);

// 3.生成图片文件
BufferedImage tag = new BufferedImage(size, size,
BufferedImage.TYPE_INT_RGB);
tag.getGraphics().drawImage(croppedImage, 0, 0, size, size,
null);
FileOutputStream fos = new FileOutputStream(smallFile);
BufferedOutputStream bos = new BufferedOutputStream(fos);
JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(bos);
encoder.encode(tag);
bos.close();
}
} catch (Exception e) {
LOG.error(new ImageUtil(), e);
}

}

public static void imageCut(String filePath, String savePath)
throws Exception {
FileInputStream is = null;
ImageInputStream iis = null;

try {
// 读取图片文件
is = new FileInputStream(filePath);

/*
* 返回包含所有当前已注册 ImageReader 的 Iterator，这些 ImageReader 声称能够解码指定格式。
* 参数：formatName - 包含非正式格式名称 .（例如 "jpeg" 或 "tiff"）等 。
*/
Iterator<ImageReader> it = ImageIO
.getImageReadersByFormatName(FileUtil.getFileExtention(
savePath).substring(1));
ImageReader reader = it.next();
// 获取图片流
iis = ImageIO.createImageInputStream(is);

/*
* <p>iis:读取源.true:只向前搜索 </p>.将它标记为 ‘只向前搜索’。
* 此设置意味着包含在输入源中的图像将只按顺序读取，可能允许 reader 避免缓存包含与以前已经读取的图像关联的数据的那些输入部分。
*/
reader.setInput(iis, true);

/*
* <p>描述如何对流进行解码的类<p>.用于指定如何在输入时从 Java Image I/O
* 框架的上下文中的流转换一幅图像或一组图像。用于特定图像格式的插件 将从其 ImageReader 实现的
* getDefaultReadParam 方法中返回 ImageReadParam 的实例。
*/
ImageReadParam param = reader.getDefaultReadParam();

// 取得图片缩放大小
int size;
BufferedImage bi = ImageIO.read(is);
if (bi.getHeight() > bi.getWidth()) {
size = bi.getWidth();
} else {
size = bi.getHeight();
}
/*
* 图片裁剪区域。Rectangle 指定了坐标空间中的一个区域，通过 Rectangle 对象
* 的左上顶点的坐标（x，y）、宽度和高度可以定义这个区域。
*/
Rectangle rect = new Rectangle(0, 0, size, size);

// 提供一个 BufferedImage，将其用作解码像素数据的目标。
param.setSourceRegion(rect);

/*
* 使用所提供的 ImageReadParam 读取通过索引 imageIndex 指定的对象，并将 它作为一个完整的
* BufferedImage 返回。
*/
bi = reader.read(0, param);

// 保存新图片
ImageIO.write(bi, FileUtil.getFileExtention(savePath).substring(1),
new File(savePath));
} finally {
if (is != null)
is.close();
if (iis != null)
iis.close();
}
}

public static void toJPG(File in, File file) {
try {
BufferedImage buffer = ImageIO.read(in);
buffer.setRGB(0, 0, 0);
ImageIO.write(buffer, "JPEG", file);
} catch (Exception e) {
// TODO: handle exception
}
}

public static void main(String[] args) {
try {
//ImageUtil.resize("f:/logo.tif", "f:/logo.jpg", 100, 100, true);

//ImageUtil.resize("f:/004.jpg", "f:/a_11.jpg", 1280, 960, false);
ImageUtil.cutImage("f:/a.jpg", "f:/a_12.jpg", 640, 480);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}