现在的位置: 首页 > 综合 > 正文

在MIDP2.0中操作图片像素

2013年06月23日 ⁄ 综合 ⁄ 共 8571字 ⁄ 字号 小 中 大 ⁄ 评论关闭
文章目录

作者：chenyi 文章来源：chenyis blog

正文

   我们知道，在MIDP1.0中，除非我们利用特定厂商的API(比如Nokia),我们是没法对图片的像素进行操作的，但是在MIDP2.0中,Image和Graphics的功能都大大增强了。比如，我们可以获取Image的所有像素值,然后利用程序来修改这些像素(比如说ARGB各自的值),最后再把修改后的像素图绘制出来。通过直接操作图片像素，我们就获得了一种很强大的能力，用编程的方式实现出很多有趣的效果来，而不用额外制作新图片。比如说透明度渐变，颜色反转等。下面就是2个例子，分别实现透明度渐变和颜色反转的功能。

例题一: 透明度渐变效果的实现

   给定一张图片，假如我们想实现这么一种效果:图片由全透明状态逐渐清晰，最后达到正常状态。要实现这一个过程，我们首先要获取该图片的所有像素值，逐步让这些像素的alpha值从0转变到正常，每改变图片的所有像素值一次，我们就请求刷屏一次,把最新的像素图画出来，这样我们就能实现透明度渐变的效果了。代码实现如下:

  2. import java.io.IOException;
  4. import javax.microedition.lcdui.Canvas;
  5. import javax.microedition.lcdui.Display;
  6. import javax.microedition.lcdui.Graphics;
  7. import javax.microedition.lcdui.Image;
  8. import javax.microedition.midlet.MIDlet;
  9. import javax.microedition.midlet.MIDletStateChangeException;
  11. /**
  12.  * 
  13.  * @author Jagie
  14.  * 
  15.  */
  16. public class ShadowMIDlet extends MIDlet {
  17.     Canvas c = new ShadowCanvas();
  19.     public ShadowMIDlet() {
  21.     }
  23.     protected void startApp() throws MIDletStateChangeException {
  24.         Display.getDisplay(this).setCurrent(c);
  26.     }
  28.     protected void pauseApp() {
  29.         // TODO Auto-generated method stub
  31.     }
  33.     protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
  34.         // TODO Auto-generated method stub
  36.     }
  38. }
  40. /**
  41.  * 
  42.  * @author Jagie
  43.  * 
  44.  */
  45. class ShadowCanvas extends Canvas implements Runnable {
  46.     int w, h;
  48.     // 原始图片
  49.     Image srcImage;
  51.     // 原始图片的像素数组
  52.     int[] srcRgbImage;
  54.     // 渐变图片的像素数组
  55.     int[] shadowRgbImage;
  57.     int imgWidth, imgHeight;
  59.     int count;
  61.     public ShadowCanvas() {
  62.         w = this.getWidth();
  63.         h = this.getHeight();
  64.         try {
  65.             srcImage = Image.createImage("/av.png");
  66.         } catch (IOException e) {
  67.             // TODO Auto-generated catch block
  68.             e.printStackTrace();
  69.         }
  70.         imgWidth = srcImage.getWidth();
  71.         imgHeight = srcImage.getHeight();
  72.         // 制造原始图片的像素数组，用一个int来代表每一个像素,按位表示方式是:0xAARRGGBB
  73.         srcRgbImage = new int[imgWidth * imgHeight];
  74.         // 获取原始图片的所有像素，参见MIDP APPI文档
  75.         srcImage.getRGB(srcRgbImage, 0, imgWidth, 0, 0, imgWidth, imgHeight);
  77.         shadowRgbImage = new int[srcRgbImage.length];
  79.         System.arraycopy(srcRgbImage, 0, shadowRgbImage, 0,
  80.                 shadowRgbImage.length);
  82.         // 渐变图片的所有像素已开始都是全透明的
  83.         for (int i = 0; i < shadowRgbImage.length; i++) {
  84.             shadowRgbImage[i] &= 0x00ffffff;
  85.         }
  87.         new Thread(this).start();
  89.     }
  91.     public void paint(Graphics g) {
  92.         g.setColor(0, 0, 0);
  93.         g.fillRect(0, 0, w, h);
  94.         // 绘制渐变图片
  95.         g.drawRGB(shadowRgbImage, 0, imgWidth, (w - imgWidth) / 2,
  96.                 (h - imgHeight) / 2, imgWidth, imgHeight, true);
  98.         g.setColor(0, 255, 0);
  99.         g.drawString("count=" + count, w / 2, 30, Graphics.HCENTER
  100.                 | Graphics.TOP);
  101.     }
  103.     public void run() {
  104.         while (true) {
  106.             boolean changed = false;
  107.             // 改变渐变图片的每一个像素
  108.             for (int i = 0; i < shadowRgbImage.length; i++) {
  109.                 // 获取渐变图片的某一像素的alpha值
  110.                 int alpha = (shadowRgbImage[i] & 0xff000000) >>> 24;
  111.                 // 原始图片的对应像素的alpha值
  112.                 int oldAlpha = (srcRgbImage[i] & 0xff000000) >>> 24;
  114.                 if (alpha < oldAlpha) {
  115.                     // alpha值++
  116.                     shadowRgbImage[i] = ((alpha + 1) << 24)
  117.                             | (shadowRgbImage[i] & 0x00ffffff);
  118.                     changed = true;
  119.                 }
  120.             }
  122.             try {
  123.                 Thread.sleep(10);
  124.             } catch (InterruptedException e) {
  125.                 // TODO Auto-generated catch block
  126.                 e.printStackTrace();
  127.             }
  128.             count++;
  129.             repaint();
  130.             // 当所有像素的alpha值都达到原始值后,线程运行结束
  131.             if (!changed) {
  132.                 System.out.println("over");
  133.                 break;
  134.             }
  135.         }
  137.     }
  139. }

透明度渐变效果如下:
  
  

例题二:颜色反转

   在手机游戏中,我们经常会碰上这样一种情况,比如我方飞机和敌方飞机外观是完全一样的，唯一的区别就是颜色不同，比如说敌方飞机是红色的，而我方飞机是绿色的。在MIDP1.0中，我们就只好制作2张图片来表示2种飞机，自然，这样会造成jar空间的极大浪费。但是在MIDP2.0中，通过对图片直接进行像素操作，反转RGB中的一个值，我们只需要一张图片就够了，样例代码如下:

ColorMIDlet.java

  1. import java.io.IOException;
  3. import javax.microedition.lcdui.Canvas;
  4. import javax.microedition.lcdui.Display;
  5. import javax.microedition.lcdui.Graphics;
  6. import javax.microedition.lcdui.Image;
  7. import javax.microedition.midlet.MIDlet;
  8. import javax.microedition.midlet.MIDletStateChangeException;
  10. /**
  11.  * 
  12.  * @author Jagie
  13.  * 
  14.  */
  15. public class ColorMIDlet extends MIDlet {
  16.     Canvas c = new ColorCanvas();
  18.     public ColorMIDlet() {
  19.         super();
  20.         // TODO Auto-generated constructor stub
  21.     }
  23.     protected void startApp() throws MIDletStateChangeException {
  24.         Display.getDisplay(this).setCurrent(c);
  26.     }
  28.     protected void pauseApp() {
  29.         // TODO Auto-generated method stub
  31.     }
  33.     protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
  34.         // TODO Auto-generated method stub
  36.     }
  38. }
  40. /**
  41.  * 
  42.  * @author Jagie
  43.  * 
  44.  */
  45. class ColorCanvas extends Canvas {
  46.     Image srcImage;
  48.     int[] targetImage1;
  50.     int[] targetImage2;
  52.     public ColorCanvas() {
  53.         try {
  54.             srcImage = Image.createImage("/av.png");
  55.         } catch (IOException e) {
  56.             // TODO Auto-generated catch block
  57.             e.printStackTrace();
  58.         }
  60.         targetImage1 = GraphicsUtil.flipImageColor(srcImage,
  61.                 GraphicsUtil.SHIFT_RED_TO_BLUE);
  63.         targetImage2 = GraphicsUtil.flipImageColor(srcImage,
  64.                 GraphicsUtil.SHIFT_RED_TO_GREEN);
  66.     }
  68.     public void paint(Graphics g) {
  70.         g.setColor(0, 0, 0);
  71.         g.fillRect(0, 0, this.getWidth(), this.getHeight());
  72.         g.setColor(0x00ff00);
  73.         g.drawString("origin:", getWidth() / 2, 0, Graphics.TOP
  74.                 | Graphics.HCENTER);
  75.         g.drawImage(srcImage, 30, 20, Graphics.LEFT | Graphics.TOP);
  76.         g.drawString("SHIFT_RED_TO_BLUE:", getWidth() / 2,
  77.                 srcImage.getHeight() + 20, Graphics.TOP | Graphics.HCENTER);
  78.         g.drawRGB(targetImage1, 0, srcImage.getWidth(), 30, srcImage
  79.                 .getHeight() + 40, srcImage.getWidth(), srcImage.getHeight(),
  80.                 true);
  81.         g.drawString("SHIFT_RED_TO_GREEN:", getWidth() / 2, srcImage
  82.                 .getHeight() * 2 + 40, Graphics.TOP | Graphics.HCENTER);
  83.         g.drawRGB(targetImage2, 0, srcImage.getWidth(), 30, srcImage
  84.                 .getHeight() * 2 + 60, srcImage.getWidth(), srcImage
  85.                 .getHeight(), true);
  87.     }
  89. }

GraphicsUtil.java

  1. import javax.microedition.lcdui.Image;
  3. /**
  4.  * 
  5.  * @author Jagie
  6.  * 
  7.  */
  8. public class GraphicsUtil {
  10.     public static final int SHIFT_RED_TO_GREEN = 0;
  12.     public static final int SHIFT_RED_TO_BLUE = 1;
  14.     public static final int SHIFT_GREEN_TO_BLUE = 2;
  16.     public static final int SHIFT_GREEN_TO_RED = 3;
  18.     public static final int SHIFT_BLUE_TO_RED = 4;
  20.     public static final int SHIFT_BLUE_TO_GREEN = 5;
  22.     public static int[] flipImageColor(Image source, int shiftType) {
  23.         // we start by getting the image data into an int array - the number
  24.         // of 32-bit ints is equal to the width multiplied by the height
  25.         int[] rgbData = new int[(source.getWidth() * source.getHeight())];
  26.         source.getRGB(rgbData, 0, source.getWidth(), 0, 0, source.getWidth(),
  27.                 source.getHeight());
  29.         // now go through every pixel and adjust it's color
  30.         for (int i = 0; i < rgbData.length; i++) {
  31.             int p = rgbData[i];
  33.             // split out the different byte components of the pixel by
  34.             // applying
  35.             // a mask so we only get what we need, then shift it to make it
  36.             // a normal number we can play around with
  37.             int a = ((p & 0xff000000) >> 24);
  38.             int r = ((p & 0x00ff0000) >> 16);
  39.             int g = ((p & 0x0000ff00) >> 8);
  40.             int b = ((p & 0x000000ff) >> 0);
  42.             int ba = a, br = r, bb = b, bg = g; // backup copies
  44.             // flip the colors around according to the operation required
  45.             switch (shiftType) {
  46.             case SHIFT_RED_TO_GREEN:
  47.                 g = r;
  48.                 r = bg;
  49.                 break;
  50.             case SHIFT_RED_TO_BLUE:
  51.                 b = r;
  52.                 r = bb;
  53.                 break;
  54.             case SHIFT_GREEN_TO_BLUE:
  55.                 g = b;
  56.                 b = bg;
  57.                 break;
  58.             case SHIFT_GREEN_TO_RED:
  59.                 g = r;
  60.                 r = bg;
  61.                 break;
  62.             case SHIFT_BLUE_TO_RED:
  63.                 b = r;
  64.                 r = bb;
  65.                 break;
  66.             case SHIFT_BLUE_TO_GREEN:
  67.                 b = g;
  68.                 g = bb;
  69.                 break;
  70.             }
  72.             // shift all our values back in
  73.             rgbData[i] = (a << 24) | (r << 16) | (g << 8) | b;
  74.         }
  76.         return rgbData;
  77.     }
  79. }
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞