j2me工具类ImageUtil.java

最新推荐文章于 2018-05-19 20:43:26 发布
最新推荐文章于 2018-05-19 20:43:26 发布
阅读量89 收藏
点赞数
分类专栏： j2me 文章标签： Java 360 J#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gundumw100/article/details/83481766
版权 

# 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);  
#     }  
#   
# }


图片的透明处理 其实和第一个渐变效果差不多 只不多这个函数中多了一个透明度参数 使用起来更加方便 

   1. /** 
   2.      *  
   3.      * @param img 
   4.      *            原始图片 
   5.      * @param transparent 
   6.      *            透明度 0-255之间 
   7.      * @return 处理透明度后的图片 
   8.      */  
   9.     public static Image effect_transparent(Image img, int transparent) {  
  10.         if (transparent < 0 || transparent > 255)  
  11.             return img;  
  12.   
  13.         int srcW = img.getWidth();  
  14.         int srcH = img.getHeight();  
  15.         int[] srcPixels = getPixels(img); //函数功能 讲图片数据存入指定数组  
  16.   
  17.         for (int i = 0; i < srcPixels.length; i++) {  
  18.             int a = srcPixels[i] >> 24;  
  19.             srcPixels[i] = (transparent << 24) | (srcPixels[i] & 0x00ffffff);  
  20.   
  21.         }  
  22.         return drawPixels(srcPixels, srcW, srcH); //将数组转化为图片  
  23.     }


任意角度翻转函数 

   1. /** 
   2.     *@param imgSource  源图像 
   3.     *@param cx   旋转点相对于源图像坐上角横坐标 
   4.     *@param cy   旋转点相对于源图像坐上角纵坐标 
   5.     *@param theta 图像逆时针旋转的角度 
   6.     *@return 旋转后的图像 
   7.     */  
   8.     public Image rotate(Image imgSource, int cx, int cy, double theta)   
   9.     {  
  10.         if (Math.abs(theta % 360) < 1)  
  11.             return imgSource; //角度很小时直接返回  
  12.   
  13.         int w1 = imgSource.getWidth(); //原始图像的高度和宽度  
  14.   
  15.         int h1 = imgSource.getHeight();  
  16.   
  17.         int[] srcMap = new int[w1 * h1];  
  18.   
  19.         imgSource.getRGB(srcMap, 0, w1, 0, 0, w1, h1); //获取原始图像的像素信息  
  20.   
  21.         int dx = cx > w1 / 2 ? cx : w1 - cx; //计算旋转半径  
  22.   
  23.         int dy = cy > h1 / 2 ? cy : h1 - cy;  
  24.   
  25.         double dr = Math.sqrt(dx * dx + dy * dy);  
  26.   
  27.         int wh2 = (int) (2 * dr + 1); //旋转后新图像为正方形，其边长+1是为了防止数组越界  
  28.   
  29.         int[] destMap = new int[wh2 * wh2]; //存放新图像象素的数组  
  30.   
  31.         double destX, destY;  
  32.   
  33.         double radian = theta * Math.PI / 180; //计算角度计算对应的弧度值  
  34.   
  35.         for (int i = 0; i < w1; i++) {  
  36.             for (int j = 0; j < h1; j++) {  
  37.                 if (srcMap[j * w1 + i] >> 24 != 0) { //对非透明点才进行处理  
  38.                     // 得到当前点经旋转后相对于新图像左上角的坐标  
  39.                     destX = dr + (i - cx) * Math.cos(radian) + (j - cy)  
  40.                             * Math.sin(radian);  
  41.                     destY = dr + (j - cy) * Math.cos(radian) - (i - cx)  
  42.                             * Math.sin(radian);  
  43.                     //从源图像中往新图像中填充像素  
  44.                     destMap[(int) destY * wh2 + (int) destX] = srcMap[j * w1  
  45.                             + i];  
  46.                 }  
  47.             }  
  48.         }  
  49.         return Image.createRGBImage(destMap, wh2, wh2, true); //返回旋转后的图像  
  50.     }


图片的缩放和透明效果 

public static final Image zoomImage(Image src){
return zoomImage(src,src.getWidth(),src.getHeight(),true,false);
}
public static final Image zoomImage(Image src, int desW, int desH, boolean isBackgroundTrans, boolean isTrans) {
Image desImg = null;
int srcW = src.getWidth(); // source image width
int srcH = src.getHeight(); // source image height
int[] srcBuf = new int[srcW * srcH]; // source image pixel
src.getRGB(srcBuf, 0, srcW, 0, 0, srcW, srcH);
// compute interpolation table
int[] tabY = new int[desH];
int[] tabX = new int[desW];
int sb = 0;
int db = 0;
int tems = 0;
int temd = 0;
int distance = srcH > desH ? srcH : desH;
for ( int i = 0 ; i <= distance ; i++) { /* vertical direction */
tabY[db] = sb;
tems += srcH;
temd += desH;
if ( tems > distance) {
tems -= distance;
sb++;
}
if ( temd > distance) {
temd -= distance;
db++;
}
}
sb = 0;
db = 0;
tems = 0;
temd = 0;
distance = srcW > desW ? srcW : desW;
for ( int i = 0 ; i <= distance ; i++) { /* horizontal direction */
tabX[db] = (short) sb;
tems += srcW;
temd += desW;
if ( tems > distance) {
tems -= distance;
sb++;
}
if ( temd > distance) {
temd -= distance;
db++;
}
}
// set transparence
// if(isTrans){
// int a= 100;//set the transparence of pixel 100
// for(int i=0;i<srcBuf.length;i++){
// if(srcBuf[i]==0x00FFFFFF)continue;
// srcBuf[i]=(a<<24) | (srcBuf[i] & 0x00FFFFFF);// modify the highest 2 value
// }
// }

// formation enlarge and shorten buffer pixel
int[] desBuf = new int[desW * desH];
int dx = 0;
int dy = 0;
int sy = 0;
int oldy = -1;
for ( int i = 0 ; i < desH ; i++) {
if ( oldy == tabY[i]) {
System.arraycopy(desBuf, dy - desW, desBuf, dy, desW);
}
else {
dx = 0;
for ( int j = 0 ; j < desW ; j++) {
desBuf[dy + dx] = srcBuf[sy + tabX[j]];
dx++;
}
sy += (tabY[i] - oldy) * srcW;
}
oldy = tabY[i];
dy += desW;
}
if(isTrans){
// int a= 100;//set the transparence of pixel 100
for(int i=0;i<desBuf.length;i++){
if(desBuf[i]==0x00FFFFFF)continue;
int alpha = ((desBuf[i] & 0xff000000) >>> 24)==0?0:100;
desBuf[i]=((alpha+1)<<24) | (desBuf[i] & 0x00FFFFFF);// modify the highest 2 value
}
}
if(isBackgroundTrans){
desImg = Image.createRGBImage(desBuf, desW, desH, true);
}else{
desImg = Image.createRGBImage(desBuf, desW, desH, false);
}

return desImg;
}
gundumw100
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ImageUtil.java
07-27
本文件是图片验证码工具类，作用是生成一个四位数的图片验证码
j2me-ImageItem类
深未来技术
12-21 337
代码如下: package hello;import javax.microedition.midlet.*;import javax.microedition.lcdui.*;public class HelloMIDlet extends MIDlet implements CommandListener{    privateboolean midletPause
图片处理工具类 - ImageUtils.java
weixin_33895516的博客
05-04 253
纯JAVA实现的图片处理工具类，提供图片的裁剪、压缩、获取尺寸、制作圆角等方法。   源码如下：(点击下载 -ImageUtils.java 、FolderUtils.java 、commons-io-2.4.jar、commons-lang-2.6.jar) import java.awt.AlphaComposite; import java.awt.Color; import ...
3G视线J2ME 工具包0.0.1版本发布了
无花专栏--http://www.ucweb.com
05-12 699
关键字: J2ME        自己利用国庆的时间，把以前自己做过，实践过的一些想法，整合成了一堆代码跟例子，我暂且把它们叫做 3G视线J2ME 工具包0.0.1版本。 里面的内容包括： 关于我们 3GEye 是由一个软件自由职业团队组成，他们分散不同的地方，但是却有一个相同的目的--致力于中国手机软件开发的普及，3G就快要到来了，我们不想在落后别人了。手机软件开发
Winter.Sports.Foreign.J2ME.programming..rar_Java_
08-12
3. **用户界面设计**：J2ME中的用户界面通常基于WTK（Wireless Toolkit）提供的 Lightweight User Interface Toolkit (LWUIT) 或者 MIDP 的Canvas类。开发者需要学习如何绘制图形、处理触摸事件和动画效果，以创建...
J2me数据库引擎类.rar_j2me_rms
09-21
这类文件通常由J2ME开发工具生成，以便在设备上正确地初始化和恢复RMS存储。 3. **www.pudn.com.txt**：这个文件可能是从网站www.pudn.com下载资源时一同打包的说明文件或者版权信息。通常，它不会包含与RMS数据库...
基于Java的源码-毕业设计一款J2me飞行射击游戏.zip
07-23
通常，J2ME项目的源码文件会包括.java文件，这些文件包含了游戏的各个类和方法，例如主类、游戏循环、游戏对象类、图像资源管理类等。 【详细知识点】 1. **Java基础**：掌握基本的Java语法，包括变量、数据类型、...
Java毕业设计一款J2me飞行射击游戏.zip
08-28
Java毕业设计一款基于J2ME的飞行射击游戏是一项常见的编程实践任务，旨在让学生掌握Java语言在移动设备开发中的应用，特别是Java Micro Edition (J2ME) 平台。J2ME是Java平台的一个子集，专门用于嵌入式设备，如早期...
基于Java的实例源码-毕业设计一款J2me飞行射击游戏.zip
06-28
1. **源代码文件**：.java文件，包含了游戏的主要逻辑，如主类、游戏循环、角色类、敌机类等。 2. **资源文件**：如图像、音频和配置文件，这些通常是游戏界面和音效的组成部分。 3. **项目配置**：如J2ME的Midlet...
ImageUtil 工具类
xuanzeticai的专栏
11-12 972
package com.itcast.util; import java.io.BufferedInputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.net.URL; import java.net.URLConnection; impo
BufferedImage.getRGB()方法的异常，合并两个图片报错异常
Mint6的博客
05-19 3592
异常报错1.java.lang.ArrayIndexOutOfBoundsException: Coordinate out of bounds! at sun.awt.image.ByteInterleavedRaster.getDataElements(ByteInterleavedRaster.java:318) at java.awt.image.BufferedImage...
Image 的 getRGB方法
pdw_jsp的专栏
03-24 3080
第一次自己翻译文章，翻译不到位的地方忘体谅！废话少说直接上东西了函数原型public void getRGB(int[] rgbData, int offset, int scanlength, int x,int y, int width, int height)获得一个指定图像区域的ARGB数据并且存储在一个提供的整形数组里，每一个像素的值存储成一个16进制的格式，最高位包含了alpha 通道，并且也分别保存了图像的R , G , B 值。alpha 通道指明了像素的透明度的问题，其中0x00代表的
Java的图片处理工具类ImageUtils
热门推荐
技术分享
07-19 2万+
可实现以下常用功能：缩放图像、切割图像、图像类型转换、彩色转黑白、文字水印、图片水印等
ant-design-vue-1.1.10-beta.zip
最新发布
08-26
基于 Ant Design 和 Vue 的企业级 UI 组件库
J2ME入门：微型版Java平台详解
"该资源是一份关于J2ME开发的PPT，主要介绍了J2ME的基本概念、Java平台的三个版本（J2SE、J2EE、J2ME）、J2ME在不同设备上的应用以及JVM的三种实现——CVM、KVM和CardVM。课程还提供了相关的教材和参考书，并提到了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值