imageutil.java

动画素材图像语义标注系统：该系统实现对图片的语义标注

package cn.dxm.client;

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Iterator;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageOutputStream;

/**
 * 图片操作工具类
 * 
 * @author www.NetJava.cn
 * 
 */
public class ImageUtil {

	
	/**
	 * 读取图片
	 * 
	 * @param ref:图片文件名
	 * @return：BufferedImage对象
	 */
	public static BufferedImage loadImage(String ref) {
		BufferedImage bimg = null;
		try {
			long d = 10;
			bimg = ImageIO.read(new File(ref));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return bimg;
	}

	/**
	 * 保存图片文件,比如保存为C:/images/fooimage.png
	 * 
	 * @param img
	 *            :图片对象
	 * @param saveFile
	 *            :文件名
	 */
	public static void saveImage(BufferedImage img, String ref) {
		try {
			String format = (ref.endsWith(".png")) ? "png" : "jpg";
			ImageIO.write(img, format, new File(ref));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 创建有透明度的图片
	 * 
	 * @param url:文件名
	 * @param transperancy:透明度
	 *            0.1~1
	 * @return:图片对象
	 */
	public static BufferedImage loadTranslucentImage(String url,
			float transperancy) {
		// Load the image
		BufferedImage loaded = loadImage(url);
		// Create the image using the
		BufferedImage aimg = new BufferedImage(loaded.getWidth(), loaded
				.getHeight(), BufferedImage.TRANSLUCENT);
		// Get the images graphics
		Graphics2D g = aimg.createGraphics();
		// Set the Graphics composite to Alpha
		g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
				transperancy));
		// Draw the LOADED img into the prepared reciver image
		g.drawImage(loaded, null, 0, 0);
		// let go of all system resources in this Graphics
		g.dispose();
		// Return the image
		return aimg;
	}

	/**
	 * 使图片的某种色彩透明
	 * 
	 * @param ref:图片文件名
	 * @param color:要改成透明的色
	 * @return:图片对象
	 */
	public static BufferedImage makeColorTransparent(String ref, Color color) {
		BufferedImage image = loadImage(ref);
		BufferedImage dimg = new BufferedImage(image.getWidth(), image
				.getHeight(), BufferedImage.TYPE_INT_ARGB);
		Graphics2D g = dimg.createGraphics();
		g.setComposite(AlphaComposite.Src);
		g.drawImage(image, null, 0, 0);
		g.dispose();
		for (int i = 0; i < dimg.getHeight(); i++) {
			for (int j = 0; j < dimg.getWidth(); j++) {
				if (dimg.getRGB(j, i) == color.getRGB()) {
					dimg.setRGB(j, i, 0x8F1C1C);
				}
			}
		}
		return dimg;
	}

	/**
	 * 水平翻转图片
	 * 
	 * @param img
	 * @return
	 */
	public static BufferedImage horizontalflip(BufferedImage img) {
		int w = img.getWidth();
		int h = img.getHeight();
		BufferedImage dimg = new BufferedImage(w, h, img.getType());
		Graphics2D g = dimg.createGraphics();
		g.drawImage(img, 0, 0, w, h, w, 0, 0, h, null);
		g.dispose();
		return dimg;
	}

	/**
	 * 垂直转图片
	 * 
	 * @param img
	 * @return
	 */
	public static BufferedImage verticalflip(BufferedImage img) {
		int w = img.getWidth();
		int h = img.getHeight();
		BufferedImage dimg = new BufferedImage(w, h, img.getColorModel()
				.getTransparency());
		Graphics2D g = dimg.createGraphics();
		g.drawImage(img, 0, 0, w, h, 0, h, w, 0, null);
		g.dispose();
		return dimg;
	}

	
	/**
	 * 将图片顺时钟翻转90度.
	 * 
	 */
	public static BufferedImage turnRightLflip(BufferedImage img) {
		int w = img.getWidth();
		int h = img.getHeight();
		BufferedImage dimg = new BufferedImage(h, w, img.getColorModel().getTransparency());
		Graphics2D g = dimg.createGraphics();
		g.drawImage(img, 0, 0, h, w, 0, h, w, 0, null);
		g.dispose();
		return dimg;
	}
	
	/**
	 * 将图片逆时钟翻转90度.
	 * 
	 */
	public static BufferedImage turnLefthLflip(BufferedImage img) {
		int w = img.getWidth();
		int h = img.getHeight();
		BufferedImage dimg = new BufferedImage(h, w, img.getColorModel().getTransparency());
		Graphics2D g = dimg.createGraphics();
		g.drawImage(img, 0, 0, h, w, w, 0, 0, h, null);
		g.dispose();
		return dimg;
	}
	
	
	/**
	 * 将图片转动指定角度,角度大于零时用.
	 * 
	 * @param img
	 * @param angle
	 * @return
	 */
	public static BufferedImage rotate(BufferedImage img, int angle) {
		int w = img.getWidth();
		int h = img.getHeight();
		BufferedImage dimg = dimg = new BufferedImage(h, w, img.getType());
		Graphics2D g = dimg.createGraphics();
		g.rotate(Math.toRadians(angle), h / 2, h / 2);
		g.drawImage(img, null, 0, 0);
		return dimg;
	}

	
	/**
	 * 将图片转动指定角度,角度小于零时用.
	 * 
	 * @param img
	 * @param angle
	 * @return
	 */
	public static BufferedImage rotate1(BufferedImage img, int angle) {
		int w = img.getWidth();
		int h = img.getHeight();
		BufferedImage dimg = dimg = new BufferedImage(h, w, img.getType());
		Graphics2D g = dimg.createGraphics();
		g.rotate(Math.toRadians(angle), w / 2, w / 2);
		g.drawImage(img, null, 0, 0);
		return dimg;
	}
	
	
	/**
	 * 重设图片大小
	 * 
	 * @param img
	 * @param newW
	 * @param newH
	 * @return
	 */
	public static BufferedImage resize(BufferedImage img, int newW, int newH) {
		int w = img.getWidth();
		int h = img.getHeight();
		BufferedImage dimg = new BufferedImage(newW, newH, img.getType());
		Graphics2D g = dimg.createGraphics();
		g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
				RenderingHints.VALUE_INTERPOLATION_BILINEAR);
		g.drawImage(img, 0, 0, newW, newH, 0, 0, w, h, null);
		g.dispose();
		return dimg;
	}

	/**
	 * 将图片转化为Byte字节
	 * 
	 * @param image:BufferedImage对象
	 * @param quality:质量级别
	 *            0.0~0.9
	 * @return
	 */
	public static byte[] toByteArray(BufferedImage image, float quality) {
		try {
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			if (quality == -1)
				ImageIO.write(image, "jpeg", out); // write without compression
			else
				write(image, quality, out); // write with compression
			return out.toByteArray();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

	public static void write(BufferedImage image, float quality,
			OutputStream out) throws IOException {
		Iterator writers = ImageIO.getImageWritersBySuffix("jpeg");
		if (!writers.hasNext()) {
			throw new IllegalStateException("No writers found");
		}
		ImageWriter writer = (ImageWriter) writers.next();
		ImageOutputStream ios = ImageIO.createImageOutputStream(out);
		writer.setOutput(ios);
		ImageWriteParam param = writer.getDefaultWriteParam();
		if (quality >= 0) {
			param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
			param.setCompressionQuality(quality);
		}
		writer.write(null, new IIOImage(image, null, null), param);
		ios.close();
		writer.dispose();
	}

	/**
	 * 将byte数组转化为图片
	 * 
	 * @param bytes
	 * @return
	 */
	public static BufferedImage read(byte[] bytes) {
		try {
			return read(new ByteArrayInputStream(bytes));
		} catch (IOException e) {
			e.getStackTrace();
			return null;
		}
	}

	public static BufferedImage read(InputStream in) throws IOException {
		BufferedImage image = null;
		image = ImageIO.read(in);
		if (image == null)
			throw new IOException("Read fails");
		return image;
	}

	/**
	 * 将图片分割为图片组，在做动画游戏时用
	 * 
	 * @param img
	 * @param cols
	 *            :行数
	 * @param rows
	 *            :列数
	 * @return :图片对象数组
	 */
	public static BufferedImage[] splitImage(BufferedImage img, int cols,
			int rows) {
		int w = img.getWidth() / cols;
		int h = img.getHeight() / rows;
		int num = 0;
		BufferedImage imgs[] = new BufferedImage[w * h];
		for (int y = 0; y < rows; y++) {
			for (int x = 0; x < cols; x++) {
				imgs[num] = new BufferedImage(w, h, img.getType());
				// Tell the graphics to draw only one block of the image
				Graphics2D g = imgs[num].createGraphics();
				g.drawImage(img, 0, 0, w, h, w * x, h * y, w * x + w,
						h * y + h, null);
				g.dispose();
				num++;
			}
		}
		return imgs;
	}
}