java以目标尺寸按原图片像素比缩放切割图片

package com.yifeng.img;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.awt.image.CropImageFilter;
import java.awt.image.FilteredImageSource;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.imageio.ImageIO;

/**
 * 需求：原始图片缩放为目标尺寸后，要求缩放后的图片保持原图片的样式不改变，但是缩放后图片的四边可以裁减。
 * 原理：将待裁剪图片宽高相除值和目标尺寸宽高相除值进行比较 ，
 * 如果前者较大，说明待裁剪图片相对于目标尺寸来说要宽出一块，现在已高为基准进行裁剪，即将原始图片的高度缩放到目标尺寸的高度。
 * 计算出原始图片高度和目标尺寸高度的比例，和原始图片宽度相乘，得到缩放后的宽度。
 * 此时的缩缩放后的高度就是目标尺寸的高度，但是宽度*肯定*会比目标尺寸宽度宽。 将缩放后的多余的宽度分为两份右边和左边各裁去一份。 以宽为基准原理类似。
 * 
 * @ClassName: ImgUtil
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author RockeyCai
 * @date 2015年11月2日 上午10:25:21
 *
 */
public class ImgUtil {

	/**
	 * 文件信息
	 * 
	 * @ClassName: ImageInfo
	 * @Description: TODO(这里用一句话描述这个类的作用)
	 * @author A18ccms a18ccms_gmail_com
	 * @date 2015年11月2日 下午12:32:11
	 *
	 */
	public enum ImageInfo {

		iPhone5_5("5.5", 1242, 2208),
		iPhone4_7("4.7", 750, 1334),
		iPhone4_0("4.0", 640, 1136),
		iPhone3_5("3.5", 640, 960),
		iPad("iPad", 1536, 2048),
		iPad_Pro("iPad_Pro", 2048, 2723);

		private int width;
		private int height;
		private String imgName;

		private ImageInfo(String imgName, int width, int height) {
			this.width = width;
			this.height = height;
			this.imgName = imgName;
		}

		public int getWidth() {
			return width;
		}

		public void setWidth(int width) {
			this.width = width;
		}

		public int getHeight() {
			return height;
		}

		public void setHeight(int height) {
			this.height = height;
		}

		public String getImgName() {
			return imgName;
		}

		public void setImgName(String imgName) {
			this.imgName = imgName;
		}
	}

	/**
	 * 第一步，等比例压缩图片，第二部，截取图片（根据计算，平均截取）
	 * 
	 * @param srcImgPath
	 *            待切割图片路径
	 * @param destImgPath
	 *            切割后图片路径
	 * @param destImgW
	 *            所需宽度
	 * @param destImgH
	 *            所需高度
	 */
	public static void createThumb(String srcImgPath, String destImgPath, int destImgW, int destImgH) {
		// 原图片等比例缩小或放大之后的图片
		int narrowImgW;
		int narrowImgH;
		// 原图片大小
		int srcImgW;
		int srcImgH;
		try {
			BufferedImage bi = ImageIO.read(new File(srcImgPath));
			srcImgW = bi.getWidth();
			srcImgH = bi.getHeight();
			// 转换图片尺寸与目标尺寸比较 ， 如果转换图片较小，说明转换图片相对于目标图片来说高较小，需要以高为基准进行缩放。
			if ((float) srcImgW / srcImgH > (float) destImgW / destImgH) {
				narrowImgW = (int) (((float) destImgH / (float) srcImgH) * srcImgW);
				narrowImgH = destImgH;
				// 按照原图以高为基准等比例缩放、或放大。这一步高为所需图片的高度，宽度肯定会比目标宽度宽。
				int cutNarrowImgSize = (narrowImgW - destImgW) / 2;
				BufferedImage narrowImg = new BufferedImage(narrowImgW, narrowImgH, BufferedImage.TYPE_INT_RGB);
				narrowImg.getGraphics().drawImage(bi.getScaledInstance(narrowImgW, narrowImgH, Image.SCALE_SMOOTH), 0, 0, null);
				// 等比例缩放完成后宽度与目标尺寸宽度相比较 ， 将多余宽的部分分为两份 ，左边删除一部分
				Image image = narrowImg.getScaledInstance(narrowImgW, narrowImgH, Image.SCALE_DEFAULT);
				CropImageFilter cropFilter = new CropImageFilter(cutNarrowImgSize, 0, narrowImgW - cutNarrowImgSize, narrowImgH);
				Image img = Toolkit.getDefaultToolkit().createImage(new FilteredImageSource(image.getSource(), cropFilter));
				BufferedImage cutLiftNarrowImg = new BufferedImage(narrowImgW - cutNarrowImgSize, narrowImgH, BufferedImage.TYPE_INT_RGB);
				cutLiftNarrowImg.getGraphics().drawImage(img, 0, 0, null);
				// 右边删除一部分
				image = cutLiftNarrowImg.getScaledInstance(narrowImgW - cutNarrowImgSize, narrowImgH, Image.SCALE_DEFAULT);
				cropFilter = new CropImageFilter(0, 0, narrowImgW - cutNarrowImgSize * 2, narrowImgH);
				img = Toolkit.getDefaultToolkit().createImage(new FilteredImageSource(image.getSource(), cropFilter));
				BufferedImage cutRightNarrowImg = new BufferedImage(narrowImgW - cutNarrowImgSize * 2, narrowImgH, BufferedImage.TYPE_INT_RGB);
				Graphics g = cutRightNarrowImg.getGraphics();
				g.drawImage(img, 0, 0, null); // 绘制截取后的图
				g.dispose();
				// 输出为文件 最终为所需要的格式
				ImageIO.write(cutRightNarrowImg, "JPEG", new File(destImgPath));
			} else { // 以宽度为基准
				narrowImgW = destImgW;
				narrowImgH = (int) (((float) destImgW / (float) srcImgW) * srcImgH);
				int cutNarrowImgSize = (narrowImgH - destImgH) / 2;

				BufferedImage narrowImg = new BufferedImage(narrowImgW, narrowImgH, BufferedImage.TYPE_INT_RGB);
				narrowImg.getGraphics().drawImage(bi.getScaledInstance(narrowImgW, narrowImgH, Image.SCALE_SMOOTH), 0, 0, null);

				Image image = narrowImg.getScaledInstance(narrowImgW, narrowImgH, Image.SCALE_DEFAULT);
				CropImageFilter cropFilter = new CropImageFilter(0, cutNarrowImgSize, narrowImgW, narrowImgH - cutNarrowImgSize);
				Image img = Toolkit.getDefaultToolkit().createImage(new FilteredImageSource(image.getSource(), cropFilter));
				BufferedImage cutTopNarrowImg = new BufferedImage(narrowImgW, narrowImgH - cutNarrowImgSize, BufferedImage.TYPE_INT_RGB);
				cutTopNarrowImg.getGraphics().drawImage(img, 0, 0, null);

				image = cutTopNarrowImg.getScaledInstance(narrowImgW, narrowImgH - cutNarrowImgSize, Image.SCALE_DEFAULT);
				cropFilter = new CropImageFilter(0, 0, narrowImgW, narrowImgH - cutNarrowImgSize * 2);
				img = Toolkit.getDefaultToolkit().createImage(new FilteredImageSource(image.getSource(), cropFilter));
				BufferedImage cutBottomNarrowImg = new BufferedImage(narrowImgW, narrowImgH - cutNarrowImgSize * 2, BufferedImage.TYPE_INT_RGB);
				Graphics g = cutBottomNarrowImg.getGraphics();
				g.drawImage(img, 0, 0, null);
				g.dispose();
				ImageIO.write(cutBottomNarrowImg, "JPEG", new File(destImgPath));
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 第一步，等比例压缩图片，第二部，截取图片（以左上角x=0 y=0,截取）
	 * 
	 * @param srcImgPath
	 *            待切割图片路径
	 * @param destImgPath
	 *            切割后图片路径
	 * @param destImgW
	 *            所需宽度
	 * @param destImgH
	 *            所需高度
	 * @throws IOException
	 */
	public static void createThumb2(String srcImgPath, String destImgPath, int destImgW, int destImgH) throws IOException {

		// 原图片等比例缩小或放大之后的图片
		int narrowImgW;
		int narrowImgH;

		// 原图片大小
		int srcImgW;
		int srcImgH;

		// try {
		BufferedImage bi = ImageIO.read(new File(srcImgPath));
		srcImgW = bi.getWidth();
		srcImgH = bi.getHeight();

		// 转换图片尺寸与目标尺寸比较 ， 如果转换图片较小，说明转换图片相对于目标图片来说高较小，需要以高为基准进行缩放。
		if ((float) srcImgW / srcImgH > (float) destImgW / destImgH) {
			narrowImgW = (int) (((float) destImgH / (float) srcImgH) * srcImgW);
			narrowImgH = destImgH;
			// 按照原图以高为基准等比例缩放、或放大。这一步高为所需图片的高度，宽度肯定会比目标宽度宽。
			BufferedImage narrowImg = new BufferedImage(narrowImgW, narrowImgH, BufferedImage.TYPE_INT_RGB);
			narrowImg.getGraphics().drawImage(bi.getScaledInstance(narrowImgW, narrowImgH, Image.SCALE_SMOOTH), 0, 0, null);

			// 等比例缩放完成后宽度与目标尺寸宽度相比较 ， 将多余宽的部分分为两份 ，左边删除一部分
			Image image = narrowImg.getScaledInstance(narrowImgW, narrowImgH, Image.SCALE_DEFAULT);

			// 获取需要部分
			CropImageFilter cropFilter = new CropImageFilter(0, 0, narrowImgW, destImgH);
			Image img = Toolkit.getDefaultToolkit().createImage(new FilteredImageSource(image.getSource(), cropFilter));
			BufferedImage cutRightNarrowImg = new BufferedImage(narrowImgW, destImgH, BufferedImage.TYPE_INT_RGB);

			Graphics g = cutRightNarrowImg.getGraphics();
			g.drawImage(img, 0, 0, null); // 绘制截取后的图
			g.dispose();

			// 输出为文件 最终为所需要的格式
			ImageIO.write(cutRightNarrowImg, "JPEG", new File(destImgPath));

		} else { // 以宽度为基准
			narrowImgW = destImgW;
			narrowImgH = (int) (((float) destImgW / (float) srcImgW) * srcImgH);

			BufferedImage narrowImg = new BufferedImage(narrowImgW, narrowImgH, BufferedImage.TYPE_INT_RGB);
			narrowImg.getGraphics().drawImage(bi.getScaledInstance(narrowImgW, narrowImgH, Image.SCALE_SMOOTH), 0, 0, null);

			Image image = narrowImg.getScaledInstance(narrowImgW, narrowImgH, Image.SCALE_DEFAULT);// 等比例压缩

			// 获取需要部分
			CropImageFilter cropFilter1 = new CropImageFilter(0, 0, narrowImgW, destImgH);
			Image img1 = Toolkit.getDefaultToolkit().createImage(new FilteredImageSource(image.getSource(), cropFilter1));
			BufferedImage cutBottomNarrowImg1 = new BufferedImage(narrowImgW, destImgH, BufferedImage.TYPE_INT_RGB);

			Graphics g = cutBottomNarrowImg1.getGraphics();
			g.drawImage(img1, 0, 0, null);
			g.dispose();
			ImageIO.write(cutBottomNarrowImg1, "JPEG", new File(destImgPath));
		}
		// } catch (IOException e) {
		// //e.printStackTrace();
		// }
	}

	/**
	 * @Title: createImg
	 * @Description: TODO(这里用一句话描述这个方法的作用)
	 * @param @param inputPath 源图片地址
	 * @param @param outputRootPath 保存地址
	 * @param @param imageInfos 生成图片集合
	 * @return void 返回类型
	 * @throws
	 */
	public static void createImg(String inputPath, String outputRootPath, List<ImageInfo> imageInfos) {

		// 要生成的图片列表
		List<File> srcImageList = new ArrayList<File>();

		// 获取要生成的图片列表
		File inputFilePath = new File(inputPath);
		if (inputFilePath.isDirectory()) {
			for (File temp : inputFilePath.listFiles()) {
				if (temp.isFile()) {
					if (temp.getName().toUpperCase().lastIndexOf(".JPG") > -1 || temp.getName().toUpperCase().lastIndexOf(".PNG") > -1) {
						srcImageList.add(temp);
					}
				}
			}
		}

		File file = null;
		// 遍历生成文件
		for (ImageInfo imageInfo : imageInfos) {
			// 生成图片存放的文件夹 E:/mytest/iPhone/4.7
			String createImgDicPath = String.format("%s%s", outputRootPath, imageInfo.imgName);
			// 创建文件夹
			file = new File(createImgDicPath);
			if (!file.exists()) {
				file.mkdirs();
			}

			// 遍历图片集合,生成图片
			for (File srcImgeFile : srcImageList) {
				// 源图片路径 E:/mytest/iPhone/5.5/p1.jpg
				String srcImgPath = srcImgeFile.getPath();
				// 生成图片路径 E:/mytest/iPhone/4.7/p1.jpg
				String createImgName = String.format("%s/%s", createImgDicPath, srcImgeFile.getName());
				try {
					// 生成文件
					createThumb2(srcImgPath, createImgName, imageInfo.width, imageInfo.height);
					System.out.println(String.format("%s 生成完成", createImgName));
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(String.format("%s 生成失败 原因:%s", createImgName, e.getMessage()));
				}

			}
		}
		srcImageList.clear();
		srcImageList = null;
	}

	public static void main(String[] args) {

		// 保存图片地址
		String outputRootPath = "E:/mytest/iPhone/";
		// 源图片文件夹地址
		String inputPath = "E:/mytest/iPhone/5.5/";

		// 生成图片集合
		List<ImageInfo> imageInfos = new ArrayList<ImageInfo>();
		imageInfos.add(ImageInfo.iPhone4_7); // E:/mytest/iPhone/4.7
		imageInfos.add(ImageInfo.iPhone4_0); // E:/mytest/iPhone/4.0
		imageInfos.add(ImageInfo.iPhone3_5); // E:/mytest/iPhone/3.5
		createImg(inputPath, outputRootPath, imageInfos);

		// 生成iPad
		outputRootPath = "E:/mytest/";
		inputPath = "E:/mytest/iPad_Pro/";
		// 输出图片
		imageInfos.clear();
		imageInfos.add(ImageInfo.iPad); // E:/mytest/iPad/
		createImg(inputPath, outputRootPath, imageInfos);

	}

}