用java实现图片渐变叠加（3种方法）（转）

最新推荐文章于 2022-04-07 17:06:25 发布
最新推荐文章于 2022-04-07 17:06:25 发布
阅读量316 收藏 1
点赞数
文章标签： java

437693588787331680.jpg


原理上是2种方法，但是可以用3种方法实现（没想到花了我那么多时间）： 1.是根据alpha值计算，象素的各单色分量衰减后相加；2.是修改一张图片的透明度，然后用画到另一张图片上面；3.是象素点的插值，不涉及透明度的使用。

实现过程描述如下：

一。根据alpha值计算

  把图片的象素分离出来。原图的alpha值都设为0xff。确定一张图片A渐变的衰减系数div（0～1），另一张图片B的衰减就是1－div。

div=row/range; row是递增的行，range是渐变范围。

合成渐变的象素的公式我发现是：

color=(A.blue+A.green+A.red)*div+(B.blue+B.green+B.red)*(1-div)

A表示图片A的某点象素，B表示图片B的某点象素。当然实现上各种颜色不能直接相加，要位移相应的位，然后 进行或运算。

二。修改透明度

   修改图片B的渐变范围象素的alpha值，alpha为0就是透明，0xff为不透明。渐变就是alpha的值的递变。然后以图片B的大小，新建一个图像缓冲bi

Graphics2D g2= (Graphics2D)bi.getGraphics();
        g2.drawImage(imageA.getImage(),0,0,null)//将图片A画入缓冲区bi

        最后把修改好的半透明图片画入bi
        g2.drawImage(image,0,0,null);

最后完整的图片渐变叠加就保存在了这个缓冲区内。最后输出图片即可。

javax.imageio.ImageIO.write(bi, "JPEG", new java.io.File(filename));

我想应该还有别的办法可以实现：对两张图片的象素，基于alpha值进行计算，是可以合成渐变效果的象素 的。目前还没有试验出这个计算方法。

三。象素插值。等差数列的原理。

 有两张图片A,B，图片A的象素密度随横坐标的的增加减小，图片B的密度与图片A变化相反。

 我用的方法是，描述每一列相隔row行，需要插入一个象素。row这个变量的取值，在纸面上画出来的曲线，是在渐变区先增后减的一次函数。转折点是渐变区的中点。

 

下面的代码按顺序对应的上面的每种方法。每个程序用图片分割。

3696610869141207574.jpg 

//SpliceCount.java
/*
 *author by liuke
 *email:  soulnew@gmail.com
 *blog:  souljava.blog.163.com
 **/

package com.soulnew.Pixel;
import java.awt.image.PixelGrabber;
import java.awt.Image;
import java.awt.image.ImageObserver;
import  javax.swing.ImageIcon;
import java.io.FileWriter;
import javax.swing.JFrame;
import java.awt.image.MemoryImageSource;
import  java.awt.Graphics2D;
import java.io.File;
public class SpliceCount{
 int pixels[];
 int Aw,Ah,Bw,Bh;
 int Wmax,Hmax;  //the size of splice image
 int arrayImageA[],arrayImageB[];   //arrays used to save the pixels
 String imagepathA="images/try.gif"; //you can change the image path here
 String imagepathB="images/fruit1.jpg";
 String utputimage="SpliceCount.jpg";
 FileWriter fw;  //used to write log
 int index=0;
 ImageIcon imageA,imageB;
 public SpliceCount(){
  
  imageA=new ImageIcon(imagepathA);
  imageB=new ImageIcon(imagepathB);
  
  Aw=imageA.getIconWidth();
  Ah=imageA.getIconHeight();
  Bw=imageB.getIconWidth();
  Bh=imageB.getIconHeight();
  arrayImageA=handlepixels(imageA.getImage(),0,0,Aw,Ah);
  arrayImageB=handlepixels(imageB.getImage(),0,0,Bw,Bh);
  if(arrayImageA!=null&&arrayImageB!=null){
   
   doSplice(arrayImageA,arrayImageB);   
   Image image=createImage(pixels);
   saveImage(image,outputimage);
  }
  if(fw!=null){
   try{
    fw.close();
   }catch(Exception e){
    e.printStackTrace();
   }   
  }
 }
 
 public void doSplice(int[] imageA,int[] imageB){
  pixels=imageB;
  Hmax=Bh;
  Wmax=Bw;
  int rangeFrom=Bw/4;
  int rangeTo=Bw*3/4;
     int range=Bw>>1;
      
  for(int i=rangeFrom;i      float div=(float)(rangeTo-i)/(float)range;
      if(i>rangeTo){   //渐变范围以外，不衰减
       div=0;       
      }                
      float div1=1-div;  //渐变左边范围以外，不衰减，用imgeA填充
     
     
      for(int j=0;j       int pixel=pixels[j*Bw+i];
       int alpha = (pixel >> 24) & 0xff; //分离imageB象素好相加
             int red   = (pixel >> 16) & 0xff;       
             int green = (pixel >>  8) & 0xff;
             int blue  = (pixel     ) & 0xff;
             
             int alpha1,red1,green1,blue1;
             pixel=imageA[j*Aw+i];  //准备分离imageA象素
             if(i>Aw||j>Ah){    //imageA 的大小不够，用白色填充
              alpha1 = 0xff;
               red1 = 0xff;
               green1= 0xff;
               blue1= 0xff;
             }else{
               alpha1 = (pixel >> 24) & 0xff;
                  red1   = (pixel >> 16) & 0xff;       
                  green1 = (pixel >>  8) & 0xff;
                  blue1  = (pixel     ) & 0xff;
             }            
             
       alpha=0xff;
       red =Math.round(red*div+red1*div1); //象素按每种颜色的衰减相加
       green =Math.round(green*div+green1*div1);
       blue =Math.round(blue*div+blue1*div1);
       
          pixels[j*Bw+i]=(alpha<<24)|(red<<16)|(green<<8)|(blue); //合成颜色  
         
   }
  } 
 }
 public void writePixel2File(int color){
     index++;
     
     if(fw==null){
      try{
     fw =new FileWriter("pixel.txt");
     }catch(Exception e){
      e.printStackTrace();
     }
     }             
        try{
         if(index%100==0)
         fw.write("\n");
         
         fw.write("\t"+color);
        }catch(Exception e){
         e.printStackTrace();
        }
    }
 
 public Image createImage(int[] colors){
     JFrame. jf=new JFrame();
        Image modImg = jf.createImage(
              new MemoryImageSource(           
             Wmax,Hmax,colors,0,Wmax));
        return modImg;
    }
   
 
 public void saveImage(Image image,String filename){     
     java.awt.image.BufferedImage bi = new java.awt.image.BufferedImage(Wmax, Hmax, java.awt.image.BufferedImage.TYPE_INT_BGR);
        Graphics2D g2= (Graphics2D)bi.getGraphics();
      
        g2.drawImage(image,0,0,null);
       
        try{
         javax.imageio.ImageIO.write(bi, "JPEG", new java.io.File(filename));
        }catch(Exception e){
         e.printStackTrace();
        }       
    }
   
 public int[] handlepixels(Image img, int x, int y, int w, int h) {
        int[] pixel = new int[w * h];               
        PixelGrabber pg = new PixelGrabber(img, x, y, w, h, pixel, 0, w);
        try {
            pg.grabPixels();
        } catch (InterruptedException e) {
            System.err.println("interrupted waiting for pixels!");
           
        }
        if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
            System.err.println("image fetch aborted or errored");
        }      
        return pixel;
    }
 public static void main(String[] args){
  SpliceCount splice=new SpliceCount();
 }
}

437693588787331680.jpg

3437090940613986752.jpg2571273912251995015.jpg

/*
 *author by liuke
 *email:  soulnew@gmail.com
 *blog:  souljava.blog.163.com
 **/

package com.soulnew.Pixel;
import java.awt.image.PixelGrabber;
import java.awt.Image;
import java.awt.image.ImageObserver;
import  javax.swing.ImageIcon;
import java.io.FileWriter;
import javax.swing.JFrame;
import java.awt.image.MemoryImageSource;
import  java.awt.Graphics2D;
import java.io.File;
public class SpliceAlpha{
 int pixels[];
 int Aw,Ah,Bw,Bh;
 int Wmax,Hmax;  //the size of splice image
 int arrayImageA[],arrayImageB[];   //arrays used to save the pixels
 String imagepathA="images/try.gif"; //you can change the image path here
 String imagepathB="images/fruit1.jpg";
 String utputimage="splicealpha.jpg";
 FileWriter fw;  //used to write log
 int index=0;
 ImageIcon imageA,imageB;
 public SpliceAlpha(){
  
  imageA=new ImageIcon(imagepathA);
  imageB=new ImageIcon(imagepathB);
  
  Aw=imageA.getIconWidth();
  Ah=imageA.getIconHeight();
  Bw=imageB.getIconWidth();
  Bh=imageB.getIconHeight();
  arrayImageA=handlepixels(imageA.getImage(),0,0,Aw,Ah);
  arrayImageB=handlepixels(imageB.getImage(),0,0,Bw,Bh);
  if(arrayImageA!=null&&arrayImageB!=null){
   
   doSplice(arrayImageA,arrayImageB);   
   Image image=createImage(pixels);
   saveImage(image,outputimage);
  }
  if(fw!=null){
   try{
    fw.close();
   }catch(Exception e){
    e.printStackTrace();
   }   
  }
 }
 
 public void doSplice(int[] imageA,int[] imageB){
  pixels=imageB;
  Hmax=Bh;
  Wmax=Bw;
  int rangeFrom=Bw/4;
  int rangeTo=Bw*3/4;
     int range=Bw>>1;
      
  for(int i=rangeFrom;i      float div=(float)(rangeTo-i)/(float)range;
      int alpha=(int)(0xff*div);
      alpha=alpha<<24;
     
      for(int j=0;j       if(i>=rangeTo){
         pixels[j*Bw+i]=0;
           continue;
          }
      pixels[j*Bw+i]=pixels[j*Bw+i]&0xffffff;    
      pixels[j*Bw+i]=pixels[j*Bw+i]|(alpha);
     
   }
  } 
 }
 public void writePixel2File(int color){
     index++;
     
     if(fw==null){
      try{
     fw =new FileWriter("pixel.txt");
     }catch(Exception e){
      e.printStackTrace();
     }
     }             
        try{
         if(index%100==0)
         fw.write("\n");
         
         fw.write("\t"+color);
        }catch(Exception e){
         e.printStackTrace();
        }
    }
 
 public Image createImage(int[] colors){
     JFrame. jf=new JFrame();
        Image modImg = jf.createImage(
              new MemoryImageSource(           
             Wmax,Hmax,colors,0,Wmax));
        return modImg;
    }
   
 
 public void saveImage(Image image,String filename){     
     java.awt.image.BufferedImage bi = new java.awt.image.BufferedImage(Wmax, Hmax, java.awt.image.BufferedImage.TYPE_INT_BGR);
        Graphics2D g2= (Graphics2D)bi.getGraphics();
        g2.drawImage(imageA.getImage(),0,0,null);
        g2.drawImage(image,0,0,null);
       
        try{
         javax.imageio.ImageIO.write(bi, "JPEG", new java.io.File(filename));
        }catch(Exception e){
         e.printStackTrace();
        }       
    }
   
 public int[] handlepixels(Image img, int x, int y, int w, int h) {
        int[] pixel = new int[w * h];               
        PixelGrabber pg = new PixelGrabber(img, x, y, w, h, pixel, 0, w);
        try {
            pg.grabPixels();
        } catch (InterruptedException e) {
            System.err.println("interrupted waiting for pixels!");
           
        }
        if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
            System.err.println("image fetch aborted or errored");
        }      
        return pixel;
    }
 public static void main(String[] args){
  SpliceAlpha splice=new SpliceAlpha();
 }
}

 

430656714369465021.jpg

3437090940613986752.jpg2571273912251995015.jpg

用象素交错填充的办法实现的图片叠加。

效果不怎么好

/*
 *author by liuke
 *email:  soulnew@gmail.com
 *blog:  souljava.blog.163.com
 **/

package com.soulnew.Pixel;
import java.awt.image.PixelGrabber;
import java.awt.Image;
import java.awt.image.ImageObserver;
import  javax.swing.ImageIcon;
import java.io.FileWriter;
import javax.swing.JFrame;
import java.awt.image.MemoryImageSource;
import  java.awt.Graphics2D;
import java.io.File;


public class Splice{
 int arrayImageA[],arrayImageB[];   //arrays used to save the pixels
 String imagepathA="images/try.gif"; //you can change the image path here
 String imagepathB="images/fruit1.jpg";
 int rangeFrom,rangeTo; //the transition range from one position to another
 int splicePixel[];
 int Aw,Ah,Bw,Bh;
 int Wmax,Hmax;  //the size of splice image
 String utputimage="splice.jpg";
 int index=0;
 FileWriter fw;
 
 
 public Splice(){
  
  ImageIcon imageA=new ImageIcon(imagepathA);
  ImageIcon imageB=new ImageIcon(imagepathB);
  
  Aw=imageA.getIconWidth();
  Ah=imageA.getIconHeight();
  Bw=imageB.getIconWidth();
  Bh=imageB.getIconHeight(); 
   
  arrayImageA=handlepixels(imageA.getImage(),0,0,Aw,Ah);
  arrayImageB=handlepixels(imageB.getImage(),0,0,Bw,Bh);
  if(arrayImageA!=null&&arrayImageB!=null){
   doSplice2(arrayImageA,arrayImageB);   
   Image image=createImage(splicePixel);
   saveImage(image,outputimage);
  }
  if(fw!=null){
   try{
    fw.close();
   }catch(Exception e){
    e.printStackTrace();
   }   
  }    
  
 }
 public Image createImage(int[] colors){
     JFrame. jf=new JFrame();
        Image modImg = jf.createImage(
              new MemoryImageSource(           
             Wmax,Hmax,colors,0,Wmax));
        return modImg;
    }
   
    public void saveImage(Image image,String filename){     
     java.awt.image.BufferedImage bi = new java.awt.image.BufferedImage(Wmax, Hmax, java.awt.image.BufferedImage.TYPE_INT_BGR);
        Graphics2D g2= (Graphics2D)bi.getGraphics();
        g2.drawImage(image,0,0,null);
       
        try{
         javax.imageio.ImageIO.write(bi, "JPEG", new java.io.File(filename));
        }catch(Exception e){
         e.printStackTrace();
        }       
    }
 /*
  *the method can splice two image(array) into one image(array)
  *the the range smaller than the the image size
  *@all parameter must not to be null!!!
  *
  **/

    public void doSplice2(int[] imageA,int[] imageB){
     //first of all,you should check whether the condition fill this method
     if(Aw>Bw){
      Wmax=Aw;          
     }else{
      Wmax=Bw;
     }
     
     rangeFrom=Wmax/4;  // you can set range here
     rangeTo=Wmax*3/4;   
     if(rangeFrom>Wmax)
        return;
     if(rangeFrom>=rangeTo)
        return;  
     if(Ah>Bh){
       Hmax=Ah;
     }else{
       Hmax=Bh; 
     }
     splicePixel=new int[Wmax*Hmax];
     int range=rangeTo-rangeFrom;
     float sp=((float)Hmax/(float)range);    //step 
    
      
      
     for(int i=0;i      
      float rownumber=sp*(rangeTo-i);
         float row=((float)Hmax)/rownumber;
            int start=(int)Math.round(Math.random()*row);
            float point=start;
      //System.out.print("\n"+row);
      for(int j=0;j       start=Math.round(point);
      // start=start+(int)Math.round((Math.random()-0.5)*row);
          if(start<0)
         start=0;       
                 
       if(i        if(j>=Bh||i>=Bw){
         splicePixel[j*Wmax+i]=0xffffffff;
         continue;
        }
           splicePixel[j*Wmax+i]=imageB[j*Bw+i]; 
         continue;
       }else if(i>=rangeTo){
        if(j>=Ah||i>=Aw){
          splicePixel[j*Wmax+i]=0xffffffff;
          continue;
         }
           splicePixel[j*Wmax+i]=imageA[j*Aw+i]; 
           continue; 
       }
      // this.writePixel2File((int)Math.round((Math.random()-0.5)*row));
       if(j==start){
        
         if(j>=Ah||i>=Aw){
          splicePixel[j*Wmax+i]=0xffffffff;
          continue;
         }       
            splicePixel[j*Wmax+i]=imageB[j*Bw+i];
            point=point+row;  
       }else{       
        if(j>=Bh||i>=Bw){
          splicePixel[j*Wmax+i]=0xffffffff;
          continue;
        }
        splicePixel[j*Wmax+i]=imageA[j*Aw+i];
       }    
      }
     }
   }
  
    public void writePixel2File(int color){
     index++;
     
     if(fw==null){
      try{
     fw =new FileWriter("pixel.txt");
     }catch(Exception e){
      e.printStackTrace();
     }
     }             
        try{
         if(index%100==0)
         fw.write("\n");
         
         fw.write("\t"+color);
        }catch(Exception e){
         e.printStackTrace();
        }
    }
 public int[] handlepixels(Image img, int x, int y, int w, int h) {
        int[] pixels = new int[w * h];               
        PixelGrabber pg = new PixelGrabber(img, x, y, w, h, pixels, 0, w);
        try {
            pg.grabPixels();
        } catch (InterruptedException e) {
            System.err.println("interrupted waiting for pixels!");
           
        }
        if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
            System.err.println("image fetch aborted or errored");
        }      
        return pixels;
    }
 public static void main(String[] args){
  Splice splice=new Splice();
 }
}


来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/12379366/viewspace-220439/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/12379366/viewspace-220439/

cuiluangou0298
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android编程实现图片背景渐变切换与图层叠加效果
08-31
主要介绍了Android编程实现图片背景渐变切换与图层叠加效果,涉及Android图形特效的相关操作技巧,具有一定参考借鉴价值,需要的朋友可以参考下
Java实现颜色渐变效果
08-26
主要为大家详细介绍了Java实现颜色渐变效果的方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java drawimage 缩放_java-如何缩放BufferedImage
weixin_29775479的博客
02-13 610
要缩放图像，您需要创建一个新图像并将其绘制。 一种方法是使用此处建议的scaleBilinear()的AffineTransformOp.filter()方法。 这使您可以选择插值技术。private static BufferedImage scale1(BufferedImage before, double scale) {int w = before.getWidth();int h = ...
JAVA图片处理工具类
纳川的博客
07-21 478
所需jar包 <dependency> <groupId>net.coobird</groupId> <artifactId>thumbnailator</artifactId> <version>0.4.8</version> </dependency> 工具类...
java awt生成签名图片消除锯齿化
weixin_41543212的博客
02-20 640
项目场景： 在一个线上互联网医院中，需要生成电子处方图片，图片里面会有医生的手写签名。通过java.awt的Graphics2D方式来生成处方图片，并将手写签名的图片导入其中。 问题描述： 但是在签名图片导入后，就可以看到明显的锯齿。 具体导入图片代码： g2.drawImage(getImage("https://xx.jpg", 100, 50), WIDTH - (LEVEL_PADDING + 9 * contentFontSize + contentFontSize / 2) + 5, heig
JAVA处理图片
hbwdasd的博客
04-07 4341
一、我们需要获取图片 public int[][] getImagePixArray(String path){ File file = new File (path); java.awt.image.BufferedImage buffimg = null; try { buffimg = ImageIO.read (file); } catch (IOException e) {
Java SWT Image 图像 —— 反色、拉伸、透明叠加
xmind
01-18 424
图像反色 对于彩色图像的 R、G、B 各彩色分量取反的技术就是图像的反色处理，这在处理二值化图像的连通区域选取的时候非常重要。如物体连通域用黑色表示，而二值化后的物体连通域图像可那是白色的，而背景是黑色的，这时应手动选取图像的反色处理或有程序根据背景和物体连通域两种颜色的数量所占比例而自动选择是否选择选取图像的反色处理，其算法很简单，假设源图像一像素的红,绿,蓝分量为 (R，G，B)，则目标图像...
js实现图片从左往右渐变切换效果的方法
10-24
主要介绍了js实现图片从左往右渐变切换效果的方法,是比较典型的图片渐变切换效果特效,非常具有实用价值,需要的朋友可以参考下
android中实现背景图片颜色渐变方法
01-20
常用，记录一下。 效果图： 首先新建xml文件 bg_gradient.xml 代码如下: <?xml version=”1.0″ encoding=”utf-8″?>  ”http://schemas.android.com/apk/res/android... android:endColor=”#99000000″
JAVA绘制图形方法
wang6xin6nian6的专栏
11-07 1461
怎样使用drawImage()方法绘制图形法： （1）Public abstract boolean drawImage(Image  img,int  x,int  y, ImageObserver  observer) 参数说明： Img          需要绘制的图像 X            图像顶点的x坐标 Y            图像顶点的Y坐标 Obser
java中 g.drawImage()方法如何使用
热门推荐
evilcry2012的专栏
02-09 2万+
java中 g.drawImage()方法如何使用 2013-04-08 09:04contact999 | 分类：JAVA相关 | 浏览1921次 File file=new File("d:\\img\\5.jpg"); BufferedImage bi=ImageIO.read(file); Graphics g=bi.getGraphics(); g.drawImage(i
Java学习之绘图
03-27 1万+
Java偏向于图形化界面编程，当然就有图像显示之类的东西，图形处理方面也是强项。 1、Graphics类 Graphics类是所有图形上下文的抽象基类，它允许应用程序在组件以及闭屏图像上进行绘制。Graphics类封装了Java支持的基本绘图操作所需的状态信息，主要包括颜色、字体、画笔、文本、图像等 Graphics类提供了绘图常用的方法，利用这些方法可以实现直线、矩形、多边形、椭圆...
java drawimage 模糊_Java实现图像高斯模糊特效
weixin_33473110的博客
12-26 484
说到Java实现的图像特效处理，肯定离不开Java Image Filters。它由Jhlabs开发并提供数十种图像处理特效，例如高斯模糊、反转色、水波纹、凹凸、黑白效果等。我截取了小部分的图像特效处理过滤器，实在太多，有兴趣的朋友可以逐一看看。源码下载一直没有找到Maven坐标，网上有一个，但是很多源码缺失不能用。因此只能把源码下载下来，官方网站就可以下载。下载下来目录如下，src里面是源码，d...
java 图像渐变_将图像渐变为透明渐变
weixin_30404433的博客
02-16 154
如果你想要这个：你可以这样做：div, img { position:absolute; top:0; left:0; width:250px; height:250px; }img {-webkit-mask-image:-webkit-gradient(linear, left top, left bottom, from(rgba(0,0,0,1)), to(rgba(0,0,0,0)));...
用java实现图片渐变叠加（3种方法）
ycb1689的专栏
11-14 3171
原理上是2种方法，但是可以用3种方法实现（没想到花了我那么多时间）：1.是根据alpha值计算，象素的各单色分量衰减后相加；2.是修改一张图片的透明度，然后用画到另一张图片上面；3.是象素点的插值，不涉及透明度的使用。做的时候先试的第3种方法的，花的时间最多，结果发现效果最烂，象素差别过大看起来就像麻子一样。代码里的渐变范围是图片的1/4到3/4.自己可以修改的^_^。 最简单的是第2种方法。第...
用java生成一个渐变色图片
最新发布
03-25
A：可以使用Java提供的渐变类 GradientPaint，以下是生成渐变色图片的示例代码： ```java import java.awt.Color; import java.awt.GradientPaint; import java.awt.Graphics2D; import java.awt.image....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值