欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

使用JAVA对图片进行效果变换

程序员文章站 2022-06-05 23:52:11
...

 原文链接: http://www.ismyway.com/articles/simpleimageeffect/index.html

一提到JAVA,谈论最多的就是JSP/SERVLET/J2EE之类的,但对于用JAVA对图片进行效果变换,到论坛里看了看,关于这方面的话题并不多,网上关于图像效果处理的文章也并不丰富,于是在自己摸索了几天,并且参考了AnfyJava(专业级的JAVA效果生成器)后,我用轻量级控件写了一个(AnfyJava继承的是Applet,Applet是java.awt包中的,属于重量级控件,SUN现在推荐使用swing来编写图形程序,因此,我用的是JApplet)。

其实,用JAVA做图像效果和其它语言在本质上并没有什么区别,只不过在实现起来有所不同罢了,下面我就把我在项目中处理的经验与大家分享一下吧。

图像的变换,实际上就是把两幅图片的内容进行某些运算,生成新的图像,然后显示出来,最终实现从一幅图片到另一幅图片的过度效果。变换的具体过程如下:

使用JAVA对图片进行效果变换
            
    
    博客分类: java 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组成的,其格式为

使用JAVA对图片进行效果变换
            
    
    博客分类: java java 

int alpha = (pixel >> 24) & 0xff;

int red = (pixel >> 16) & 0xff;

int green = (pixel >> 8) & 0xff;

int blue = (pixel) & 0xff;

 

 

假如要实现显示图片A后,图片B由上至下展开,则可以每次将图片A中的一行像素替换为B中的相应行,然后生成新的像素信息:

使用JAVA对图片进行效果变换
            
    
    博客分类: java java 

 

 

 

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();

}

}

 

相关标签: java