一提到JAVA，谈论最多的就是JSP/SERVLET/J2EE之类的，但对于用JAVA对图片进行效果变换，到论坛里看了看，关于这方面的话题并不多，网上关于图像效果处理的文章也并不丰富，于是在自己摸索了几天，并且参考了AnfyJava(专业级的JAVA效果生成器)后，我用轻量级控件写了一个(AnfyJava继承的是Applet，Applet是java.awt包中的，属于重量级控件，SUN现在推荐使用swing来编写图形程序，因此，我用的是JApplet)。
其实，用JAVA做图像效果和其它语言在本质上并没有什么区别，只不过在实现起来有所不同罢了，下面我就把我在项目中处理的经验与大家分享一下吧。
图像的变换，实际上就是把两幅图片的内容进行某些运算，生成新的图像，然后显示出来，最终实现从一幅图片到另一幅图片的过度效果。变换的具体过程如下：
在上面的过程中，图片A和B的尺寸最好保持一致，如果不一致的话，可能要做一些额外的处理，在此，我选用的图片A和B的尺寸是一致的。
首先，我们将其当作一个Applet来写，由于Applet的局限性，不可以直接使用File类来读取图像文件，因此，我们只能通过如下方法来获取图像文件。
URLClassLoader urlLoader = (URLClassLoader)this.getClass().getClassLoader();
URL url = urlLoader.findResource("imagea.gif");
Image image = Toolkit.getDefaultToolkit().getImage(url);
当我们获得了图像后，可以通过java.awt.image.PixelGrabber包中的PixelGrabber方法来将图像中的像素信息完全读取出来，其用法如下：
PixelGrabber(Image img, int x, int y, int w, int h, int[] pix, int off, int scansize)
其中img是要读取的图像，x/y是要读取图像中的左上角坐标，w/h分别是从x/y开始起的距离，其实x,y,w,h就是一个矩形，pix是保存像素的数组，off是读取图像时开始的位置，scansize是指扫描的宽度，一般来说和w相等。
int width = image.getWidth();
int height = image.getHeight();
int size = width * height;
int[] pixels = new int[size];
pixelgrabber = new PixelGrabber(image, 0, 0, width, height, pixels, 0, width);
try {
pixelgrabber.grabPixels(); //读取像素入数组
}
catch (InterruptedException _ex) {}
由于像素信息是由alpha,red,green,blue组成的，其格式为
因此，我们可以将颜色分解成单独的RGB信息
int alpha = (pixel >> 24) & 0xff;
int red = (pixel >> 16) & 0xff;
int green = (pixel >> 8) & 0xff;
int blue = (pixel) & 0xff;
假如要实现显示图片A后，图片B由上至下展开，则可以每次将图片A中的一行像素替换为B中的相应行，然后生成新的像素信息：
图像A的像素数组 图像B的像素数组
old = pixelA; //保存图片A的像素信息
oldR = redA; //保存图片A的R信息
oldG = greenA; //保存图片A的G信息
oldB = blueA; //保存图片A的B信息for (int i = 0; i < width; i++) { //line为行数
oldR[line * width + i] = redA [line * width + i];
oldG[line * width + i] = greenA [line * width + i];
oldB[line * width + i] = blueA [line * width + i];
old[line * width + i] = oldR[line * width + i] << 16 + oldG[line * width + i] << 8 + oldB[line * width + i];
}
当生成新的像素信息后，可以通过java.awt.image.MemoryImageSource包中的MemoryImageSource(int w, int h, ColorModel cm, int[] pix, int off, int scan)方法将像素数组对应到图像，并且可以用newPixels()方法来生成新的图像(具体用法可以参考JAVA API DOC)。
memoryimagesource = new MemoryImageSource(imageWidth, imageHeight,
new DirectColorModel(24, 0xff0000, 0x00ff00, 0x0000ff), blocks, 0, imageWidth);
//检查java版本
String javaVersion;
try {
javaVersion = System.getProperty("java.version");
}
catch (SecurityException _ex) {
javaVersion = "unk";
}
if (!javaVersion.startsWith("1.0")) { //jdk1.1以上的版本才支持此方法
try {
memoryimagesource.setAnimated(true);
memoryimagesource.setFullBufferUpdates(true);
imageBuf = createImage(memoryimagesource);
memoryimagesource.newPixels(); //生成新的图像
}
catch (NoSuchMethodError _ex) {
System.out.println("unknow java version!");
}
}
到此，新的图像已经产生，只需要输出到屏幕即可。
在此，需要注意以下几个问题：
1、 由于Applet读取的图像文件可以比较大，对于速度较慢的网络，可能会造成图像未读取完全就开始进行变换，因此，建议使用MediaTracker方法来保证图像能被顺利载入。
2、 在显示的时候，为了避免闪烁，可以采用双缓冲的方法。
3、 由于在某此高速计算机上，生成新的像素可以非常快，为了避免速度过快而造成效果并不明显，可以加以适当的延时处理。
4、 为了保证效果的平滑，我们特地开辟了非常大的数组来保存像素/RGB信息，这是以空间换时间的做法。
完整的源程序附下(在jdk1.4/2k Server/RedHat9下运行通过，所用机器为P4 2.4G/512M)
/*程序只给出了一个从上向下展开的例子，并且申明的变量redA等并没有使用，如果考虑到要做其它更复杂的效果变换，可以查阅相关资料，找到各种变换效果的公式即可(此时redA等就会用上了)*/
package pic;
import java.awt.*;
import java.io.*;
import java.net.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.swing.*;
public class effect
extends JApplet
implements Runnable {
//定义变量
Toolkit toolkit;
int totalBlocks = 0; //图像被分解成的块数，默认为 宽X高
int[] blocks; //保存块数的信息
Image[] bufferImage = new Image[2]; //屏幕上的图形缓冲
VolatileImage offScreenImage;
Image imageBuf; //保存图片缓冲区内容
Graphics2D offScreenGraphics;
Thread thread;
MediaTracker mediaTracker;
boolean[] isImageReady; //图片是否已经装载
MemoryImageSource memoryimagesource;
int imageWidth, imageHeight; //图像的宽及高
int[] pixelA, pixelB;
int[] redA, greenA, blueA, redB, greenB, blueB;
public effect() throws HeadlessException {
bufferImage[0] = getImage("a.jpg");
bufferImage[1] = getImage("b.jpg");
if ( (bufferImage[0].getWidth(this) != bufferImage[1].getWidth(this)) ||
(bufferImage[0].getHeight(this) != bufferImage[1].getHeight(this))) {
System.out.println("图像尺寸不一致！");
return;
}
toolkit = getToolkit();
imageWidth = bufferImage[0].getWidth(this);
imageHeight = bufferImage[0].getHeight(this);
totalBlocks = imageWidth * imageHeight; //计算分解的块数
blocks = new int[totalBlocks];
pixelA = new int[totalBlocks];
pixelB = new int[totalBlocks];
redA = new int[totalBlocks];
greenA = new int[totalBlocks];
blueA = new int[totalBlocks];
redB = new int[totalBlocks];
greenB = new int[totalBlocks];
blueB = new int[totalBlocks];
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gd = ge.getDefaultScreenDevice();
GraphicsConfiguration gc = gd.getDefaultConfiguration();
offScreenImage = gc.createCompatibleVolatileImage(imageWidth, imageHeight); //创建图像缓冲
offScreenGraphics = offScreenImage.createGraphics(); //取得缓冲的graphics对象
}
public void init() {
getImagePixels(bufferImage[0], pixelA);
getImagePixels(bufferImage[1], pixelB);
for (int i = 0; i < totalBlocks; i++) {
blocks[i] = pixelA[i]; //保存图像A的像素信息
redA[i] = pixelA[i] & 0xff0000; //保存图像B的red值
greenA[i] = pixelA[i] & 0x00ff00; //保存图像B的green值
blueA[i] = pixelA[i] & 0x0000ff; //保存图像B的blue值
redB[i] = pixelB[i] & 0xff0000; //保存图像B的red值
greenB[i] = pixelB[i] & 0x00ff00; //保存图像B的green值
blueB[i] = pixelB[i] & 0x0000ff; //保存图像B的blue值
}
prepareImagePixels(); //将像素信息还原为图像
}
public void run() {
//检查java版本
String javaVersion;
try {
javaVersion = System.getProperty("java.version");
}
catch (SecurityException _ex) {
javaVersion = "unk";
}
if (javaVersion.startsWith("1.0")) {
System.out.println("require java 1.1 or later version!");
return;
}
try { //暂停3秒钟后等待效果开始
thread.sleep(3000l);
}
catch (InterruptedException ex1) {
}
int line = 0;
Thread currentThread = Thread.currentThread();
while (line < imageHeight && thread == currentThread) {
for (int i = 0; i < imageWidth; i++) {
int offset = line * imageWidth + i;
blocks[offset] = pixelB[offset]; //与下一被注释的语句作用相同
//blocks[offset] = redB[offset] | greenB[offset] | blueB[offset];
}
memoryimagesource.newPixels(); //生成新的图像
line++;
repaint();
//适当延时
try {
thread.sleep(20l);
}
catch (InterruptedException ex) {
}
}
}
public void paint(Graphics g) {
if (offScreenGraphics != null) { //保证在destory()时不引发异常
offScreenGraphics.drawImage(imageBuf, 0, 0, this);
g.drawImage(offScreenImage, 0, 0, this);
}
}
public void start() {
if (thread == null) {
thread = new Thread(this);
thread.start();
}
}
public void stop() {
thread = null;
}
public final void update(Graphics g) {
paint(g);
}
public void destroy() {
if (offScreenImage != null) {
offScreenImage.flush();
}
offScreenImage = null;
if (offScreenGraphics != null) {
offScreenGraphics.dispose();
}
offScreenGraphics = null;
System.gc();
}
/**
* 通过给定的文件名获得图像
* @param filename 给定图像的文件名
* @return 图像
*/
Image getImage(String filename) {
URLClassLoader urlLoader = (URLClassLoader)this.getClass().getClassLoader();
URL url = null;
Image image = null;
url = urlLoader.findResource(filename);
image = Toolkit.getDefaultToolkit().getImage(url);
MediaTracker mediatracker = new MediaTracker(this);
try {
mediatracker.addImage(image, 0);
mediatracker.waitForID(0);
}
catch (InterruptedException _ex) {
image = null;
}
if (mediatracker.isErrorID(0)) {
image = null;
}
return image;
}
/**
* 取得给定图像的像素数组
* @param image 指定的图像
* @param pixels 保存像素信息的数组
* @return 成功返回true
*/
private boolean getImagePixels(Image image, int pixels[]) {
PixelGrabber pixelgrabber = new PixelGrabber(image, 0, 0, imageWidth,
imageHeight, pixels,
0, imageWidth);
try {
pixelgrabber.grabPixels();
}
catch (InterruptedException _ex) {
return false;
}
return true;
}
/**
* 将像素数组还原为图像
*/
void prepareImagePixels() {
memoryimagesource = new MemoryImageSource(imageWidth, imageHeight,
new DirectColorModel(24, 0xff0000,
0x00ff00, 0x0000ff), blocks, 0, imageWidth);
try {
memoryimagesource.setAnimated(true);
memoryimagesource.setFullBufferUpdates(true);
imageBuf = createImage(memoryimagesource);
memoryimagesource.newPixels(); //生成新的图像
}
catch (NoSuchMethodError _ex) {
}
}
/**
* 取得图像的宽度
* @return 宽度
*/
public int getWidth() {
return imageWidth;
}
/**
* 取得图像的高度
* @return 高度
*/
public int getHeight() {
return imageHeight;
}
public static void main(String args[]) {
JFrame frame = new JFrame("Demo");
effect e = new effect();
e.init();
e.start();
frame.getContentPane().setLayout(new BorderLayout());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setResizable(false);
frame.getContentPane().add(e);
frame.setSize(new Dimension(e.getWidth() + 6, e.getHeight() + 20));
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frameSize = frame.getSize();
frame.setLocation( (screenSize.width - frameSize.width) / 2,
(screenSize.height - frameSize.height) / 2);
frame.show();
}
}
新建一个HTML文件，加入以下语句可作为Applet(其中width/height分别是图片的高和宽)：
<APPLET height=640 width=480 code=pic.effect.class></APPLET>
作为应用程序运行的时候，在命令行输入：
java pic.effect
如果给你带来帮助，欢迎微信或支付宝扫一扫，赞一下。
