j2me上面实现图片的特效 （缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画,蒙版）等功能

最新推荐文章于 2020-07-17 09:53:26 发布
最新推荐文章于 2020-07-17 09:53:26 发布
阅读量663 收藏
点赞数
分类专栏： j2me 文章标签： j2me image null import string class

系统条件：MIDP2.0，cldc1.1

代码如下：
 
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);
     }
 
}
 
 
 
 
 
 

fengyeen
关注
专栏目录
j2me 的关于图片的处理 源码(缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画)
05-30
本文将深入探讨如何使用J2ME进行图片处理，包括缩放、裁剪、调整大小、镜像翻转、对比度和亮度调整、黑白效果、线条艺术以及粉笔画效果。我们将以`ImageUtil.java`为例，讲解源码中封装的类和方法。 首先，`...
JavaScript图像处理(2) - 亮度对比度调整(Brightness/Contrast)
Peihong's Infinite Dimensional Space
11-15 8848
基本的图像处理操作之一是颜色操作，也就是根据一定的规则修改图像中像素的值。例如说改变图像的亮度、对比度，进行色彩替换，或者是对图像进行曲线操作，复杂一点的还有色彩空间矢量化等。 修改图像的亮度和对比度实际上是对像素值进行线性变换： r = r * alpha + beta g = g * alpha + beta b = b * alpha + beta 亮度变化比较简单，就是在上面
基于j2me的图片特效（缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画）
偷得浮生半日闲
04-12 3955
最近需要完成一个在j2me上面实现图片的特效 （缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画,蒙版）等功能，于是写了一些算法完成了以上功能，系统条件：MIDP2.0，cldc1.1 代码如下：ImageUtil /* * ImageUtil.java * * Created on 2008年1月11日, 上午9:26 * *//**
图像像素处理_明度/亮度/平均值/灰褐色/滤镜/灰色_canvas_js动画
07-25 2820
本文参考《写给Web开发人员看的HTML5教程》 其他滤镜可参考jacob Seidelin的Pixastic图像处理库(http://www.pixastic.com/lib),那里有超过30种javascript滤镜，均基于Mozilla的公开授权。 //明度 function grayLigtness(r,g,b,a){ var val=parseInt(
HTML5画布kineticjs照亮或变暗的图像教程
终是如此也需努力
09-03 844
照亮或变暗的图像kineticjs，我们可以使用kinetic.filters.brighten滤波器与filterbrightness财产的亮度设置。亮度属性可以设置为255和255之间的任意整数。负值变暗的图像，使图像和正面的价值观。 说明：滑动控制来调整亮度 body { margin: 0px; pad
图像处理之调整亮度与对比度
weixin_34191845的博客
03-22 2033
图像处理之调整亮度与对比度 很多时候，一张图像被过度曝光显得很白，或者光线不足显得很暗，有时候背景跟图像人物 也观察不清楚，这个时候可以通过调节图像的两个基本属性-亮度与对比度来获得整体效果 的提升，从而得到质量更高的图片。 基本原理： 图像亮度本质上图像中每个像素的亮度，每个像素的亮度本质上RGB值的大小，RGB值为0 是像素点为黑色，RGB都为25...
基于j2me的图片特效处理类
06-27
基于j2me的图片特效处理类（缩放，裁剪，调整大小，镜像，对比度亮度调整，黑白，线条，粉笔画）
j2me图片特效包及demo程序
07-08
开发者可以遍历图片的每个像素，根据对比度和亮度系数调整 RGB 值。对于亮度调整，可以简单地加减一个常数值；对比度调整则需要对颜色值进行缩放和偏移。 7. **黑白效果**：可以将彩色图片转换为灰度图片，方法是将...
j2me图片缩放方法
03-27
### j2me图片缩放方法详解 在J2ME（Java 2 Micro Edition）平台下进行图像处理时，图片的缩放是一个常见的需求。本文将详细介绍三种不同的图片缩放方法，包括它们的工作原理、实现代码及适用场景。 #### 方法一：...
PDA.rar_PDA_j2me_j2me 图片_j2me 文件_j2me 通信
09-24
在移动设备领域，个人数字助手（PDA）与Java ME（J2ME）技术结合，为开发者提供了在手机上实现类似PDA功能的平台。本文将深入探讨如何使用J2ME进行通信录管理、文件操作以及图片处理，同时介绍一个名为"PDAPDemo"的...
粉笔画教程雪花的粉笔画画法
河南省电闪雷鸣文化传媒有限公司
07-17 1198
1.从利用粉笔画出基本的雪花形状开始，并在线条相交的中心添加填充的心形。 2.绘制华丽的雪花就是所有微小的细节。从心形的上方利用粉笔画出小小的V形装饰。 3.在每个线条之间，添加几行看起来像珍珠的圆形图案。利用粉笔画一个小圆圈，但不要实心填充，请用手指涂抹粉笔。这将使它看起来更像一个立体的圆形。 4.继续添加粉笔画出的白色圆形图案，从最靠近中心的最大圆形图案开始，逐渐变小。 5.添加从主线条伸出的小对角线。这种羽毛状的形状将与圆形形成鲜明对比。 6.用粉笔画出小小的心形盖住线条顶端。 7.用粉.
J2ME图片浏览器
Smallearth的专栏
05-26 127
package Mypaint; import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import javax.microedition.midlet.MIDletStateChangeException; public class mypaint extends MIDlet { privat...
收集了几个关于J2ME图片缩放的函数
千里积于跬步，江海成于小流
11-26 1029
收集了几个图像缩放函数，可能实现的方式很多，感觉这几个还是不错的，分享下说明：以下函数都是基于MIDP2.0的，缩放后保留透明色。代码1，resizeImage函数 public static Image resizeImage(Image src, int destW, int destH) { int srcW = src.getWidth();
j2me图片大小、剪切、透明等处理
阿当
02-23 906
<br />image = Image.createImage("/images.png");<br /><br /><br />图片是以位表示的一个数组。<br />对数组的处理时各种图片处理的老祖宗<br />下面是在网上摘抄的加上了一下自己处理的一个图片处理类<br />import javax.microedition.lcdui.*; import javax.microedition.lcdui.game.Sprite; public class ImageUtil { pu
Jupyter_关于长期序列预测NeurIPS 2021的自耦分解变压器的代码发布.zip
11-14
Jupyter-Notebook
考研公共课历年真题集-最新发布.zip
最新发布
11-14
考研公共课历年真题集-最新发布.zip
2006-2023年上市公司资产误定价Misp数据集（4.9万样本，含原始数据、代码及结果，最新）.zip
11-14
2006-2023年上市公司资产误定价Misp数据集（4.9万样本，含原始数据、代码及结果，最新）.zip
使用J2ME实现翻书特效教程
"这篇教程介绍了如何在J2ME（Java 2 Micro Edition）平台上实现一个图片翻书的特效。通过处理图片，模拟真实的图书翻页动态效果，为移动设备的应用增添趣味性和互动性。" 在J2ME开发中，图片处理是一项重要的任务，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值