像素与字节 数字图像处理
2015-07-24 10:13:00 weixin_33826609 阅读数 9

图像中的像素格效果是最常见的图像特效,可以隐藏或者模糊一些不想被显示出来的图像细

节,是常用的图像处理手段。

 

像素格效果的算法其实非常的简单,只是对图像进行块扫描,求出每个像素块的平均RGB

值,然后赋值到块中的每个像素点,最后输出处理以后的图像,而像素块的扫描有点类似

卷积的处理。具体算法步骤如下:

1.      按照从左到右,自上而下的顺序,扫描每个像素点。

2.      对扫描到的像素,计算出它属于的像素块,并且计算像素块的平均RGB值

3.      将RGB赋值给扫描到的像素点。

4.      循环上面2,3步骤,直到所有像素点都完成。

程序效果:



像素格滤镜源代码如下:

[java] view plaincopy
  1. package com.process.blur.study;  
  2. /** 
  3.  * @author gloomy fish 
  4.  * @date 2012-05-30 
  5.  *  
  6.  */  
  7. import java.awt.image.BufferedImage;  
  8.   
  9. public class PixellateFilter extends AbstractBufferedImageOp {  
  10.     private int size;  
  11.       
  12.     public PixellateFilter() {  
  13.         size = 10// default block size=10x10  
  14.     }  
  15.       
  16.     public PixellateFilter(int size) {  
  17.         this.size = size;  
  18.     }  
  19.   
  20.     @Override  
  21.     public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
  22.         int width = src.getWidth();  
  23.         int height = src.getHeight();  
  24.   
  25.         if ( dest == null )  
  26.             dest = createCompatibleDestImage( src, null );  
  27.   
  28.         int[] inPixels = new int[width*height];  
  29.         int[] outPixels = new int[width*height];  
  30.         getRGB( src, 00, width, height, inPixels );  
  31.         int index = 0;  
  32.           
  33.         int offsetX = 0, offsetY = 0;  
  34.         int newX = 0, newY = 0;  
  35.         double total = size*size;  
  36.         double sumred = 0, sumgreen = 0, sumblue = 0;  
  37.         for(int row=0; row<height; row++) {  
  38.             int ta = 0, tr = 0, tg = 0, tb = 0;  
  39.             for(int col=0; col<width; col++) {  
  40.                 newY = (row/size) * size;  
  41.                 newX = (col/size) * size;  
  42.                 offsetX = newX + size;  
  43.                 offsetY = newY + size;  
  44.                 for(int subRow =newY; subRow < offsetY; subRow++) {  
  45.                     for(int subCol =newX; subCol < offsetX; subCol++) {  
  46.                         if(subRow <0 || subRow >= height) {  
  47.                             continue;  
  48.                         }  
  49.                         if(subCol < 0 || subCol >=width) {  
  50.                             continue;  
  51.                         }  
  52.                         index = subRow * width + subCol;  
  53.                         ta = (inPixels[index] >> 24) & 0xff;  
  54.                         sumred += (inPixels[index] >> 16) & 0xff;  
  55.                         sumgreen += (inPixels[index] >> 8) & 0xff;  
  56.                         sumblue += inPixels[index] & 0xff;  
  57.                     }  
  58.                 }  
  59.                 index = row * width + col;  
  60.                 tr = (int)(sumred/total);  
  61.                 tg = (int)(sumgreen/total);  
  62.                 tb = (int)(sumblue/total);  
  63.                 outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
  64.   
  65.                 sumred = sumgreen = sumblue = 0// reset them...  
  66.             }  
  67.         }  
  68.   
  69.         setRGB( dest, 00, width, height, outPixels );  
  70.         return dest;  
  71.     }  
  72.   
  73. }  
2019-05-01 22:36:33 tyfwin 阅读数 57

发现博客和书上的都是一样的文字,只看书理解有点费时间,自己看视频理解的,稍微整理一下自己的理解。

相邻像素:

4邻域: 像素p(x,y)的4邻域是: (x+1,y);(x-1,y);(x,y+1);(x,y-1) 。

                  用N4(p)表示像素p的4邻域。

 

D邻域:像素p(x,y)的D邻域是: 对角上的点 (x+1,y+1);(x+1,y-1);(x- 1,y+1);(x-1,y-1) 。

               用ND(p)表示像素p的D邻域。

 

8邻域:像素p(x,y)的8邻域是: 4邻域的点 + D邻域的点 。  

             用N8(p)表示像素p的8邻域。 N8(p) = N4(p) + ND(p)

邻接性:

邻接性有两个要素:

1、灰度值的相等或者在一个灰度集合中(值域V

2、空间位置的邻接性(邻域)。

三种邻接性:

    ◆  4邻接:如果点q在N4(P)中(即p、q是4邻域的),且数值在V中q和p是4邻接的;

    ◆  8邻接:p、q是8邻域的,且数值在V中

    ◆  m邻接(混合邻接):满足下列条件的任一个,且数值在V中

       (i)q在中N4(P)

       (ii)q在ND(P)中,且集合N4(P)∩N4(Q)中没有V值的像素。

m邻接本质:像素间同时存在4邻接和8邻接时候,优先采用4邻接,屏蔽8邻接。

例如下图中,(b)中两个灰色的1满足m邻接。(c)中两个灰色的1不满足m邻接。

 

连通性:

书上概念:从坐标(x,y)的像素p到坐标为(s,t)的像素q的通路,是由一系列的特定像素组成的序列,其坐标为:
(x0,y0), (x1,y1), …, (xn,yn)
其中(x0,y0) = (x,y), (xn,yn) = (s,t)。 并且像素(xi,yi)和(xi-1,yi-1)对于1≤i≤n是邻接的(4邻接,8邻接,m邻接)。在这种情况下,n是通路的长度。从像素p到像素q就形成了一个像素通路。

感觉看下面这个截图就够了。

 

像素之间距离:

定义:对于像素p、q、z,分别具有坐标(x,y), (s,t)和(u,v),如果

(1) D(p,q)    ≥ 0   ( D(p,q)=0,当且仅 当p =q),

(2) D(p,q)  =  D(q,p)

(3) D(p,z) ≤ D(p,q) + D(q,z)

则称D是距离函数或度量。

欧式距离:

D4距离(城市距离):

像素p(x,y)和q(s,t)之间的D4距 离定义为: D4(p,q) = |x – s| + |y – t|

例如,与点(x,y)(中心点)D4距离小于等于2的像素,形成右边 固定距离的轮廓。

 

D8距离(棋盘距离):

q(s,t)之间的D8距离定义为: D8(p,q) = max(|x – s|  ,|y – t|)

 

 

 

 

 

 

2012-05-31 06:13:40 jia20003 阅读数 5226

图像处理之像素格效果


图像中的像素格效果是最常见的图像特效,可以隐藏或者模糊一些不想被显示出来的图像细

节,是常用的图像处理手段。

 

像素格效果的算法其实非常的简单,只是对图像进行块扫描,求出每个像素块的平均RGB

值,然后赋值到块中的每个像素点,最后输出处理以后的图像,而像素块的扫描有点类似

卷积的处理。具体算法步骤如下:

1.      按照从左到右,自上而下的顺序,扫描每个像素点。

2.      对扫描到的像素,计算出它属于的像素块,并且计算像素块的平均RGB值

3.      将RGB赋值给扫描到的像素点。

4.      循环上面2,3步骤,直到所有像素点都完成。

程序效果:


http://my.csdn.net/my/album/detail/1166674

像素格滤镜源代码如下:

package com.process.blur.study;
/**
 * @author gloomy fish
 * @date 2012-05-30
 * 
 */
import java.awt.image.BufferedImage;

public class PixellateFilter extends AbstractBufferedImageOp {
	private int size;
	
	public PixellateFilter() {
		size = 10; // default block size=10x10
	}
	
	public PixellateFilter(int size) {
		this.size = size;
	}

	@Override
	public BufferedImage filter(BufferedImage src, BufferedImage dest) {
		int width = src.getWidth();
        int height = src.getHeight();

        if ( dest == null )
            dest = createCompatibleDestImage( src, null );

        int[] inPixels = new int[width*height];
        int[] outPixels = new int[width*height];
        getRGB( src, 0, 0, width, height, inPixels );
        int index = 0;
        
        int offsetX = 0, offsetY = 0;
        int newX = 0, newY = 0;
        double total = size*size;
        double sumred = 0, sumgreen = 0, sumblue = 0;
        for(int row=0; row<height; row++) {
        	int ta = 0, tr = 0, tg = 0, tb = 0;
        	for(int col=0; col<width; col++) {
        		newY = (row/size) * size;
        		newX = (col/size) * size;
        		offsetX = newX + size;
        		offsetY = newY + size;
        		for(int subRow =newY; subRow < offsetY; subRow++) {
        			for(int subCol =newX; subCol < offsetX; subCol++) {
        				if(subRow <0 || subRow >= height) {
        					continue;
        				}
        				if(subCol < 0 || subCol >=width) {
        					continue;
        				}
        				index = subRow * width + subCol;
                		ta = (inPixels[index] >> 24) & 0xff;
                		sumred += (inPixels[index] >> 16) & 0xff;
                		sumgreen += (inPixels[index] >> 8) & 0xff;
                		sumblue += inPixels[index] & 0xff;
        			}
        		}
        		index = row * width + col;
        		tr = (int)(sumred/total);
        		tg = (int)(sumgreen/total);
        		tb = (int)(sumblue/total);
        		outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;

        		sumred = sumgreen = sumblue = 0; // reset them...
        	}
        }

        setRGB( dest, 0, 0, width, height, outPixels );
        return dest;
	}

}
转载时请注明出自本博客

2012-05-31 06:13:00 iteye_3606 阅读数 20

图像处理之像素格效果


图像中的像素格效果是最常见的图像特效,可以隐藏或者模糊一些不想被显示出来的图像细

节,是常用的图像处理手段。

像素格效果的算法其实非常的简单,只是对图像进行块扫描,求出每个像素块的平均RGB

值,然后赋值到块中的每个像素点,最后输出处理以后的图像,而像素块的扫描有点类似

卷积的处理。具体算法步骤如下:

1.按照从左到右,自上而下的顺序,扫描每个像素点。

2.对扫描到的像素,计算出它属于的像素块,并且计算像素块的平均RGB值

3.将RGB赋值给扫描到的像素点。

4.循环上面2,3步骤,直到所有像素点都完成。

程序效果:


http://my.csdn.net/my/album/detail/1166674

像素格滤镜源代码如下:

package com.process.blur.study;
/**
 * @author gloomy fish
 * @date 2012-05-30
 * 
 */
import java.awt.image.BufferedImage;

public class PixellateFilter extends AbstractBufferedImageOp {
	private int size;
	
	public PixellateFilter() {
		size = 10; // default block size=10x10
	}
	
	public PixellateFilter(int size) {
		this.size = size;
	}

	@Override
	public BufferedImage filter(BufferedImage src, BufferedImage dest) {
		int width = src.getWidth();
        int height = src.getHeight();

        if ( dest == null )
            dest = createCompatibleDestImage( src, null );

        int[] inPixels = new int[width*height];
        int[] outPixels = new int[width*height];
        getRGB( src, 0, 0, width, height, inPixels );
        int index = 0;
        
        int offsetX = 0, offsetY = 0;
        int newX = 0, newY = 0;
        double total = size*size;
        double sumred = 0, sumgreen = 0, sumblue = 0;
        for(int row=0; row<height; row++) {
        	int ta = 0, tr = 0, tg = 0, tb = 0;
        	for(int col=0; col<width; col++) {
        		newY = (row/size) * size;
        		newX = (col/size) * size;
        		offsetX = newX + size;
        		offsetY = newY + size;
        		for(int subRow =newY; subRow < offsetY; subRow++) {
        			for(int subCol =newX; subCol < offsetX; subCol++) {
        				if(subRow <0 || subRow >= height) {
        					continue;
        				}
        				if(subCol < 0 || subCol >=width) {
        					continue;
        				}
        				index = subRow * width + subCol;
                		ta = (inPixels[index] >> 24) & 0xff;
                		sumred += (inPixels[index] >> 16) & 0xff;
                		sumgreen += (inPixels[index] >> 8) & 0xff;
                		sumblue += inPixels[index] & 0xff;
        			}
        		}
        		index = row * width + col;
        		tr = (int)(sumred/total);
        		tg = (int)(sumgreen/total);
        		tb = (int)(sumblue/total);
        		outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;

        		sumred = sumgreen = sumblue = 0; // reset them...
        	}
        }

        setRGB( dest, 0, 0, width, height, outPixels );
        return dest;
	}

}
转载时请注明出自本博客

2017-07-12 15:46:12 u011600592 阅读数 194

- created by gloomyfish


图像中的像素格效果是最常见的图像特效,可以隐藏或者模糊一些不想被显示出来的图像细

节,是常用的图像处理手段。

 

像素格效果的算法其实非常的简单,只是对图像进行块扫描,求出每个像素块的平均RGB

值,然后赋值到块中的每个像素点,最后输出处理以后的图像,而像素块的扫描有点类似

卷积的处理。具体算法步骤如下:

1.      按照从左到右,自上而下的顺序,扫描每个像素点。

2.      对扫描到的像素,计算出它属于的像素块,并且计算像素块的平均RGB值

3.      将RGB赋值给扫描到的像素点。

4.      循环上面2,3步骤,直到所有像素点都完成。

程序效果:


http://my.csdn.net/my/album/detail/1166674

package com.process.blur.study;  
/** 
 * @author gloomy fish 
 * @date 2012-05-30 
 *  
 */  
import java.awt.image.BufferedImage;  
  
public class PixellateFilter extends AbstractBufferedImageOp {  
    private int size;  
      
    public PixellateFilter() {  
        size = 10; // default block size=10x10  
    }  
      
    public PixellateFilter(int size) {  
        this.size = size;  
    }  
  
    @Override  
    public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
        int width = src.getWidth();  
        int height = src.getHeight();  
  
        if ( dest == null )  
            dest = createCompatibleDestImage( src, null );  
  
        int[] inPixels = new int[width*height];  
        int[] outPixels = new int[width*height];  
        getRGB( src, 0, 0, width, height, inPixels );  
        int index = 0;  
          
        int offsetX = 0, offsetY = 0;  
        int newX = 0, newY = 0;  
        double total = size*size;  
        double sumred = 0, sumgreen = 0, sumblue = 0;  
        for(int row=0; row<height; row++) {  
            int ta = 0, tr = 0, tg = 0, tb = 0;  
            for(int col=0; col<width; col++) {  
                newY = (row/size) * size;  
                newX = (col/size) * size;  
                offsetX = newX + size;  
                offsetY = newY + size;  
                for(int subRow =newY; subRow < offsetY; subRow++) {  
                    for(int subCol =newX; subCol < offsetX; subCol++) {  
                        if(subRow <0 || subRow >= height) {  
                            continue;  
                        }  
                        if(subCol < 0 || subCol >=width) {  
                            continue;  
                        }  
                        index = subRow * width + subCol;  
                        ta = (inPixels[index] >> 24) & 0xff;  
                        sumred += (inPixels[index] >> 16) & 0xff;  
                        sumgreen += (inPixels[index] >> 8) & 0xff;  
                        sumblue += inPixels[index] & 0xff;  
                    }  
                }  
                index = row * width + col;  
                tr = (int)(sumred/total);  
                tg = (int)(sumgreen/total);  
                tb = (int)(sumblue/total);  
                outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
  
                sumred = sumgreen = sumblue = 0; // reset them...  
            }  
        }  
  
        setRGB( dest, 0, 0, width, height, outPixels );  
        return dest;  
    }  
  
}  


没有更多推荐了,返回首页