java 图片缩放、裁剪。

1、缩放图片（源图片大小按多个尺寸压缩）

压缩规格： 1、实际图宽 / 图宽、实际图高 / 图高，取最小比值；
                     2、最小比值大于1，按最小比值进行缩放；
                     3、最小比值小于1，不变化。

2、裁剪图片（压缩图片按指定尺寸进行裁剪）

裁剪规则：1、裁剪点x,y；x为宽、y为高

    2、裁剪点计算：x = （缩放图片宽-图宽）/  2

                                                  y = （缩放图片高-图高）/  2

package com.ninepoint.babystar.test.action;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.awt.image.CropImageFilter;
import java.awt.image.FilteredImageSource;
import java.awt.image.ImageFilter;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Iterator;

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

import org.jfree.chart.plot.Zoomable;
/**
 * 图片缩放、切割
 * 1、图宽：实际图宽=图宽比
 *    图高：实际图稿=图高比
 * 2、图宽比与图高比，取最小值
 * 3、最小比值是否大于1
 *    3.1、大于1     成比例缩放
 *    3.2、小于1     取最小的宽
 * 4、切割 以中间段切割（图片格式都是PNG）
 */
/**
 * 
 * @Description  图片缩放、切割
 * @author nier_ni
 * @date 2015-9-17 下午07:47:15 
 * @version
 */
public class ImgZoomAndCut {
private static List<String> tables = null;
	static{
		tables  = new ArrayList<String>();
		try{
		   InputStream in = KeyWordFilter.class.getClassLoader().getResourceAsStream("picture.properties.txt");
		   Properties pro = new Properties();
		   pro.load(in);
		   Enumeration enu = pro.propertyNames(); 
		   while(enu.hasMoreElements()){
			   String table = Pattern.compile(new String(((String)enu.nextElement()).getBytes("ISO-8859-1"), "UTF-8")).toString();
			   tables.add(table);
		   }
		}catch(IOException ioEx){
			ioEx.printStackTrace();
		}
	}
	/**
     * 
     * @Description 图片按多个尺寸压缩切割
     */
    public static void PictureBySizeCompressionCutting(String picPath){
    	for(int i = 0; i < tables.size(); i++){
    		System.out.println(tables.get(i));
    		String[] strs = tables.get(i).split(",");
    		imgZoomAndCutDemo(picPath,Integer.parseInt(strs[0]),Integer.parseInt(strs[1]));
    	}
    }
	/**
	 * 
	 * @Description 图片成比例缩放
	 * @param srcImageFile 源图像文件地址
	 * @param result 缩放后的图像地址
	 * @param scale 缩放比例
	 * @param flag 缩放选择:true 放大; false 缩小;
	 */
	private static int x = 0;
	private static int y = 0;
	public static void imgZoom(String srcImageFile, String result, int scale, boolean flag){
	  try {
            BufferedImage src = ImageIO.read(new File(srcImageFile)); // 读入文件
            int width = src.getWidth(); // 得到源图宽
            int height = src.getHeight(); // 得到源图长
            if (flag) {// 放大
                width = width * scale;
                height = height * scale;
            } else {// 缩小
                width = width / scale;
                height = height / scale;
            }
            Image image = src.getScaledInstance(width, height,
                    Image.SCALE_DEFAULT);
            BufferedImage tag = new BufferedImage(width, height,
                    BufferedImage.TYPE_INT_RGB);
            Graphics g = tag.getGraphics();
            g.drawImage(image, 0, 0, null); // 绘制缩小后的图
            g.dispose();
            ImageIO.write(tag, "PNG", new File(result));// 输出到文件流
        } catch (IOException e) {
            e.printStackTrace();
        }
	}
	 /**
     * @Description 图像切割(按指定起点坐标和宽高切割)
     * @param srcImageFile 源图像地址
     * @param result 切片后的图像地址
     * @param x 目标切片起点坐标X
     * @param y 目标切片起点坐标Y
     * @param width 目标切片宽度
     * @param height 目标切片高度
     */
    public final static void ImgCut(String srcImageFile, String result,
            int x, int y, int width, int height) {
        try {
            // 读取源图像
        	System.out.println("切割图片大小Width：" + width + ",Height:" + height);
            BufferedImage bi = ImageIO.read(new File(srcImageFile));
            int srcWidth = bi.getHeight(); // 源图宽度
            int srcHeight = bi.getWidth(); // 源图高度
            if (srcWidth > 0 && srcHeight > 0) {
                Image image = bi.getScaledInstance(srcWidth, srcHeight,
                        Image.SCALE_DEFAULT);
                // 四个参数分别为图像起点坐标和宽高
                // 即: CropImageFilter(int x,int y,int width,int height)
                ImageFilter cropFilter = new CropImageFilter(x, y, width, height);
                Image img = Toolkit.getDefaultToolkit().createImage(
                        new FilteredImageSource(image.getSource(),
                                cropFilter));
                BufferedImage tag = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
                Graphics g = tag.getGraphics();
                g.drawImage(img, 0, 0, width, height, null); // 绘制切割后的图
                g.dispose();
                // 输出为文件
                ImageIO.write(tag, "PNG", new File(result));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
	/**
	 * 
	 * @Description  计算图片缩放比例
	 * @param srcImageFile 源图像地址
	 * @param width 实际图片宽
	 * @param height 实际图片高
	 * @return
	 */
	public static int scaling(String srcImageFile,int width, int height){
		int smallValue = 0;
		try {
            // 读取源图像
            BufferedImage bi = ImageIO.read(new File(srcImageFile));
            int srcWidth = bi.getHeight(); // 源图宽度
            int srcHeight = bi.getWidth(); // 源图高度
            int scaleWidth = srcWidth/width;
            int scaleHeight = srcHeight/height;
            //获取比例最小值
            smallValue = intCompare(scaleWidth,scaleHeight);
		} catch (Exception e) {
            e.printStackTrace();
        }
		return smallValue;
	}
	/**
	 * @Description 两个数字取最小值（int类型）
	 * @param scaleWidth 宽比值
	 * @param scaleHeight 高比值
	 * @return
	 */
	public static int intCompare(int scaleWidth, int scaleHeight){
		int result = 0;
	    if (scaleWidth > scaleHeight) {  
	        result = scaleHeight;  
	    }else if (scaleWidth < scaleHeight) {  
	        result = scaleWidth;  
	    }else if (scaleWidth == scaleHeight) {  
	        result = scaleWidth;  
	    }
		return result;
	}
	/**
	 * 
	 * @Description 计算图片的切割点
	 * @param zoomImageFile 缩放图片地址
	 * @param width 实际图片宽
	 * @param height 实际图片高
	 */
	public static void cutPosition(int cutType,String zoomImageFile,double width, double height){
		try {
            // 读取源图像
			System.out.println("读取源图像:" + zoomImageFile);
            BufferedImage bi = ImageIO.read(new File(zoomImageFile));
            double srcWidth = bi.getHeight(); // 源图宽度
            double srcHeight = bi.getWidth(); // 源图高度
            System.out.println("源图宽度:"+srcWidth +",源图高度:" + srcHeight + "。");
            switch (cutType) {
			case 1:
				if(srcWidth > width){
	            	x = (int)(srcWidth/2 - width/2);
	            }
	            if(srcHeight > height){
	            	y = (int)(srcHeight/2 - height/2);
	            }
				break;
			case 0:
				if(srcWidth == width){
					x = 0;
				}else{
					x = (int)srcWidth/2;
				}
				if(srcHeight == height){
					y = 0;
				}else{
					y = (int)srcHeight/2;
				}
				break;
			default:
				if(srcWidth > width){
	            	x = (int)(srcWidth/2 - (width*cutType)/2);
	            }
	            if(srcHeight > height){
	            	y = (int)(srcHeight/2 - (height*cutType)/2);
	            }
				break;
			}
            System.out.println("切割:" + x +",切割y:" + y + "。");
		} catch (Exception e) {
            e.printStackTrace();
        }
	}
	/**
	 * 
	 * @Description 获得缩放图片的地址
	 * @param srcImageFile 源图像文件地址
	 * @param scale 缩放比例
	 * @return
	 */
	public static String zoomFileName(String srcImageFile,int scale){
		StringBuffer filePath = new StringBuffer();
		String strs[] = filePathSplit(srcImageFile);
		if(strs.length > 1){
			filePath.append(strs[0]);
			filePath.append("\\");
			filePath.append(strs[1]);
			filePath.append("_");
			filePath.append(scale);
			filePath.append(".png");
		}
		return filePath.toString();
	}
	/**
	 * 
	 * @Description 获取切割图片的地址
	 * @param zoomImageFile 缩放图片地址
	 * @param width 实际图片宽
	 * @param height 实际图片高
	 * @return
	 */
	public static String cutFileName(int isZoom,String zoomImageFile,int width, int height){
		StringBuffer filePath = new StringBuffer();
		String strs[] = filePathSplit(zoomImageFile);
		if(strs.length > 1){
			filePath.append(strs[0]);
			filePath.append("\\");
			if(isZoom == 1){
				filePath.append(strs[1].substring(0, strs[1].lastIndexOf("_")));
			}else{
				filePath.append(strs[1]);
			}
			filePath.append("_");
			filePath.append(width);
			filePath.append("_");
			filePath.append(height);
			filePath.append(".png");
		}
		return filePath.toString();
	}
	/**
	 * 
	 * @Description 分离路径与文件名（文件名不包含扩展名）
	 * @param filePath 文件全路径
	 * @return
	 */
	public static String[] filePathSplit(String filePath){
		//System.out.println("路径：" + filePath);
		String strs[] = new String[2];
		strs[0] = filePath.substring(0, filePath.lastIndexOf("\\"));
		String fileName = filePath.substring(filePath.lastIndexOf("\\")+1);
		fileName = fileName.substring(0,fileName.lastIndexOf("."));
		strs[1] = fileName;
		return strs;
	}
	/**
	 * 
	 * @Description 先缩放后切割 
	 * @param srcImageFile 源图像文件地址
	 * @param width 实际图片宽
	 * @param height 实际图片高
	 */
	public static void imgZoomAndCutDemo(String srcImageFile,int width, int height){
		/**
		 * 1、图片缩放比例
		 * 2、图片缩放
		 * 3、切割点
		 * 4、图片切割
		 */
		try {
			int picWidth = width;
			int picHeight = height;
			int isZoom = 0;//是否压缩
			BufferedImage bi = ImageIO.read(new File(srcImageFile));
	        int srcWidth = bi.getHeight(); // 源图宽度
	        int srcHeight = bi.getWidth(); // 源图高度
			int scale = scaling(srcImageFile,width,height);
			String zoomFileName = srcImageFile;
			if(scale > 1){
				zoomFileName = zoomFileName(srcImageFile,scale);
				imgZoom(srcImageFile, zoomFileName, scale, false);
				isZoom = 1;
				cutPosition(1,zoomFileName,picWidth,picHeight);
			}else if(scale < 1){
				int length = intCompare(srcWidth,srcHeight);
				picWidth = length;
				picHeight = length;
				cutPosition(scale,zoomFileName,picWidth,picHeight);
			}else if(scale == 1){
				int length = intCompare(srcWidth,srcHeight);
				picWidth = length;
				picHeight = length;
				cutPosition(scale,zoomFileName,picWidth,picHeight);
			}
			String cutFileName = cutFileName(isZoom,zoomFileName, width, height);
			cutPic(zoomFileName, cutFileName, y, x, picWidth, picHeight);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	/**
	 * 
	 * @Description 先切割后缩放
	 * @author Administrator
	 * @param srcImageFile
	 * @param width
	 * @param height
	 */
	/**public static void imgCutAndZoomDemo(String srcImageFile,int width, int height){
		/**
		 * 1、切割点
		 * 2、图片切割
		 * 3、图片缩放比例s
		 * 4、图片缩放
		int scale = scaling(srcImageFile,width,height);
		System.out.println("图片缩放：" + scale + "倍。");
		String cutFileName = cutFileName(1,srcImageFile, width, height);
		//获取切割点
		cutPosition(scale,srcImageFile,width,height);
		System.out.println("切割点：" + x + "," + y + "。");
		ImgCut(srcImageFile, cutFileName, y, x, width*scale, height*scale);
		String zoomFileName = zoomFileName(cutFileName,scale);
		imgZoom(cutFileName, zoomFileName, scale, false);
	}*/
	public static void main(String[] args) {
		//imgZoom("D:\\photo\\ImgZoom\\grass.jpg","D:\\photo\\ImgZoom\\grass_2.png",2,false);
		//ImgCut("D:\\photo\\ImgZoom\\grass_2.png","D:\\photo\\ImgZoom\\grass_3.png",0,0,200,200);
		imgZoomAndCutDemo("D:\\photo\\ImgZoom\\grass.jpg",200,200);
		//imgZoomAndCutDemo("D:\\photo\\ImgZoom\\small.jpg",500,500);
		//imgZoomAndCutDemo("D:\\photo\\ImgZoom\\small.jpg",200,200);
		//imgZoomAndCutDemo("D:\\photo\\ImgZoom\\grass_4.png",213,213);
		//imgZoomAndCutDemo("D:\\photo\\ImgZoom\\height.png",327,327);
		//imgCutAndZoomDemo("D:\\photo\\ImgZoom\\CutAndZoom\\grass.jpg",200,200);
		//ImgCut("D:\\photo\\ImgZoom\\grass.jpg","D:\\photo\\ImgZoom\\grass1.jpg",0,0,200,200);
		//cutPic("D:\\photo\\ImgZoom\\grass.jpg","D:\\photo\\ImgZoom\\grass2.jpg",0,0,200,200);
	}
	 /** 
     * @param srcFile源文件 
     * @param outFile输出文件 
     * @param x坐标 
     * @param y坐标 
     * @param width宽度 
     * @param height高度 
     * @return 
     * @作者 王建明 
     * @创建日期 2012-8-2 
     * @创建时间 下午02:05:03 
     * @描述 —— 裁剪图片 
     */  
    public static boolean cutPic(String srcFile, String outFile, int x, int y,  
            int width, int height) {  
        FileInputStream is = null;  
        ImageInputStream iis = null;  
        try {  
            // 如果源图片不存在  
            if (!new File(srcFile).exists()) {  
                return false;  
            }  
  
            // 读取图片文件  
            is = new FileInputStream(srcFile);  
  
            // 获取文件格式  
            String ext = srcFile.substring(srcFile.lastIndexOf(".") + 1);  
  
            // ImageReader声称能够解码指定格式  
            Iterator<ImageReader> it = ImageIO.getImageReadersByFormatName(ext);  
            ImageReader reader = it.next();  
  
            // 获取图片流  
            iis = ImageIO.createImageInputStream(is);  
  
            // 输入源中的图像将只按顺序读取  
            reader.setInput(iis, true);  
  
            // 描述如何对流进行解码  
            ImageReadParam param = reader.getDefaultReadParam();  
  
            // 图片裁剪区域  
            Rectangle rect = new Rectangle(x, y, width, height);  
  
            // 提供一个 BufferedImage，将其用作解码像素数据的目标  
            param.setSourceRegion(rect);  
  
            // 使用所提供的 ImageReadParam 读取通过索引 imageIndex 指定的对象  
            BufferedImage bi = reader.read(0, param);  
  
            // 保存新图片  
            File tempOutFile = new File(outFile);  
            if (!tempOutFile.exists()) {  
                tempOutFile.mkdirs();  
            }  
            ImageIO.write(bi, ext, new File(outFile));  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        } finally {  
            try {  
                if (is != null) {  
                    is.close();  
                }  
                if (iis != null) {  
                    iis.close();  
                }  
            } catch (IOException e) {  
                e.printStackTrace();  
                return false;  
            }  
        }  
    }  
}