GLSL/C++ 实现滤镜效果

入门效果之浮雕

"浮雕"图象效果是指图像的前景前向凸出背景。常见于一些纪念碑的雕刻上，要实现浮雕其实非常简单。我们把图象的一个象素和左上方的象素进行求差运算，并加上一个灰度。这个灰度就是表示背景颜色。这里我们设置这个插值为128 (图象RGB的值是0-255)。同时,我们还应该把这两个颜色的差值转换为亮度信息.否则浮雕图像会出现彩色。

[cpp] view plaincopy

1.    "precision mediump float;      \n"  
2. "varying vec2 v_texCoord;      \n"  
3. "uniform sampler2D s_baseMap;     \n"  
4. "uniform vec2 TexSize;            \n"  
5. "void main()                 \n"  
6. "{                             \n"  
7. "   vec2 tex =v_texCoord;   \n"  
8. "   vec2 upLeftUV = vec2(tex.x-1.0/TexSize.x,tex.y-1.0/TexSize.y);           \n"  
9. "   vec4 curColor = texture2D(s_baseMap,v_texCoord);                           \n"  
10. "   vec4 upLeftColor = texture2D(s_baseMap,upLeftUV);                  \n"  
11. "   vec4 delColor = curColor - upLeftColor;                           \n"  
12. "   float h = 0.3*delColor.x + 0.59*delColor.y + 0.11*delColor.z;                  \n"  
13. "   vec4 bkColor = vec4(0.5, 0.5, 0.5, 1.0);                   \n"  
14. "   gl_FragColor = vec4(h,h,h,0.0) +bkColor;                             \n"  
15. "}                           \n";  

C++版

[cpp] view plaincopy

1. void relief(int x,int y,BYTE *pre,BYTE *now,int Stride,int index){  
2.     int upperleft;  
3.     upperleft=(y-1)*Stride+4*(x-1);  
4.     Vec4 Pixel,NowPixel;  
5.     NowPixel.SetPixel(pre,index);  
6.     Pixel.SetPixel(pre,upperleft);  
7.     Pixel=NowPixel-Pixel;  
8.     BeGray(Pixel);  
9.     Pixel.GetPixelToNow(now,index);  
10. }  

   

入门效果之马赛克

接下来我们完成一个更加常见的效果—马赛克.图片的马赛克就是把图片的一个相当大小的区域用同一个点的颜色来表示.可以认为是大规模的降低图像的分辨率,而让图像的一些细节隐藏起来, 比如电视中要秀一下某个罪犯的身材,却又不能展示他的脸,这个时候我们就可以给他的脸加一个马赛克.

用HLSL代码实现马赛克是非常简单的,但是同样的,我们需要一些额外的步骤,第一步就是先把纹理坐标转换成图像实际大小的整数坐标.接下来,我们要把图像这个坐标量化---比如马赛克块的大小是8x8象素。那么我们可以用下列方法来得到马赛克后的图像采样值，假设[x.y]为图像的整数坐标：

[x,y]mosaic = [ int(x/8)*8 , int(y/8)*8].

[cpp] view plaincopy

1.    "precision mediump float;    \n"  
2. "varying vec2 v_texCoord;    \n"  
3. "uniform sampler2D s_baseMap;\n"  
4. "uniform vec2 TexSize;       \n"  
5. "vec2 mosaicSize = vec2(8,8);\n"  
6. "void main()                 \n"  
7. "{                           \n"  
8. "   vec2 intXY = vec2(v_texCoord.x*TexSize.x, v_texCoord.y*TexSize.y);   \n"  
9. "   vec2 XYMosaic = vec2(floor(intXY.x/mosaicSize.x)*mosaicSize.x,floor(intXY.y/mosaicSize.y)*mosaicSize.y);  \n"  
10. "   vec2 UVMosaic = vec2(XYMosaic.x/TexSize.x,XYMosaic.y/TexSize.y);     \n"  
11. "   vec4 baseMap = texture2D(s_baseMap,UVMosaic);                        \n"  
12. "   gl_FragColor = baseMap;                                              \n"  
13. "}                                                                       \n";  

C++ 版

[cpp] view plaincopy

1. void Mosaic(int x,int y,BYTE *pre,BYTE *now,int Stride,int index){  
2.     Vec4 Pixel,Pixel_UpperLeft;  
3.     Pixel.SetPixel(pre,index);  
4.     if (x%8==0&&y%8==0)  
5.     {  
6.         Pixel.GetPixelToNow(now,index);  
7.     }   
8.     else  
9.     {  
10.         int tmpX,tmpY;  
11.         tmpX=x/8*8;  
12.         tmpY=y/8*8;  
13.         int index_UpperLeft;  
14.         index_UpperLeft=tmpY*Stride+4*(tmpX);  
15.         Pixel_UpperLeft.SetPixel(pre,index_UpperLeft);  
16.         Pixel_UpperLeft.GetPixelToNow(now,index);  
17.     }  
18. }  

读者可能会发现这个马赛克太普通了，确实它不够新颖，下面我们来改良一下，我们希望达到这样一个效果：马赛克区域不是方的，而是圆的，圆形区域以外，我们用图像原来的颜色覆盖。这样我们需要改变一下代码。

首先求出原来马赛克区域的正中心（原来是左上角）：然后计算图像采样点到这个中心的距离，如果在马赛克圆内，就用区域的中心颜色，否则就用原来的颜色。改良后的代码如下，这里我们把马赛克区域大小调节成16x16。这样效果更明显。

[cpp] view plaincopy

1.    "precision highp float;            \n"  
2. "varying vec2 v_texCoord;            \n"  
3. "uniform sampler2D s_baseMap;        \n"  
4. "uniform vec2 TexSize;               \n"  
5. "vec2 mosaicSize = vec2(8,8);      \n"  
6. "void main()                         \n"  
7. "{                                   \n"  
8. "   vec2 intXY = vec2(v_texCoord.x*TexSize.x, v_texCoord.y*TexSize.y);    \n"  
9. "   vec2 XYMosaic = vec2(floor(intXY.x/mosaicSize.x)*mosaicSize.x,floor(intXY.y/mosaicSize.y)*mosaicSize.y) + 0.5*mosaicSize; \n"  
10. "   vec2 delXY = XYMosaic - intXY;   \n"  
11. "   float delL = length(delXY);      \n"  
12. "   vec2 UVMosaic = vec2(XYMosaic.x/TexSize.x,XYMosaic.y/TexSize.y); \n"  
13. "   vec4 _finalColor;                \n"  
14. "   if(delL< 0.5*mosaicSize.x)       \n"  
15. "       _finalColor = texture2D(s_baseMap,UVMosaic);  \n"  
16. "   else                             \n"  
17. "       _finalColor = texture2D(s_baseMap,v_texCoord);  \n"  
18. "   gl_FragColor = _finalColor;      \n"  
19. "}                                   \n"  ;  

C++版

[cpp] view plaincopy

1. void Mosaic_Point(int x,int y,BYTE *pre,BYTE *now,int Stride,int index){  
2.     Vec4 Pixel,Pixel_UpperLeft;  
3.     Pixel.SetPixel(pre,index);  
4.     int i,j;  
5.     i=x%8;  
6.     j=y%8;  
7.     double dist=sqrt(double((4-i)*(4-i)+(4-j)*(4-j)));  
8.     if (dist>4)  
9.     {  
10.         Pixel.GetPixelToNow(now,index);  
11.     }   
12.     else  
13.     {  
14.         int tmpX,tmpY;  
15.         tmpX=x/8*8;  
16.         tmpY=y/8*8;  
17.         int index_UpperLeft;  
18.         index_UpperLeft=tmpY*Stride+4*(tmpX);  
19.         Pixel_UpperLeft.SetPixel(pre,index_UpperLeft);  
20.         Pixel_UpperLeft.GetPixelToNow(now,index);  
21.     }  
22. }  

图:  改良后的马赛克效果

l  进阶效果之锐化模糊

以上两个效果相对比较简单，姑且称之为入门效果， 它并没有用到太多数字图像处理或者信号处理方面的知识。接下来我们要介绍稍微复杂一点的效果，第一个就是图像的模糊和锐化。

图像的模糊又成为图像的平滑(smoothing)，我们知道人眼对高频成分是非常敏感的，如果在一个亮度连续变化的图像中，突然出现一个亮点，那么我们很容易察觉出来，类似的，如果图像有个突然的跳跃—明显的边缘，我们也是很容易察觉出来的。这些突然变化的分量就是图像的高频成分。人眼通常是通过低频成分来辨别轮廓，通过高频成分来感知细节的（这也是为什么照片分辨率低的时候，人们只能辨认出照片的大概轮廓，而看不到细节）。但是这些高频成分通常也包含了噪声成分。图像的平滑处理就是滤除图像的高频成分。

那么如何才能滤除图像的高频成分呢？我们先来介绍一下图像数字滤波器的概念。

简单通俗的来说，图像的数字滤波器其实就是一个n x n的数组（数组中的元素成为滤波器的系数或者滤波器的权重，n称为滤波器的阶）。对图像做滤波的时候，把某个像素为中心的nxn个像素的值和这个滤波器做卷积运算（也就是对应位置上的像素和对应位置上的权重的乘积累加起来），公式如下

 其中x , y 为当前正在处理的像素坐标。

通常情况下，我们滤波器的阶数为3已经足够了，用于模糊处理的3x3滤波器如下

                                _。

经过这样的滤波器，其实就是等效于把一个像素和周围8个像素一起求平均值，这是非常合理的---等于把一个像素和周围几个像素搅拌在一起—自然就模糊了。

[cpp] view plaincopy

1. "precision mediump float;                              \n"  
2.     "vec4 dip_filter(mat3 _filter, sampler2D _image, vec2 _xy, vec2 texSize)               \n"  
3.     "{                                                                                    \n"  
4.     "   mat3 _filter_pos_delta_x=mat3(vec3(-1.0, 0.0, 1.0), vec3(0.0, 0.0 ,1.0) ,vec3(1.0,0.0,1.0));            \n"  
5.     "   mat3 _filter_pos_delta_y=mat3(vec3(-1.0,-1.0,-1.0),vec3(-1.0,0.0,0.0),vec3(-1.0,1.0,1.0));              \n"  
6.     "   vec4 final_color = vec4(0.0, 0.0, 0.0, 0.0);                                      \n"  
7.     "   for(int i = 0; i<3; i++)                                                          \n"  
8.     "   {                                                                                 \n"  
9.     "       for(int j = 0; j<3; j++)                                                      \n"  
10.     "       {                                                                             \n"  
11.     "           vec2 _xy_new = vec2(_xy.x + _filter_pos_delta_x[i][j], _xy.y + _filter_pos_delta_y[i][j]); \n"  
12.     "           vec2 _uv_new = vec2(_xy_new.x/texSize.x, _xy_new.y/texSize.y);            \n"  
13.     "           final_color += texture2D(_image,_uv_new) * _filter[i][j];                 \n"  
14.     "       }                                                                             \n"  
15.     "   }                                                                                 \n"  
16.     "   return final_color;                                                               \n"  
17.     "}                                                                                    \n"  
18.     "varying vec2 v_texCoord;                                                             \n"  
19.     "uniform vec2 TexSize;                                                                \n"  
20.     "uniform sampler2D s_baseMap;                                                         \n"  
21.     "void main()                                                                          \n"  
22.     "{                                                                                    \n"  
23.     "   vec2 intXY = vec2(v_texCoord.x * TexSize.x, v_texCoord.y * TexSize.y);            \n"  
24.     "   mat3 _smooth_fil = mat3(1.0/9.0,1.0/9.0,1.0/9.0,                                          \n"  
25.     "                           1.0/9.0,1.0/9.0,1.0/9.0,                                          \n"  
26.     "                           1.0/9.0,1.0/9.0,1.0/9.0);                                         \n"  
27.     "   vec4 tmp = dip_filter(_smooth_fil, s_baseMap, intXY, TexSize);"  
28.     "   gl_FragColor = tmp;                                                               \n"  
29.     "}                                                                                    \n";  

C++版

[cpp] view plaincopy

1. void dip_filter(int x,int y,BYTE *pre,BYTE *now,int Stride,int index)  
2. {  
3.     int dir_x[3][3]={-1,0,1,-1,0,1,-1,0,1};  
4.     int dir_y[3][3]={1,1,1,0,0,0,-1,-1,-1};  
5.     int tmpX,tmpY;  
6.     Vec4 Pixel,PrePixel;  
7.     double num=sqrt(2.0);  
8.     double filter[3][3]={-1,0,1,  
9.                             -num,0,num,  
10.                             -1,0,1};  
11.     Pixel.Clear();  
12.     for (int i=0;i<3;i++)  
13.     {  
14.         for (int j=0;j<3;j++)  
15.         {  
16.             tmpX=x+dir_x[i][j];  
17.             tmpY=y+dir_y[i][j];  
18.             int tmp=tmpY*Stride+4*(tmpX);  
19.             PrePixel.SetPixel(pre,tmp);  
20.             Pixel+=PrePixel*filter[i][j];  
21.         }  
22.     }  
23.     BeGray(Pixel);  
24.     Pixel.GetPixelToNow(now,index);  
25. }  

以上的模糊滤波器称为BOX滤波器，是最简单的滤波器，如果考虑到离开中心像素的距离对滤波器系数的影响，我们通常采用更加合理的滤波器---高斯滤波器—一种通过2维高斯采样得到的滤波器，它的模板如下：

很容易看出来，离开中心越远的像素，权重系数越小。

对于锐化操作，常用的锐化模板是拉普拉斯(Laplacian)模板，这个模板定义如下：

容易看出拉普拉斯模板的作法：先将自身与周围的8个象素相减，表示自身与周围象素的差别；再将这个差别加上自身作为新象素的灰度。可见，如果一片暗区出现了一个亮点，那么锐化处理的结果是这个亮点变得更亮，这就增强了图像的细节。

下面三副图分别表示了经过BOX滤波。高斯滤波和拉普拉斯滤波后的图像

  

BOX 模糊                  高斯模糊                    拉普拉斯锐化

高斯模糊和拉普拉斯锐化效果的GLSL和BOX的代码基本一致，就是filter的系数不同，这里不在列出。

通过这个两个效果，我们介绍了图像的滤波操作，这样的操作，也成为模板操作，它实现了一种邻域运算(Neighborhood Operation)，即某个象素点的结果灰度不仅和该象素灰度有关，而且和其邻域点的值有关。模板运算在图象处理中经常要用到，可以看出，它是一项非常耗时的运算。有一种优化的方法称为可分离式滤波，就是使用两个pass来进行x/y方向分别滤波，能让运算次数大大减少。而且滤波器阶数越高，优势越明显。

数字图像滤波的时候，同样还需要注意边界像素的问题，不过幸好，GLSL能让边界处理更加的透明和简单。

l  进阶效果之描边效果

相对浮雕效果来说，描边（边缘检测）的代码并不复杂多少，只是在理论上相对来说稍微复杂一点，而且效果看上去更加的讨人喜欢一些。

我们知道 ，如果在图像的边缘处，灰度值肯定经过一个跳跃，我们可以计算出这个跳跃，并对这个值进行一些处理，来得到边缘浓黑的描边效果。

首先我们可以考虑对这个象素的左右两个象素进行差值，得到一个差量，这个差量越大，表示图像越处于边缘，而且这个边缘应该左右方向的，同样我们能得到上下方向和两个对角线上的图像边缘。这样我们构造一个滤波器

经过这个滤波器后，我们得到的是图像在这个象素处的变化差值，我们把它转化成灰度值，并求绝对值（差值可能为负），然后我们定义差值的绝对值越大的地方越黑（边缘显然是黑的），否则越白，我们便得到如下的效果：

图：铅笔描边效果

该效果的代码如下（其中dip_filter函数代码同上）：

[cpp] view plaincopy

1. "precision mediump float;                              \n"  
2. "vec4 dip_filter(mat3 _filter, sampler2D _image, vec2 _xy, vec2 texSize)               \n"  
3. "{                                                                                    \n"  
4. "   mat3 _filter_pos_delta_x=mat3(vec3(-1.0, 0.0, 1.0), vec3(0.0, 0.0 ,1.0) ,vec3(1.0,0.0,1.0));            \n"  
5. "   mat3 _filter_pos_delta_y=mat3(vec3(-1.0,-1.0,-1.0),vec3(-1.0,0.0,0.0),vec3(-1.0,1.0,1.0));              \n"  
6. "   vec4 final_color = vec4(0.0, 0.0, 0.0, 0.0);                                      \n"  
7. "   for(int i = 0; i<3; i++)                                                          \n"  
8. "   {                                                                                 \n"  
9. "       for(int j = 0; j<3; j++)                                                      \n"  
10. "       {                                                                             \n"  
11. "           vec2 _xy_new = vec2(_xy.x + _filter_pos_delta_x[i][j], _xy.y + _filter_pos_delta_y[i][j]); \n"  
12. "           vec2 _uv_new = vec2(_xy_new.x/texSize.x, _xy_new.y/texSize.y);            \n"  
13. "           final_color += texture2D(_image,_uv_new) * _filter[i][j];                 \n"  
14. "       }                                                                             \n"  
15. "   }                                                                                 \n"  
16. "   return final_color;                                                               \n"  
17. "}                                                                                    \n"  
18. "varying vec2 v_texCoord;                                                             \n"  
19. "uniform vec2 TexSize;                                                                \n"  
20. "uniform sampler2D s_baseMap;                                                         \n"  
21. "void main()                                                                          \n"  
22. "{                                                                                    \n"  
23. "   vec2 intXY = vec2(v_texCoord.x * TexSize.x, v_texCoord.y * TexSize.y);            \n"  
24. "   mat3 _smooth_fil = mat3(-0.5,-1.0,0.0,                                        \n"  
25. "                           -1.0,0.0,1.0,                                         \n"  
26. "                            0.0,1.0,0.5);                                        \n"  
27. "   vec4 delColor = dip_filter(_smooth_fil, s_baseMap, intXY, TexSize);           \n"  
28. "   float deltaGray = 0.3*delColor.x + 0.59*delColor.y + 0.11*delColor.z;          \n"  
29. "   if(deltaGray < 0.0) deltaGray = -1.0 * deltaGray;                             \n"  
30. "   deltaGray = 1.0 - deltaGray;                                                  \n"  
31. "   gl_FragColor = vec4(deltaGray,deltaGray,deltaGray,1.0);                        \n"  
32. "}                                                                                    \n";  

C++版

[cpp] view plaincopy

1. void Gaussian_filter(int x,int y,BYTE *pre,BYTE *now,int Stride,int index)  
2. {  
3.     int dir_x[3][3]={-1,0,1,-1,0,1,-1,0,1};  
4.     int dir_y[3][3]={1,1,1,0,0,0,-1,-1,-1};  
5.     int tmpX,tmpY;  
6.     Vec4 Pixel,PrePixel;  
7.     double filter[3][3]={1.0/16,2.0/16,1.0/16,  
8.         2.0/16,4.0/16,2.0/16,  
9.         1.0/16,2.0/16,1.0/16};  
10.     Pixel.Clear();  
11.     for (int i=0;i<3;i++)  
12.     {  
13.         for (int j=0;j<3;j++)  
14.         {  
15.             tmpX=x+dir_x[i][j];  
16.             tmpY=y+dir_y[i][j];  
17.             int tmp=tmpY*Stride+4*(tmpX);  
18.             PrePixel.SetPixel(pre,tmp);  
19.             Pixel+=PrePixel*filter[i][j];  
20.         }  
21.     }  
22.     //BeGray(Pixel);  
23.     Pixel.GetPixelToNow(now,index);  
24. }  

上面演示的效果种用到的模板就是一种边缘检测器，在信号处理上是一种基于梯度的滤波器，又称边缘算子，梯度是有方向的，和边沿的方向总是正交(垂直)的，在上面的代码中，我们采用的就是一个梯度为45度方向模板，它可以检测出135度方向的边沿。

以上是简单的边缘检测算子，更加严格的，我们可以采样Sobel算子，Sobel 算子有两个，一个是检测水平边沿的 ，另一个是检测垂直平边沿的，同样，Sobel算子另一种形式是各向同性Sobel算子，也有两个，一个是检测水平边沿的，另一个是检测垂直边沿的。各向同性Sobel算子和普通Sobel算子相比，它的位置加权系数更为准确，在检测不同方向的边沿时梯度的幅度一致。读者可以自行尝试Sobel算子的效果，只要修改pencil_filter的值就可以了。

l  高级效果之伪 HDR/Blow

HDR和Blow在现在主流游戏中是非常时髦的效果。

所谓HDR就是高动态范围的意思，我们知道，在普通的显示器和位图里，每通道都是8-bit，也就是说RGB分量的范围都是0-255，这用来表示现实中的颜色显然是远远不够的，现实中的图像的动态范围远远大的多，那么如何在现有的显示设备里尽可能的保持更大的动态范围，而且让它能更符合人眼的习惯就成了图形学研究的一个热点。通常真正的HDR的做法都是采用浮点纹理，把渲染运算的过程中，我们使用16bit的动态范围来保存运算结果，然后我们对运算结果进行分析，求出这个图像的中间灰度值，然后对图像进行调整映射到LDR的设备中。但是这样的算法有两个非常耗资源的过程，其中一个是浮点纹理，另外一个就是求图像中间灰度（通常情况是把图像不停的渲染到RenderTarget，每渲染一次，图像大小缩小一半，直到缩小到1x1大，一个1024 x1024的图像需要渲染10次！）。因此虽然HDR的效果非常漂亮，但是目前还是只有为数不多的游戏采用了这样的算法，大部分都是采用的伪HDR+blow效果。

伪HDR效果通常是重新调整图像的亮度曲线，让亮的更亮，暗的更暗一些，而Blow效果则是图像的亮度扩散开来，产生很柔的效果。

在这里我们采用一个二次曲线来重新调整图像的亮度，这个曲线的方程是

   x [ (2-4k) x + 4k-1 ).

K的取值范围为0.5 – 2.0

经过这个公式调整以后，图像上亮的区域将更加的亮，并且整体亮度会提高。那么接下来，我们如何使图像的亮度扩散开来呢？一种可行的方法就是对场景图像做一次downsample。把它变成原来的1/4次大小，那样就等于亮度往外扩散了4x4个象素的区域。

[cpp] view plaincopy

1. "precision mediump float;     \n"  
2. "varying vec2 v_texCoord;     \n"  
3. "uniform sampler2D s_baseMap; \n"  
4. "uniform float k;                     \n"  
5. "vec4 xposure(vec4 _color, float gray, float ex)  \n"  
6. "{                            \n"  
7. "   float b = (4.0*ex - 1.0);     \n"  
8. "   float a = 1.0 - b;          \n"  
9. "   float f = gray*(a*gray + b); \n"  
10. "   return f*_color;          \n"  
11. "}                            \n"  
12. "void main()                  \n"  
13. "{                            \n"  
14. "   vec4 _dsColor = texture2D(s_baseMap, v_texCoord); \n"  
15. "   float _lum = 0.3*_dsColor.x + 0.59*_dsColor.y;    \n"  
16. "   vec4 _fColor = texture2D(s_baseMap, v_texCoord);  \n"  
17. "   gl_FragColor = xposure(_fColor, _lum, k);         \n"  
18. "}                                                    \n";  

C++版

[cpp] view plaincopy

1. void HDR(int x,int y,BYTE *pre,BYTE *now,int index,double k){  
2.     Vec4 Pixel;  
3.     double GrayPixel;  
4.     Pixel.SetPixel(pre,index);  
5.     GrayPixel=GetGray(Pixel)/255.0;  
6.     double b=(4*k-1.0);  
7.     double a=1-b;  
8.     double f=GrayPixel*(a*GrayPixel+b);  
9.     Pixel*=f;  
10.     OverFlow(Pixel);  
11.     Pixel.GetPixelToNow(now,index);  
12. }  

下面是原图像和经过处理后图像的对比：

  

原图                      k = 1.1                      k = 1.6

图：经过伪HDR+Blow处理过的图像和原图的对比

l  高级效果之水彩化

真正的水彩效果在shader中是比较难实现的，它需要进行中值滤波后累加等一些操作，还需要处理NPR中的笔触一类的概念。本文绕开这些概念，只从视觉效果上能尽量模拟出水彩的画的那种感觉来。

我们知道，水彩画一个最大的特点是水彩在纸上流动扩散后会和周围的颜色搅拌在一起，另外一个特点就是水彩通常会形成一个个的色块，过渡不像照片那样的平滑。针对这两个特点。我们可以设计这样的一个算法来模拟水彩画的效果。

我们可以采用噪声纹理的方式，既事先计算好一个nxn的随机数数组，作为纹理传递给Pixel shader，这样在Pixel Shader里我们就能获得随机数了。得到随机数后，我们将随机数映射成纹理坐标的偏移值，就能模拟出色彩的扩散了。典型的噪声纹理是这个样子的：

图：噪声纹理

接下来我们需要处理色块，我们对颜色的RGB值分别进行量化，把RGB分量由原来的8bit量化成比特数更低的值。这样颜色的过渡就会显得不那么的平滑，而是会呈现出一定的色块效果。

通过以上两步处理后，我们得到的图像依然有非常多的细节，尤其是第一步处理中产生的很多细节噪点，很自然的我们就想到通过平滑模糊的方式来过滤掉这些高频噪声成分。

算法设计好了，接下来看看我们如何在RenderMonkey里实现这个算法。

类似上一个效果，我们需要两个pass来完成这个算法，第一个pass叫flow pass，模拟颜色的流动和处理颜色的量化。第二个pass叫Gauss pass，也就是前面提到的高斯模糊算法。我们的重点在第一个pass。

在模拟扩散的pass中，我们同样需要一个RenderTarget，以把结果保存在其中以便后续处理，然后还需要一个噪声纹理来产生随机数。具体代码如下：

[cpp] view plaincopy

1. "precision mediump float;    \n"  
2. "varying vec2 v_texCoord;    \n"  
3. "uniform sampler2D s_baseMap;  \n"  
4. "uniform vec2 TexSize;       \n"  
5. "float _waterPower = 40.0;     \n"  
6. "float _quatLevel = 5.0;       \n"  
7. "vec4 quant(vec4 _cl, float n)  \n"  
8. "{                            \n"  
9. "   _cl.x = floor(_cl.x*255.0/n)*n/255.0;  \n"  
10. "   _cl.y = floor(_cl.y*255.0/n)*n/255.0;  \n"  
11. "   _cl.z = floor(_cl.z*255.0/n)*n/255.0;  \n"  
12. "   return _cl;                            \n"  
13. "}                                         \n"  
14. "void main()                               \n"  
15. "{                                         \n"  
16. "   vec4 noiseColor = _waterPower*texture2D(s_baseMap,v_texCoord);           \n"  
17. "   vec2 newUV =vec2 (v_texCoord.x + noiseColor.x/TexSize.x,v_texCoord.y + noiseColor.y/TexSize.y);  \n"  
18. "   vec4 _fColor = texture2D(s_baseMap,newUV);                 \n"  
19. "   gl_FragColor = quant(_fColor, 255.0/pow(2,_quatLevel));   \n"  
20. "}                                                \n";  

C++版

[cpp] view plaincopy

1. void WaterFilter(int x,int y,BYTE *pre,BYTE *now,int Stride,int index,double _quatLevel,double _waterPower,int width,int height){  
2.     Vec4 nowPixel,RoundPixel;  
3.     int indexRound;  
4.     double Level;  
5.     nowPixel.SetPixel(pre,index);  
6.     int rx=rand()%2,ry=rand()%2;  
7.     indexRound=(y+rx)*Stride+(x+ry)*4;  
8.     RoundPixel.SetPixel(pre,indexRound);  
9.     Level=255/pow(2,_quatLevel);  
10.     RoundPixel.r=floor(RoundPixel.r/Level)*Level;  
11.     RoundPixel.g=floor(RoundPixel.g/Level)*Level;  
12.     RoundPixel.b=floor(RoundPixel.b/Level)*Level;  
13.     OverFlow(RoundPixel);  
14.     RoundPixel.GetPixelToNow(now,index);  
15. }  

代码中的_quatLevel用来表示对图像的量化比特数，值越小，色块越明显，比较合理的取值范围是2-6。_waterPower则表示图像颜色扩散范围，取值范围在8－64之间的效果比较好。

下面是经过水彩画处理后的图像：

 

 图：水彩画效果。左图量化比特数为6比特，扩散范围为20象素。

                 右图量化比特数为5比特，扩散范围为40象素

最后贴个C++版用到的函数

[cpp] view plaincopy

1. struct Vec4{  
2.     double r,g,b,a;  
3.     Vec4 (){  
4.         this->r=0;  
5.         this->g=0;  
6.         this->b=0;  
7.         this->a=0;  
8.     }  
9.     Vec4(double r,double g,double b){  
10.         this->r=r;  
11.         this->g=g;  
12.         this->b=b;  
13.     }  
14.     Vec4 operator+(const double one) const{  
15.         return Vec4(r+one,g+one,b+one);  
16.     }  
17.     Vec4 operator+(const Vec4& rhs)const{  
18.         return Vec4(r+rhs.r,g+rhs.g,b+rhs.b);  
19.     }  
20.     Vec4& operator+=(const double one){  
21.         r+=one;  
22.         g+=one;  
23.         b+=one;  
24.         return *this;  
25.     }  
26.     Vec4& operator+=(const Vec4& rhs){  
27.         r+=rhs.r;  
28.         g+=rhs.g;  
29.         b+=rhs.b;  
30.         return *this;  
31.     }  
32.     Vec4 operator-(const double one) const{  
33.         return Vec4(r-one,g-one,b-one);  
34.     }  
35.     Vec4 operator-(const Vec4& rhs)const{  
36.         return Vec4(r-rhs.r,g-rhs.g,b-rhs.b);  
37.     }  
38.     Vec4& operator-=(const double one){  
39.         r-=one;  
40.         g-=one;  
41.         b-=one;  
42.         return *this;  
43.     }  
44.     Vec4 operator*(const double one) const{  
45.         return Vec4(r*one,g*one,b*one);  
46.     }  
47.     Vec4& operator*=(const double one){  
48.         r*=one;  
49.         g*=one;  
50.         b*=one;  
51.         return *this;  
52.     }  
53.     Vec4 operator/(const double one) const{  
54.         return Vec4(r/one,g/one,b/one);  
55.     }  
56.     Vec4& operator/=(const double one){  
57.         r/=one;  
58.         g/=one;  
59.         b/=one;  
60.         return *this;  
61.     }  
62.     void Clear(){  
63.         r=g=b=0;  
64.     }  
65.     void SetPixel(BYTE *pre,int index){  
66.         this->r=pre[index];  
67.         this->g=pre[index+1];  
68.         this->b=pre[index+2];  
69.         this->a=pre[index+3];  
70.     }  
71.     void SetPixel(double RGB){  
72.         this->r=RGB;  
73.         this->g=RGB;  
74.         this->b=RGB;  
75.     }  
76.     void SetPixel(double R,double G,double B){  
77.         this->r=R;  
78.         this->g=G;  
79.         this->b=B;  
80.     }  
81.     void GetPixelToNow(BYTE *now,int index){  
82.         now[index]=this->r;  
83.         now[index+1]=this->g;  
84.         now[index+2]=this->b;  
85.           
86.     }  
87. };  
88. void OverFlow(Vec4 &Pixel){  
89.     if (Pixel.r>255.0)  
90.     {  
91.         Pixel.r=255;  
92.     }  
93.     else if (Pixel.r<0.0)  
94.     {  
95.         Pixel.r=-Pixel.r;  
96.     }  
97.   
98.     if (Pixel.g>255.0)  
99.     {  
100.         Pixel.g=255;  
101.     }  
102.     else if (Pixel.g<0.0)  
103.     {  
104.         Pixel.g=-Pixel.g;  
105.     }  
106.   
107.     if (Pixel.b>255.0)  
108.     {  
109.         Pixel.b=255;  
110.     }  
111.     else if (Pixel.b<0.0)  
112.     {  
113.         Pixel.b=-Pixel.b;  
114.     }  
115. }  
116. void OverFlow(double &Pixel){  
117.     if (Pixel>255.0)  
118.     {  
119.         Pixel=255;  
120.     }  
121.     else if (Pixel<0.0)  
122.     {  
123.         Pixel=-Pixel;  
124.     }  
125. }  
126. void ToGray(Vec4 &Pixel){  
127.     double detaGray;  
128.     detaGray=Pixel.r*0.3+Pixel.g*0.59+Pixel.b*0.11;  
129.     Pixel.SetPixel(detaGray);  
130.     OverFlow(Pixel);  
131. }  
132. double GetGray(Vec4 Pixel){  
133.     double detaGray;  
134.     detaGray=Pixel.r*0.3+Pixel.g*0.59+Pixel.b*0.11;  
135.     OverFlow(detaGray);  
136.     return detaGray;  
137. }  
138. void BeGray(Vec4 &Pixel){  
139.     double detaGray;  
140.     detaGray=Pixel.r*0.3+Pixel.g*0.59+Pixel.b*0.11;  
141.       
142.     if (detaGray<0.0)  
143.     {  
144.         detaGray=-detaGray;  
145.     }  
146.     else if (detaGray>255.0)  
147.     {  
148.         detaGray=255;  
149.     }  
150.     detaGray=255-detaGray;  
151.     Pixel.SetPixel(detaGray);  
152. }  
153. void Solve(){  
154.     BYTE *pre = (BYTE*)m_srcImg.Scan0;  
155.     BYTE *now = (BYTE*)m_copySrcImg.Scan0;  
156.     //函数在这边调用即可。  
157.     int index=0,Stride=m_copySrcImg.Stride;  
158.     int width=m_pCopyImg->GetWidth();  
159.     int height=m_pCopyImg->GetHeight();  
160.     index=Stride+4;  
161.   
162.     for (int j=1;j<m_copySrcImg.Height-1;j++)  
163.     {  
164.         for (int i=1;i<m_copySrcImg.Width-1;i++)  
165.         {  
166.             //Gaussian_filter(i,j,pre,now,Stride,index);  
167.             //dip_filter(i,j,pre,now,Stride,index);  
168.             //relief(i,j,pre,now,Stride,index);  
169.             //Mosaic(i,j,pre,now,Stride,index);  
170.             //Mosaic_Point(i,j,pre,now,Stride,index);  
171.             //HDR(i,j,pre,now,index,1.1);  
172.             //WaterFilter(i,j,pre,now,Stride,index,10,40,width,height);      
173.             index+=4;  
174.         }  
175.         index+=8;  
176.     }  
177.     //调用函数。  
178. }