JAVA 图像操作辅助类

package util;

import java.awt.Component;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.image.CropImageFilter;
import java.awt.image.FilteredImageSource;
import java.awt.image.ImageFilter;
import java.awt.image.ImageProducer;

/**
 * 图像操作辅助类
 * 
 * @author hellokitty燕
 *
 */
public class ImageUtils {

    private ImageUtils() {
    }

    /**
     * 使用媒体追踪器加载单张图像
     * 
     * @param mediaTracker
     *            媒体追踪器
     * @param image
     *            待加载图像
     * @return 加载完毕的图像
     */
    public static Image addImage(MediaTracker mediaTracker, Image image) {
        // 将图片放置到媒体追踪器的图片列表中，准备开始加载工作
        mediaTracker.addImage(image, 0);
        try {
            // 加载所有图片
            mediaTracker.waitForAll();
        } catch (InterruptedException e) {
            System.err.println(e.getMessage());
        }
        // 官方提供的标准处理代码
        // & -- 按位与运算
        // 如满足条件表达式，则说明图像加载出错
        // statusAll(false) -- 返回媒体跟踪器跟踪的所有媒体状态，如图像未加载，也不会进行加载
        if ((mediaTracker.statusAll(false) & MediaTracker.ERRORED) != 0) {
            System.err.println("图片加载出错...");
        }
        return image;
    }

    /**
     * 使用媒体追踪器加载多张图像（一维数组）
     * 
     * @param mediaTracker
     *            媒体追踪器
     * @param images
     *            待加载的一维数组中的图像
     * @return 加载完毕的图像
     */
    public static Image[] addImage(MediaTracker mediaTracker, Image[] images) {
        for (int i = 0; i < images.length; i++) {
            mediaTracker.addImage(images[i], i);
        }
        try {
            mediaTracker.waitForAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 官方提供的标准处理代码
        // & -- 按位与运算
        // 如满足条件表达式，则说明图像加载出错
        // statusAll(false) -- 返回媒体跟踪器跟踪的所有媒体状态，如图像未加载，也不会进行加载
        if ((mediaTracker.statusAll(false) & MediaTracker.ERRORED) != 0) {
            System.err.println("图片加载出错...");
        }
        return images;
    }

    /**
     * 使用媒体追踪器加载多张图像（二维数组）
     * 
     * @param mediaTracker
     *            媒体追踪器
     * @param images
     *            待加载的二维数组中的图像
     * @return 加载完毕的图像
     */
    public static Image[][] addImage(MediaTracker mediaTracker, Image[][] images) {
        for (int i = 0; i < images.length; i++) {
            for (int j = 0; j < images[i].length; j++) {
                mediaTracker.addImage(images[i][j], i);
            }
        }
        try {
            mediaTracker.waitForAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 官方提供的标准处理代码
        // & -- 按位与运算
        // 如满足条件表达式，则说明图像加载出错
        // statusAll(false) -- 返回媒体跟踪器跟踪的所有媒体状态，如图像未加载，也不会进行加载
        if ((mediaTracker.statusAll(false) & MediaTracker.ERRORED) != 0) {
            System.err.println("图片加载出错...");
        }
        return images;
    }

    /**
     * 将传入的图片进行裁剪，裁剪后生成图像放入一维数组中保存，再进行图像加载。 通常用于裁剪所有图像在一行中的源图像
     * 
     * @param img
     *            待裁剪图像
     * @param count
     *            裁剪后的图像数量
     * @param x
     *            开始裁剪x坐标
     * @param y
     *            开始裁剪y坐标
     * @param width
     *            每次裁剪图像宽度
     * @param height
     *            每次裁剪图像高度
     * @param changeX
     *            每次裁剪需要改变的x坐标值
     * @param mediaTracker
     *            媒体追踪器
     * @param component
     *            用来创建裁剪后的每个图片对象的组件
     * @return 裁剪完并加载到内存后的一维图片数组
     */
    public static Image[] cutAndAddImage(Image img, int count, int x, int y,
            int width, int height, int changeX, MediaTracker mediaTracker,
            Component component) {
        // 创建保存裁剪后图像的一维数组
        Image[] images = new Image[count];
        /* 循环裁剪图像 */
        ImageProducer producer = img.getSource(); // 获取图像源
        for (int i = 0; i < count; i++) {
            // 创建用于裁剪的图像过滤器
            ImageFilter cropImageFilter = new CropImageFilter(x + i * changeX,
                    y, width, height);
            // 裁剪源图像，将裁剪后的图像放入数组保存
            images[i] = component.createImage(new FilteredImageSource(producer,
                    cropImageFilter));
        }

        // 调用 使用媒体追踪器加载多张图像（一维数组） 的方法完成图像加载
        return addImage(mediaTracker, images);
    }

    /**
     * 将传入的图片进行裁剪，裁剪后生成图像放入二维数组中保存，再进行图像加载 通常用于裁剪所有图像在多行多列中的源图像
     * 
     * @param img
     *            待裁剪图像
     * @param rows
     *            裁剪后的图像行数，即垂直方向上需要裁剪出的图片数量
     * @param columns
     *            裁剪后的图像列数，即水平方向上需要裁剪出的图片数量
     * @param x
     *            开始裁剪x坐标
     * @param y
     *            开始裁剪y坐标
     * @param width
     *            每次裁剪图像宽度
     * @param height
     *            每次裁剪图像高度
     * @param changeX
     *            每次裁剪需要改变的x坐标值
     * @param changeY
     *            每次裁剪需要改变的y坐标值
     * @param mediaTracker
     *            媒体追踪器
     * @param component
     *            用来创建裁剪后的每个图片对象的组件
     * @return 裁剪完并加载到内存后的二维图片数组
     */
    public static Image[][] cutAndAddImage(Image img, int rows, int columns,
            int x, int y, int width, int height, int changeX, int changeY,
            MediaTracker mediaTracker, Component component) {
        // 创建剪裁后图像保存的二维数组
        Image[][] images = new Image[rows][columns];
        // 获取图像源
        ImageProducer producer = img.getSource();
        /* 循环剪裁图像 */
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                // 创建用于剪裁图像的过滤器
                ImageFilter cropImageFilter = new CropImageFilter(x + j
                        * changeX, y + i * changeY, width, height);
                // 剪裁源图像，保存剪裁后的图像
                images[i][j] = component.createImage(new FilteredImageSource(
                        producer, cropImageFilter));

            }
        }
        // 调用 使用媒体追踪器加载多张图像（二维数组） 的方法完成图像加载
        return addImage(mediaTracker, images);
    }
}