j2me图片处理大全

图片的渐变效果：

import java.io.IOException;

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;

//ShadowCanvas.java
/** 
 * @author boolean liuhao137310@163.com: 
 * @version 创建时间：2009-2-7 下午02:01:27 
 * @TODO 图片的渐变效果 在第一张图片的基础上渐变出第二张图片
 */
class ShadowCanvas extends Canvas implements Runnable { 
    int w, h; 

    /**原始图片*/ 
    Image img2;
    
    /**渐变图片*/
    Image srcImage;

    // 原始图片的像素数组 
    int[] srcRgbImage; 

    // 渐变图片的像素数组 
    int[] shadowRgbImage; 

    int imgWidth, imgHeight; 

    int count; 

    /**原始图片只画一次即可 此变量记录是否是第一次画原始图片*/
    private boolean first = true;
    
    public ShadowCanvas() { 
        w = this.getWidth(); 
        h = this.getHeight(); 
        try { 
            srcImage = Image.createImage("/logoBg.png"); 
            img2 = Image.createImage("/test_bg.png");
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
        imgWidth = srcImage.getWidth(); 
        imgHeight = srcImage.getHeight(); 
        // 制造原始图片的像素数组，用一个int来代表每一个像素,按位表示方式是:0xAARRGGBB 
        srcRgbImage = new int[imgWidth * imgHeight]; 
        // 获取原始图片的所有像素，参见MIDP APPI文档 
        srcImage.getRGB(srcRgbImage, 0, imgWidth, 0, 0, imgWidth, imgHeight); 

        shadowRgbImage = new int[srcRgbImage.length]; 

        System.arraycopy(srcRgbImage, 0, shadowRgbImage, 0, 
                shadowRgbImage.length); 

        // 渐变图片的所有像素一开始都是全透明的 
        for (int i = 0; i < shadowRgbImage.length; i++) { 
            shadowRgbImage[i] &= 0x00ffffff; 
        } 

        new Thread(this).start(); 

    } 

    public void paint(Graphics g) { 
//        g.setColor(0, 0, 0); 
//        g.fillRect(0, 0, w, h); 
        if(first){
            g.drawImage(img2, 0, 0, 0);
            first = false;
        }
        // 绘制渐变图片 
        g.drawRGB(shadowRgbImage, 0, imgWidth, (w - imgWidth) / 2, 
                (h - imgHeight) / 2, imgWidth, imgHeight, true); 

//        g.setColor(0, 255, 0); 
//        g.drawString("count=" + count, w / 2, 30, Graphics.HCENTER 
//                | Graphics.TOP); 
    } 

    public void run() { 
        while (true) { 

            boolean changed = false; 
            // 改变渐变图片的每一个像素 
            for (int i = 0; i < shadowRgbImage.length; i++) { 
                // 获取渐变图片的某一像素的alpha值 
                int alpha = (shadowRgbImage[i] & 0xff000000) >>> 24; 
                // 原始图片的对应像素的alpha值 
                int oldAlpha = (srcRgbImage[i] & 0xff000000) >>> 24; 

                if (alpha < oldAlpha) { 
                    // alpha值++  写的太精妙了 把移位用到了极致
                    shadowRgbImage[i] = ((alpha + 1) << 24) 
                            | (shadowRgbImage[i] & 0x00ffffff); 
                    changed = true; 
                } 
            } 

            try { 
                Thread.sleep(10); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
            count ++; 
            repaint(); 
            // 当所有像素的alpha值都达到原始值后,线程运行结束 
            if (!changed) { 
                System.out.println("over"); 
                break; 
            } 
        } 

    } 

} 

下边这个类是照搬别人的：

ImageUtil



/*
 * ImageUtil.java
 *
 * Created on 2008年1月11日, 上午9:26
 *
 */


/**
 *
 * @author alajl
 */


import javax.microedition.lcdui.*;
import javax.microedition.lcdui.game.Sprite;


public class ImageUtil
{
    public static final int TURN_LEFT = 1;
    public static final int TURN_RIGHT = 2;


    /*
    *获取图片RGB数据，并返回大小为width*height大小的一维数组
    */
    public int[] getPixels(Image src)
    {
        int w = src.getWidth();
        int h = src.getHeight();
        int[] pixels = new int[w * h];
        src.getRGB(pixels, 0, w, 0, 0, w, h);
        return pixels;
    }

 
    /*
    *将pixels[]里的数据，生成一张图片，图片宽为w，高为h
    */ 
    public Image drawPixels(int[] pixels, int w, int h)
    {
        Image image = Image.createRGBImage(pixels, w, h, true);
        pixels = null;
        return image;
    }


    /*
    *调整图片大小
    *destW 调整后的宽，destH调整后的高
    */  
    public  Image effect_resizeImage(Image src, int destW, int destH)
    {
        int srcW = src.getWidth();
        int srcH = src.getHeight();

  
        int[] destPixels = new int[destW * destH]; 
        
        int[] srcPixels = getPixels(src); 

            for (int destY = 0; destY < destH; ++destY)
            {
                for (int destX = 0; destX < destW; ++destX)
                {
                    int srcX = (destX * srcW) / destW;
                    int srcY = (destY * srcH) / destH;
                    destPixels[destX + destY * destW] = srcPixels[srcX + srcY
                            * srcW];
                }
            }

  
        return drawPixels(destPixels, destW, destH);
    }

   
   /*
   * 调整图片亮度与对比度。  contrast 对比度，light 亮度
   */
   public Image effect_light_contrast(Image src,double contrast,int light)
   {
            int srcW = src.getWidth();
            int srcH = src.getHeight();  
            int[] srcPixels = getPixels(src);
            int r = 0;
            int g = 0;
            int b = 0;
            int a = 0;
            int argb;
     //公式y =ax+b   a为对比度，b为亮度 
     //int para_b  = light - 127 * (light - 1);
     for (int i = 0; i < srcH; i++)
           {
              for(int ii=0;ii<srcW;ii++)
        {
                      argb = srcPixels[i*srcW+ii];  
        a = ((argb & 0xff000000) >> 24); // alpha channel
                      r =((argb & 0x00ff0000) >> 16); // red channel
                      g =((argb & 0x0000ff00) >> 8); // green channel
                      b =(argb & 0x000000ff); // blue channel
                      r =(int)( r*contrast+light);                     
        g =(int)( g*contrast+light);
        b =(int)( b*contrast+light);
                     
         /*r =(int)((r -127 ) * contrast + 127+para_b);
         g =(int)((g -127 ) * contrast + 127+para_b);
         b =(int)((b -127 ) * contrast + 127+para_b);*/
         if(r>255)
                               r = 255;
                       else if(r<0) r=0;
                       if(g>255)
                               g = 255;
                       else if(g<0) g=0;
                       if(b>255)
                               b = 255;
                       else if(b<0) b=0;
               srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);

        }
     }
         return drawPixels(srcPixels, srcW, srcH);
   }
 
 
    /*
   * 图片镜像特效
   */
    public Image effect_mirror(Image src)
    {
          int srcW = src.getWidth();
          int srcH = src.getHeight();  
          int[] srcPixels = getPixels(src);
          int len;
          int temp;
          for (int i = 0; i < srcH; i++)
          {
              len = (i+1)*srcW;
              for(int ii=0;ii<srcW/2;ii++) 
              {   
                 temp=srcPixels[i*srcW+ii]; 
                 srcPixels[i*srcW+ii]=srcPixels[len-1-ii]; 
                 srcPixels[len-1-ii]=temp; 
              } 
           }
           return drawPixels(srcPixels, srcW, srcH);
    }

      /*
   * 图片剪切，cut_xpos，cut_ypos 切割框的起始位置坐标，cut_width，cut_height 切割框的宽与高
   */
    public Image effect_cut(Image src,int cut_xpos,int cut_ypos,int cut_width,int cut_height)
    {
          int srcW = src.getWidth();
          int srcH = src.getHeight();  
          int[] srcPixels = getPixels(src);
          int[] desPixels = new int[cut_width*cut_height];
          int argb;
   int num = 0;
          for (int i = 0; i < srcH; i++)
          {
            if(i >= cut_ypos&&i<cut_height+cut_ypos)
            {
                 for(int ii=0;ii<srcW;ii++)
          {
                    if(ii>=cut_xpos && ii<cut_width+cut_xpos)
      {
                         desPixels[num] = srcPixels[i*srcW+ii];    
                         num++;
                         
        }
   }
             }
         }
           return drawPixels(desPixels, cut_width, cut_height);
    }


    /*
   * 图片叠加，将src和image合成一张图片，x_pos，y_pos一般为0,0,也可以为自定义值
   */
    public Image effect_image_add_image(Image src,Image image,int x_pos,int y_pos)
    {   
             Image temp  = Image.createImage(src.getWidth(),src.getHeight());
      Graphics g = temp.getGraphics();
             //g.drawImage(src,x_pos,y_pos,Graphics.LEFT|Graphics.TOP);
      //g.drawImage(image,x_pos,y_pos,Graphics.LEFT|Graphics.TOP);*/ 
             int alpha = 168;
             int []srcRgbdata   =   new   int[src.getWidth()*src.getHeight()];   
             int []desRgbdata   =   new   int[image.getWidth()*image.getHeight()];  
             src.getRGB(srcRgbdata,0,src.getWidth(),0,0,src.getWidth(),src.getHeight());   
             image.getRGB(desRgbdata,0,image.getWidth(),0,0,image.getWidth(),image.getHeight());    
             g.drawRGB(getTransImg(alpha,srcRgbdata,desRgbdata),0,src.getWidth(),0,0,src.getWidth(),src.getHeight(),false);   
             src=null;   
             image=null;  
             return temp;
    }
    
     /*
   * 图片上添加字符
   */
    public Image effect_image_add_str(Image src,String str,int x_pos,int y_pos)
    { 
             Image temp = Image.createImage(src.getWidth(),src.getHeight());
      Graphics g = temp.getGraphics();
             g.drawImage(src,0,0,Graphics.LEFT|Graphics.TOP);
             g.setColor(0x000000);
   g.drawString(str,x_pos,y_pos,Graphics.LEFT|Graphics.TOP);
             return temp;
    }
 
     /*
   * 图片特效负片
   */
    public Image effect_negative(Image src)
    {
         int srcW = src.getWidth();
         int srcH = src.getHeight();  
         int[] srcPixels = getPixels(src);
         int r = 0;
         int g = 0;
         int b = 0;
         int a = 0;
         int argb;   
         for (int i = 0; i < srcH; i++)
         {
              for(int ii=0;ii<srcW;ii++)
        {
   argb = srcPixels[i*srcW+ii];
                        a = ((argb & 0xff000000) >> 24); // alpha channel
                        r =255-((argb & 0x00ff0000) >> 16); // red channel
                        g =255-((argb & 0x0000ff00) >> 8); // green channel
                        b =255-(argb & 0x000000ff); // blue channel
                        srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);
        }
         }
        return drawPixels(srcPixels, srcW, srcH);

         
    }

      /*
   * 图片特效黑白
   */
     public Image effect_black_white(Image src)
    {
         int srcW = src.getWidth();
         int srcH = src.getHeight();  
         int[] srcPixels = getPixels(src);
         int r = 0;
         int g = 0;
         int b = 0;
         int a = 0;
         int argb;
         int temp;
          
         for (int i = 0; i < srcH; i++)
         {
              for(int ii=0;ii<srcW;ii++)
        {
   argb = srcPixels[i*srcW+ii];
                        a = ((argb & 0xff000000) >> 24); // alpha channel
                        r = ((argb & 0x00ff0000) >> 16); // red channel
                        g = ((argb & 0x0000ff00) >> 8); // green channel
                        b = (argb & 0x000000ff); // blue channel
                        temp = (int)(.299*(double)r+.587*(double)g+.114*(double)b);
                        r = temp;
                        g = temp;
                        b = temp;
                        srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);
        }
         }
        return drawPixels(srcPixels, srcW, srcH);

         
    }
     
      /*
   * 图片特效粉笔画
   */
     public Image effect_crayon(Image src)
     { 
         int srcW = src.getWidth();
         int srcH = src.getHeight();  
         int[] srcPixels = getPixels(src);
         int r = 0;
         int g = 0;
         int b = 0;
         int a = 0;
         int argb;   
         int r1 = 0;
         int g1 = 0;
         int b1 = 0;
         int a1 = 0;
         int r2 = 0;
         int g2 = 0;
         int b2 = 0;
         int a2 = 0;
         
         for (int i = 0; i < srcH; i++)
         {
              for(int ii=0;ii<srcW;ii++)
       {
                  argb = srcPixels[i*srcW+ii];
                  a = ((argb & 0xff000000) >> 24); // alpha channel
                  r = ((argb & 0x00ff0000) >> 16); // red channel
                  g = ((argb & 0x0000ff00) >> 8); // green channel
                  b = (argb & 0x000000ff); // blue channel 
                  if(i+1 == srcH)
                  {
                       r1= 0;
                       g1= 0;
                       b1=0;
                  }
                  else
                  {
                     argb = srcPixels[(i+1)*srcW+ii]; 
                     //a1 = ((argb & 0xff000000) >> 24); // alpha channel
                     r1 = ((argb & 0x00ff0000) >> 16); // red channel
                     g1 = ((argb & 0x0000ff00) >> 8); // green channel
                     b1 = (argb & 0x000000ff); // blue channel 
                  }
                  if(ii+1 == srcW){
                       r2= 0;
                       g2= 0;
                       b2=0;
                  }
                  else
                  {
                      argb = srcPixels[i*srcW+ii+1]; 
                      r2 = ((argb & 0x00ff0000) >> 16); // red channel
                      g2 = ((argb & 0x0000ff00) >> 8); // green channel
                      b2 = (argb & 0x000000ff); // blue channel
                  }
                 // rr1=(r1-r2)^2  rr2=(r1-r3)^2
                  r = (int)Math.sqrt((double)(2*(r-r1)*(r-r1)+(r-r2)*(r-r2)));
                  g = (int)Math.sqrt((double)(2*(g-g1)*(g-g1)+(g-g2)*(g-g2)));
                  b = (int)Math.sqrt((double)(2*(b-b1)*(b-b1)+(b-b2)*(b-b2)));
                  r =255-r; // red channel
                  g =255-g; // green channel
                  b =255-b; // blue channel
                  srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);
              }
         }
         return drawPixels(srcPixels, srcW, srcH);
     }
     
         /*
   * 图片特效蒙版
   */
      public Image effect_hoodwink(Image src)
    {
         int srcW = src.getWidth();
         int srcH = src.getHeight();  
         int[] srcPixels = getPixels(src);
         int r = 0;
         int g = 0;
         int b = 0;
         int a = 0;
         int argb;

          
         for (int i = 0; i < srcH; i++)
         {
              for(int ii=0;ii<srcW;ii++)
        {
   argb = srcPixels[i*srcW+ii];
                        a = ((argb & 0xff000000) >> 24); // alpha channel
                        r = ((argb & 0x00ff0000) >> 16); // red channel
                        g = ((argb & 0x0000ff00) >> 8); // green channel
                        b = (argb & 0x000000ff); // blue channel
                        r = (int)(.299*(double)r);
                        g = (int)(.587*(double)g);
                        b = (int)(.114*(double)b);
                        srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);
        }
         }
        return drawPixels(srcPixels, srcW, srcH);

         
    }
     
    private   int[]   getTransImg(int alpha,int[] srcRgbdata,int[] desRgbdata)   
    {    
           int []   tempRgbData = new int[desRgbdata.length];   
        
           int   sr  ;
           int   sg ;
           int   sb ;
           int   dr  ;  
           int   dg ;
           int   db ; 
           int   tr  ;
           int   tg  ;
           int   tb  ;
           for(int   i=0;i<desRgbdata.length;i++)   
           {   
              sr   =   (srcRgbdata[i]&0xff0000)>>16;   
              sg   =   (srcRgbdata[i]&0xff00)>>8;   
              sb   =   srcRgbdata[i]&0xff;   
              dr   =   (desRgbdata[i]&0xff0000)>>16;   
              dg   =   (desRgbdata[i]&0xff00)>>8;   
              db   =   desRgbdata[i]&0xff;   
              tr   =   (sr*alpha   +   dr*(255-alpha))/255;   
              tg   =   (sg*alpha   +   dg*(255-alpha))/255;   
              tb   =   (sb*alpha   +   db*(255-alpha))/255;     
              tempRgbData[i]   =   (tr<<16)|(tg<<8)|tb;   
           }   
         return   tempRgbData;   
       } 
    
         /*
   * 图片特旋转
   */
    public Image effect_rotate(Image src,int direction) 
    { 
        Sprite sprite = new Sprite(src);
        switch(direction)
        {
                  case 1:
                            sprite.setTransform(sprite.TRANS_ROT270);
                            break;
                  case 2:
                            sprite.setTransform(sprite.TRANS_ROT90);   
                            break;
        }
       
        Image temp = Image.createImage(src.getHeight(),src.getWidth());
  Graphics g = temp.getGraphics();
        sprite.setPosition(0,0);
        sprite.paint(g);
        return temp;   
     } 

    
   

       /*
   * 图片特霓虹灯
   */
    public Image effect_neonLight(Image src)
    {
         int srcW = src.getWidth();
         int srcH = src.getHeight();  
         int[] srcPixels = getPixels(src);
         int r = 0;
         int g = 0;
         int b = 0;
         int a = 0;
         int argb;   
         int r1 = 0;
         int g1 = 0;
         int b1 = 0;
         int a1 = 0;
         int r2 = 0;
         int g2 = 0;
         int b2 = 0;
         int a2 = 0;
         
         for (int i = 0; i < srcH; i++)
         {
              for(int ii=0;ii<srcW;ii++)
       {
                  argb = srcPixels[i*srcW+ii];
                  a = ((argb & 0xff000000) >> 24); // alpha channel
                  r = ((argb & 0x00ff0000) >> 16); // red channel
                  g = ((argb & 0x0000ff00) >> 8); // green channel
                  b = (argb & 0x000000ff); // blue channel 
                  if(i+1 == srcH)
                  {
                       r1= 0;
                       g1= 0;
                       b1=0;
                  }
                  else
                  {
                     argb = srcPixels[(i+1)*srcW+ii]; 
                     //a1 = ((argb & 0xff000000) >> 24); // alpha channel
                     r1 = ((argb & 0x00ff0000) >> 16); // red channel
                     g1 = ((argb & 0x0000ff00) >> 8); // green channel
                     b1 = (argb & 0x000000ff); // blue channel 
                  }
                  if(ii+1 == srcW){
                       r2= 0;
                       g2= 0;
                       b2=0;
                  }
                  else
                  {
                      argb = srcPixels[i*srcW+ii+1]; 
                      r2 = ((argb & 0x00ff0000) >> 16); // red channel
                      g2 = ((argb & 0x0000ff00) >> 8); // green channel
                      b2 = (argb & 0x000000ff); // blue channel
                  }
                 // rr1=(r1-r2)^2  rr2=(r1-r3)^2
                  r = (int)Math.sqrt((double)(2*(r-r1)*(r-r1)+(r-r2)*(r-r2)));
                  g = (int)Math.sqrt((double)(2*(g-g1)*(g-g1)+(g-g2)*(g-g2)));
                  b = (int)Math.sqrt((double)(2*(b-b1)*(b-b1)+(b-b2)*(b-b2)));
                  srcPixels[i*srcW+ii] = ((a << 24) | (r << 16) | (g << 8) | b);
              }
         }
         return drawPixels(srcPixels, srcW, srcH);
    }

}

图片的透明处理：

/**
     * 
     * @param img
     *            原始图片
     * @param transparent
     *            透明度 0-255之间
     * @return 处理透明度后的图片
     */
    public static Image effect_transparent(Image img, int transparent) {
        if (transparent < 0 || transparent > 255)
            return img;

        int srcW = img.getWidth();
        int srcH = img.getHeight();
        int[] srcPixels = getPixels(img); //函数功能 讲图片数据存入指定数组

        for (int i = 0; i < srcPixels.length; i++) {
            int a = srcPixels[i] >> 24;
            srcPixels[i] = (transparent << 24) | (srcPixels[i] & 0x00ffffff);

        }
        return drawPixels(srcPixels, srcW, srcH); //将数组转化为图片
    }

还有一个任意角度翻转函数:

/**
    *@param imgSource  源图像
    *@param cx   旋转点相对于源图像坐上角横坐标
    *@param cy   旋转点相对于源图像坐上角纵坐标
    *@param theta 图像逆时针旋转的角度
    *@return 旋转后的图像
    */
    public Image rotate(Image imgSource, int cx, int cy, double theta) 
    {
        if (Math.abs(theta % 360) < 1)
            return imgSource; //角度很小时直接返回

        int w1 = imgSource.getWidth(); //原始图像的高度和宽度

        int h1 = imgSource.getHeight();

        int[] srcMap = new int[w1 * h1];

        imgSource.getRGB(srcMap, 0, w1, 0, 0, w1, h1); //获取原始图像的像素信息

        int dx = cx > w1 / 2 ? cx : w1 - cx; //计算旋转半径

        int dy = cy > h1 / 2 ? cy : h1 - cy;

        double dr = Math.sqrt(dx * dx + dy * dy);

        int wh2 = (int) (2 * dr + 1); //旋转后新图像为正方形，其边长+1是为了防止数组越界

        int[] destMap = new int[wh2 * wh2]; //存放新图像象素的数组

        double destX, destY;

        double radian = theta * Math.PI / 180; //计算角度计算对应的弧度值

        for (int i = 0; i < w1; i++) {
            for (int j = 0; j < h1; j++) {
                if (srcMap[j * w1 + i] >> 24 != 0) { //对非透明点才进行处理
                    // 得到当前点经旋转后相对于新图像左上角的坐标
                    destX = dr + (i - cx) * Math.cos(radian) + (j - cy)
                            * Math.sin(radian);
                    destY = dr + (j - cy) * Math.cos(radian) - (i - cx)
                            * Math.sin(radian);
                    //从源图像中往新图像中填充像素
                    destMap[(int) destY * wh2 + (int) destX] = srcMap[j * w1
                            + i];
                }
            }
        }
        return Image.createRGBImage(destMap, wh2, wh2, true); //返回旋转后的图像
    }

以上所有代码均来自于互联网，在此仅为备份以便后查。