java 2d 动画_Step By Step(Java 2D图形篇<三>)

本篇将继续介绍Java 2D 图形部分的内容。

10.    BufferedImage：

BufferedImage中包含着width*height个像素点的颜色值，同时BufferedImage中还带有色彩模型(ColorModel)的信息，用于描述像素点的颜色模型，如TYPE_INT_ARGB、TYPE_INT_RGB等。Graphic2D在渲染目标图像时，也需要依照ColorModel来计算图像像素的颜色信息并执行渲染。

在有些情况下，我们需要对BufferedImage中的每一个像素的颜色值进行计算，并将计算的结果回写到BufferedImage中相应的位置。那么我们是如果获取这些像素信息的呢？又是如果将计算后的颜色值回写的呢？Java 2D中提供了BufferedImage.getRaster()方法，可以直接获取BufferedImage中的光栅信息，再通过WritableRaster.getPixel()方法获取指定位置的像素的颜色值。在对取得的颜色值执行必要的计算后，可通过WritableRaster.setPixel()方法将计算结果回写到光栅的指定位置中。如果图像很大，这样反复的调用getPixel()/setPixel()势必会引起效率问题，WritableRaster为我们提供了getPixels()/setPixels()方法，可以一次获取/回写一组像素颜色值。其使用方式和getPixel()/setPixel()基本一致。

试想一下，如果我们需要每一种颜色模型(ColorModel)都实现一种处理和计算逻辑，这样会给我们的图形算法带来一些额外的负担，使我们的算法不得不和这些细节打交道，我想这并不是我们希望看到的结果，还有更好的方式可以规避这样的问题吗？答案是肯定的，Java 2D通过下面两条语句来获取标准的颜色值：

BufferedImage img = loadImageFromFile(filename);

Raster r = img.getRaster();

ColorModel cm = img.getColorModel();

Object data = r.getDataElements(x,y,null);

int argb = cm.getRGB(data);

在基于标准ARGB模型的颜色值计算后，可将结果颜色值通过下面两条语句回写到光栅的指定位置。

Object data = cm.getDataElements(argb,null);

r.setDataElements(x,y,data);

下面提供几个典型的代码示例，以供参考。

1)    在Graphics上绘制BufferedImage的一个简单示例：

主要功能是将一个图片切割成为4份(2行 * 2列)，然后再将切分后的4个子图像进行乱序，换句话说，就是让切割后的子图像不在显示在原有的位置上，最后渲染到Swing的组件上。

1 public class MyTest extends JPanel {

2 private int numlocs = 2;

3 private int numcells = numlocs * numlocs;

4 private int[] cells;

5 private BufferedImage bi;

6 private int w, h, cw, ch;

7 public MyTest() {

8 try {

9 bi = ImageIO.read(new File("D:/desktop.png"));

10 w = bi.getWidth();

11 h = bi.getHeight();

12 } catch (IOException e) {

13 e.printStackTrace();

14 }

15 //将整个图片分隔成为4分，2行 * 2列，这里cx和cy是每个子图片的宽和高16 cw = w / numlocs;

17 ch = h / numlocs;

18 cells = new int[numcells];

19 //初始化每个子图片的位置信息20 for (int i = 0; i < numcells; i++)

21 cells[i] = i;

22 }

23 void doExchange() {

24 Random rand = new Random();

25 int ri;

26 //将2 * 2 = 4个图片的位置通过随机数的方式打乱。27 for (int i = 0; i < numcells; i++) {

28 while ((ri = rand.nextInt(numlocs)) == i) {

29 }

30 int tmp = cells[i];

31 cells[i] = cells[ri];

32 cells[ri] = tmp;

33 }

34 }

35 public void paintComponent(Graphics g) {

36 super.paintComponent(g);

37 int dx, dy;

38 //逐个渲染乱序后的每个子图片39 for (int x = 0; x < numlocs; x++) {

40 int sx = x * cw;

41 for (int y = 0; y < numlocs; y++) {

42 int sy = y * ch;

43 int cell = cells[x * numlocs + y];

44 dx = (cell / numlocs) * cw;

45 dy = (cell % numlocs) * ch;

46 //参数说明：47 //BufferedImage: 目标绘制图像缓冲区48 //dx1,dy1: 绘制目标的左上角x,y坐标49 //dx2,dy2: 绘制目标的右下角x,y坐标50 //sx1,sy1: 源图像(第一个参数)的左上角x,y坐标51 //sx2,sy2: 源图像(第一个参数)的右下角x,y坐标52 g.drawImage(bi, dx, dy, dx + cw, dy + ch, sx, sy, sx + cw, sy + ch, null);

53 }

54 }

55 }

56 public static void main(String[] args) {

57 JFrame frame = new JFrame();

58 frame.setTitle("BufferedImage");

59 frame.setSize(1000, 600);

60 frame.addWindowListener(new WindowAdapter() {

61 public void windowClosing(WindowEvent e) {

62 System.exit(0);

63 }

64 });

65 Container contentPane = frame.getContentPane();

66 MyTest p = new MyTest();

67 contentPane.add(p);

68 p.doExchange();

69 frame.show();

70 }

71 }

2)    通过多种方式在(利用Graphics2D.drawImage()的不同重载方法)目标Graphics上绘制多种处理后的图像，如缩放、ConvolveOp的锐化，RescaleOp的改变亮度等。

1 public class MyTest extends JPanel {

2 private BufferedImage bi;

3 private static int ALL_WIDTH = 900;

4 private static int ALL_HEIGHT = 600;

5 private int w, h;

6 public static final float[] SHARPEN3x3 = { 0.f, -1.f, 0.f, -1.f, 5.f, -1.f, 0.f, -1.f, 0.f };

7 //可以将1,1坐标的锐化data替换为这里的模糊data，该观察效果。8 public static final float[] BLUR3x3 = { 0.1f, 0.1f, 0.1f, 0.1f, 0.2f, 0.1f, 0.1f, 0.1f, 0.1f };

9 public MyTest() {

10 try {

11 //这里的样例图片是截取的桌面背景，width和height都是比较大的，12 //同时为了简化代码突出重点，因此这里只是给出了固定的宽和高13 bi = ImageIO.read(new File("D:/desktop.png"));

14 //由于我们的整个JFrame将同时显示六种(2行*3列)不同效果的目标15 //子图像，因此这里需要针对原图的宽和高作特殊处理，并取出子图像16 bi = bi.getSubimage(0, 0, ALL_WIDTH / 3, ALL_HEIGHT / 2);

17 w = bi.getWidth();

18 h = bi.getHeight();

19 if (bi.getType() != BufferedImage.TYPE_INT_RGB) {

20 BufferedImage bi2 = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);

21 bi2.getGraphics().drawImage(bi, 0, 0, null);

22 bi = bi2;

23 }

24 } catch (IOException e) {

25 }

26 }

27 public void paintComponent(Graphics g) {

28 super.paintComponent(g);

29 Graphics2D g2 = (Graphics2D) g;

30

31 int offsetx = 0;

32 int offsety = 0;

33 //1. 在0,0的位置显示原始图像34 g.drawImage(bi, offsetx, offsety, null);

35 offsetx += bi.getWidth();

36 //2. 在0,1的位置显示通过原始坐标进行缩放的图像,该行代码将原始图像的部分图像放大一倍37 g.drawImage(bi, offsetx, offsety, offsetx + w, offsety + h, 0, 0, w / 2, h / 2, null);

38 offsetx += bi.getWidth();

39 //3. 在0,2的位置显示通过AffineTransform进行缩放后的图像40 AffineTransform at = AffineTransform.getTranslateInstance(offsetx, offsety);

41 at.scale(0.7, 0.7);

42 g2.drawImage(bi, at, null);

43 offsetx = 0;

44 offsety += bi.getHeight();

45 //4. 在1,0的位置显示通过AffineTransformOp处理后的图像.46 //AffineTransformOp是通过TYPE_BICUBIC(质量最高的)提示将原始图像进行缩放。47 AffineTransform at2 = AffineTransform.getScaleInstance(1.5, 1.5);

48 AffineTransformOp aop = new AffineTransformOp(at2, AffineTransformOp.TYPE_BICUBIC);

49 BufferedImage bi2 = new BufferedImage(bi.getWidth()

50 ,bi.getHeight(),BufferedImage.TYPE_INT_RGB);

51 //这里主要是为了确保每个图像都显示在各自的单元格内，因此用一个临时的52 //BufferedImage对象替换原有对象显示。事实上，是可以通过以下语句直接渲染的。53 //g2.drawImage(bi,aop,offsetx,offsety);但是这样的渲染结果将会使width放大1.5倍。54 aop.filter(bi, bi2);

55 g2.drawImage(bi2, offsetx, offsety,null);

56 offsetx += bi.getWidth();

57 //5. 在1,1的位置显示锐化后原图58 float[] data = SHARPEN3x3;

59 ConvolveOp cop = new ConvolveOp(new Kernel(3, 3, data), ConvolveOp.EDGE_NO_OP, null);

60 g2.drawImage(bi, cop, offsetx, offsety);

61 offsetx += bi.getWidth();

62 //6. 在1,2的位置显示通过RescaleOp图像处理器改变原图的灰度。63 RescaleOp rop = new RescaleOp(1.1f, 20.0f, null);

64 g2.drawImage(bi, rop, offsetx, offsety);

65 }

66 public static void main(String[] args) {

67 JFrame frame = new JFrame();

68 frame.setTitle("BufferedImage");

69 frame.setSize(ALL_WIDTH, ALL_HEIGHT);

70 frame.addWindowListener(new WindowAdapter() {

71 public void windowClosing(WindowEvent e) {

72 System.exit(0);

73 }

74 });

75 Container contentPane = frame.getContentPane();

76 MyTest p = new MyTest();

77 contentPane.add(p);

78 frame.show();

79 }

80 }

3)    在介绍ColorModel之前，我们需要先了解在Java 2D 中另外一组比较重要的图形工具对象--图形环境(GraphicsEnvironment)、图形设备(GraphicsDevice)和图形配置(GraphicsConfiguration)。通过下面这个简单的示例代码，可以非常清楚的看出他们之间的关系以及各自的作用。

1 public class MyTest {

2 public static void main(String[] args) {

3 //1. 获取本地的图形环境4 GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();

5 //2. 获取所有的屏幕设备6 GraphicsDevice[] gs = ge.getScreenDevices();

7 //3. 获取每个屏幕设备的配置对象8 for (int j = 0; j < gs.length; j++) {

9 GraphicsDevice gd = gs[j];

10 System.out.println("Device " + j + ": " + gd);

11 GraphicsConfiguration[] gc = gd.getConfigurations();

12 for (int i = 0; i < gc.length; i++) {

13 System.out.println(" Configuration " + i + ": " + gc[i]);

14 System.out.println(" Bounds: " + gc[i].getBounds());

15 }

16 }

17 }

18 }

19 /*输出结果如下：20 Device 0: Win32GraphicsDevice[screen=0]21 Configuration 0: sun.awt.Win32GraphicsConfig@1b8d6f7[dev=Win32GraphicsDevice[screen=0],pixfmt=0]22 Bounds: java.awt.Rectangle[x=0,y=0,width=1280,height=800]23 */

4)    通过图形设备工具类获取和屏幕相关的Metrics信息。

1 public class MyTest {

2 public static void main(String[] args) {

3 GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();

4 GraphicsDevice gs = ge.getDefaultScreenDevice();

5 DisplayMode[] dmodes = gs.getDisplayModes();

6 for (int i = 0; i < dmodes.length; i++) {

7 int w = dmodes[i].getWidth();

8 int h = dmodes[i].getHeight();

9 int depth = dmodes[i].getBitDepth();

10 int refreshRate = dmodes[i].getRefreshRate();

11 System.out.printf("ScreenWidth = %d\t ScreenHeight = %d\t " +

12 "BitDepth = %d\t RefreshRate = %d\n",w,h,depth,refreshRate);

13 }

14 DisplayMode currentDMode = gs.getDisplayMode();

15 int w = currentDMode.getWidth();

16 int h = currentDMode.getHeight();

17 int depth = currentDMode.getBitDepth();

18 int refreshRate = currentDMode.getRefreshRate();

19 System.out.println("The current Display Modes is ");

20 System.out.printf("ScreenWidth = %d\t ScreenHeight = %d\t " +

21 "BitDepth = %d\t RefreshRate = %d\n",w,h,depth,refreshRate);

22 }

23 }

5)    通过图形配置工具类创建和当前图形设备类型兼容的BufferedImage。

这里需要说明一下，每个图形设备都会有一组和当前设备相关的图形配置信息，如分辨率、位深度和色彩类型等。不同的设备之间其图形配置可能存在较大的差异，如屏幕和打印机。那么创建和设备兼容的BufferedImage的目的和应用是什么呢？目的很简单就是为了提高渲染效率。比如当前的BufferedImage对象需要被渲染到JPanel上面，如果该BufferedImage对象的图形配置信息和显示JPanel的屏幕的配置信息相一致，那么在Graphics渲染时，就可以避免因大量的数据转义而带来的额外开销。这种技巧一个非常典型的应用就是Swing的双缓冲技术。由于本篇并不是介绍Swing的专题，而双缓冲又是一个非常通用的技术，这里就不再给出更多的解释了。

下面的示例代码将给出一个用于创建与设备兼容的BufferedImage对象的工具类。

1 class CompatibleImageUtil {

2 private static GraphicsConfiguration gc;

3 public static GraphicsConfiguration getConfiguration() {

4 if (gc == null) {

5 //1. 获取本地当前正在使用的图形环境6 GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();

7 //2. 获取当前环境正在使用的图形设备8 GraphicsDevice gs = ge.getDefaultScreenDevice();

9 //3. 获取当前设备正在使用的图形配置。10 gc = gs.getDefaultConfiguration();

11 }

12 return gc;

13 }

14 //基于参数srcImage的宽度、高度和透明度参数来创建一个和设备兼容的BufferedImage对象15 public static BufferedImage createCompatibleImage(BufferedImage srcImage) {

16 return createCompatibleImage(srcImage, srcImage.getWidth(), srcImage.getHeight());

17 }

18 public static BufferedImage createCompatibleImage(BufferedImage srcImage, int width, int height) {

19 return getConfiguration().createCompatibleImage(width, height, srcImage.getTransparency());

20 }

21 public static BufferedImage createCompatibleImage(int width, int height) {

22 return getConfiguration().createCompatibleImage(width, height);

23 }

24 public static BufferedImage createCompatibleTranslucentImage(int width, int height) {

25 return getConfiguration().createCompatibleImage(width, height, Transparency.TRANSLUCENT);

26 }

27 //加载原图像，在基于加载后源图像的宽度、高度和透明度创建一个和设备兼容的BufferedImage对象28 public static BufferedImage loadCompatibleImage(File filename) throws IOException {

29 BufferedImage image = ImageIO.read(filename);

30 return toCompatibleImage(image);

31 }

32 public static BufferedImage toCompatibleImage(BufferedImage image) {

33 GraphicsConfiguration gc = getConfiguration();

34 //如果源图像的ColorModel和当前设备的ColorModel兼容，则直接返回35 if (image.getColorModel().equals(gc.getColorModel()))

36 return image;

37 //基于源图像创建和设备兼容的目标图像38 BufferedImage compatibleImage = gc.createCompatibleImage(image.getWidth()

39 , image.getHeight(),image.getTransparency());

40 //再将源图像绘制到目标图像后返回41 Graphics g = compatibleImage.getGraphics();

42 g.drawImage(image, 0, 0, null);

43 g.dispose();

44 return compatibleImage;

45 }

46 }

6)    通过直接操作BufferedImage对象内部的光栅对象来处理图像的每一个像素。

1 public class MyTest extends JPanel {

2 private BufferedImage srcImage;

3 private BufferedImage flippedImage;

4 MyTest() {

5 try {

6 Image image = ImageIO.read(new File("D:/desktop.png"));

7 //由于该测试图片是桌面的快照，因此比较大，这里为了显示方便需要截取8 srcImage = new BufferedImage(300,300, BufferedImage.TYPE_INT_ARGB);

9 Graphics g = srcImage.getGraphics();

10 g.drawImage(image, 0, 0, 300,300,0,0,300,300,null);

11 flippedImage = new BufferedImage(srcImage.getWidth(),

12 srcImage.getHeight(), srcImage.getType());

13 //直接获取源图像和目的图像的光栅数据14 DataBuffer dbSrc = srcImage.getRaster().getDataBuffer();

15 DataBuffer dbFlipped = flippedImage.getRaster().getDataBuffer();

16 //直接操作光栅数据，这里将源图像的数据数组反向写入目标图像。17 //从而达到翻转的效果18 for (int i = dbSrc.getSize() - 1, j = 0; i >= 0; --i, j++) {

19 dbFlipped.setElem(j, dbSrc.getElem(i));

20 }

21 } catch (IOException e) {

22 }

23 }

24 public void paintComponent(Graphics g) {

25 super.paintComponent(g);

26 g.drawImage(srcImage, 0, 0, null);

27 g.drawImage(flippedImage,300,0,null);

28 }

29 public static void main(String[] args) throws IOException {

30 JFrame frame = new JFrame();

31 frame.setTitle("Write with Raster");

32 frame.setSize(600, 300);

33 frame.addWindowListener(new WindowAdapter() {

34 public void windowClosing(WindowEvent e) {

35 System.exit(0);

36 }

37 });

38 Container contentPane = frame.getContentPane();

39 contentPane.add(new MyTest());

40 frame.show();

41 }

42 }

7)    通过直接操作像素颜色数组的方式更新BufferedImage的光栅数据：

1 public class MyTest extends JPanel {

2 public static void main(String[] args) throws IOException {

3 JFrame frame = new JFrame();

4 frame.setTitle("");

5 frame.setSize(600, 300);

6 frame.addWindowListener(new WindowAdapter() {

7 public void windowClosing(WindowEvent e) {

8 System.exit(0);

9 }

10 });

11 Container contentPane = frame.getContentPane();

12 contentPane.add(new MyTest());

13 frame.show();

14 }

15

16 private BufferedImage originalImage;

17 private int w;

18 private int h;

19 private WritableRaster raster;

20

21 MyTest() {

22 Image image = null;

23 try {

24 image = ImageIO.read(new File("D:/desktop.png"));

25 } catch (IOException e) {

26 e.printStackTrace();

27 }

28 originalImage = new BufferedImage(image.getWidth(null),image.getHeight(null),

29 BufferedImage.TYPE_INT_RGB);

30 Graphics g = originalImage.getGraphics();

31 g.drawImage(image,0,0,null);

32 raster = originalImage.getRaster();

33 w = originalImage.getWidth();

34 h = originalImage.getHeight();

35 int[] iArray = null;

36 //getPixels返回的数组是BufferedImage内部真实数据的copy37 int[] array = raster.getPixels(0, 0, w, h, iArray);

38 for (int i = 0; i < array.length; ++i) {

39 array[i] = array[i] - 10;

40 }

41 raster.setPixels(0, 0, w, h, array);

42 }

43

44 public void paintComponent(Graphics g) {

45 super.paintComponent(g);

46 g.drawImage(originalImage, 0, 0, null);

47 }

48 }

11.    图像处理：

如果你有一个图像并且想改变他的外观，该怎么办呢？这是你将需要访问该图像的每一个像素，并用其他的像素来取代这些像素。Java 2D中提供了BufferedImageOp的接口，实现了该接口的类可以对图像进行变换操作。具体使用方式可以参照下面示例代码：

BufferedImageOp op = getBufferedImageOperation();

BufferedImage fileteredImage = new BufferedImage(img.getWidth(),img.getHeight(),img.getType());

op.filter(img,filteredImage);

在Java 2D中为我们提供了5个BufferedImageOp接口的实现类，他们分别是AffineTransformOp、RescaleOp、LookupOp、ColorConvertOp和ConvolveOp。下面的示例代码将给出三种比较常用的图像处理实现类AffineTransformOp、Rescale和ConvolveOp的使用方式。

1 public class MyTest extends JPanel {

2 private BufferedImage image;

3 private static int WINDOW_WIDTH = 600;

4 private static int WINDOW_HEIGHT = 600;

5 static AffineTransform mirrorTransform;

6 static {

7 mirrorTransform = AffineTransform.getTranslateInstance(WINDOW_WIDTH/4,0);

8 //水平翻转9 mirrorTransform.scale(-1.0, 1.0);

10 }

11 //初始化所有的BufferedImageOp12 static BufferedImageOp[] filters = new BufferedImageOp[] {

13 //1) 显示源图像作为对比14 null,

15 //2) 图像的反色显示，这里需要将BufferedImage中每个点的像素都16 //乘以-1，在加255。17 new RescaleOp(-1.0f, 255f, null),

18 //3) 将亮度提高1.25倍19 new RescaleOp(1.25f, 0, null),

20 //4) 模糊该图像，这里的图像过滤主要是和Kernel的数据值相关。21 new ConvolveOp(new Kernel(3, 3, new float[] { 1/9f, 1/9f, 1/9f, 1/9f, 1/9f, 1/9f,

22 1/9f, 1/9f, 1/9f })),

23 //5) 锐化该图像。24 new ConvolveOp(new Kernel(3, 3, new float[] { 0.0f, -0.75f, 0.0f, -0.75f, 4.0f, -0.75f, 0.0f,

25 -0.75f, 0.0f })),

26 //6) 边缘检测。27 new ConvolveOp(new Kernel(3, 3, new float[] { 0.0f, -0.75f, 0.0f, -0.75f, 3.0f, -0.75f, 0.0f,

28 -0.75f, 0.0f })),

29 //7) 通过mirrorTransform.scale(-1.0, 1.0)的技巧翻转图片(水平翻转)30 new AffineTransformOp(mirrorTransform, AffineTransformOp.TYPE_BILINEAR),

31 //8) 通过rotate变换方式翻转，这里的180度翻转只是一个特例，为了便于演示，32 //事实上可以翻转任意角度, AnchorPoint表示翻转是的作用点(圆心)，该坐标是33 //相对于该图像的左上角的偏移值。34 new AffineTransformOp(AffineTransform.getRotateInstance(Math.PI,WINDOW_WIDTH/8,WINDOW_HEIGHT/4),

35 AffineTransformOp.TYPE_NEAREST_NEIGHBOR)

36 };

37 public MyTest() {

38 try {

39 image = ImageIO.read(new File("D:/desktop.png"));

40 //这里做一个源图像截取，便于后面的规范化显示。41 image = image.getSubimage(0, 0,WINDOW_WIDTH/4, WINDOW_HEIGHT/2);

42 } catch (IOException e) {

43 }

44 }

45 @Override

46 public Dimension getPreferredSize() {

47 return new Dimension(WINDOW_WIDTH,WINDOW_HEIGHT);

48 }

49 public void paintComponent(Graphics g) {

50 super.paintComponent(g);

51 BufferedImage bimage = new BufferedImage(image.getWidth(), image.getHeight()

52 , BufferedImage.TYPE_INT_RGB);

53 Graphics2D ig = bimage.createGraphics();

54 ig.drawImage(image, 0, 0, null);

55 for (int i = 0; i < filters.length; i++) {

56 //如果filters[i]的值是null，需要copy源图像，否则使用图像处理器处理图像。57 if (filters[i] == null)

58 g.drawImage(bimage, 0, 0, null);

59 else

60 g.drawImage(filters[i].filter(bimage, null), 0, 0, null);

61 //平行移动62 g.translate(WINDOW_WIDTH / 4, 0);

63 //向下移动，同时将x的坐标移回0的位置，由于translate和Graphics中64 //之前的坐标变换是组合的，所以这里只能用这种方法偏移，而不能直接置零65 if ((i + 1) % 4 == 0 && i != 0)

66 g.translate(-WINDOW_WIDTH, WINDOW_HEIGHT / 2);

67 }

68 ig.dispose();

69 }

70 public static void main(String[] args) {

71 JFrame frame = new JFrame();

72 frame.setTitle("BufferedImageOp");

73 frame.addWindowListener(new WindowAdapter() {

74 public void windowClosing(WindowEvent e) {

75 System.exit(0);

76 }

77 });

78 frame.setContentPane(new MyTest());

79 frame.pack();

80 frame.setVisible(true);

81 }

82 }