高斯模糊

- 理论 -

高斯分布函数可表示为一个一维的函数G(x)


或者一个二维的函数G(x,y)


在这些函数中， X和Y代表了相对于原始中心点（center tap）像素的偏移（pixel offsets）值。也就是说，他们距离中心多少像素。这里的center tap，通常翻译为“中心抽头”，它在电学中的概念是：在整个次级线圈的中心拉出的一段导线上，它相对于另外两边的抽头电压居中，而为0，两边的电压就是 一正一负。在这里，我们也可以做相似的理解。即，它表示，以某个像素为中心进行取样，假设它的坐标为（x,y），那么周围四个点的坐标就是(x-1,y) (x+1,y)(x,y-1)(x,y+1)。对于整个分布来说，我们也可以用一个平均参数来实施位移，从而取代center tap的作用。但这样的模糊不符合我们的要求，我们希望我们的分布是基于中心的。

函数中的σ，即“西格玛”。在统计学中，它常用来表示“标准差”。高斯模糊的标准差，表示模糊的延伸距离。它的缺省值一般设为1，你可以提高它，来获得更强的效果。

函数中的e是欧拉数（Euler's number），它的值一般取2.7。你可以到http://blog.sina.com.cn/s/blog_54ab9583010007u5.html看看精确到小数点后10000位的e。

这个函数的结果，就是以x（在一个方向上），或者(x,y)（在两个方向上），为中心的加权（weight）值，或者说该点在多大程度上影响模糊后的像素。

那么，它能获得什么样的结果呢？当σ 值取1时，我们可以得到：
G(0) = 0.3989422804
G(1) = G(-1) = 0.2419707245
G(2) = G(-2) = 0.0539909665
G(3) = G(-3) = 0.0044318484
......

这些结果有什么意义呢？
当x = 0时，表示这一点就是原始中心点（center tap）, 这个点需要保留0.39（39%）的颜色
当x = 1以及x = -1时, 即有一个像素的位移时, 这一点需要保留0.24的颜色值
当x = 2以及x = -2时, 即有两个像素的位移时, 这一点需要保留0.05的颜色值
......

我们可以进行任意次这样的计算。 采样越高，精度越高。

相信现在你已经大致了解高斯模糊的原理了。

- 实际应用 -

当然，理论只是基于理想环境下的计算。在一次Bloom shader的测试中，我发现了两个问题：

1、模糊后的画面，其发光度和亮度大都比原始图像要低，画面显得很暗
2、上述的采样点（tap）的标准差是随意的吗？或者说，它有什么要求（或限制）？

以下各段，我将以一维高斯分布为例

首先解决明度问题。假设你有一个全白的单通道采样贴图，那么它所有的像素值都为1。经过第一次（水平方向）的高斯模糊运算之后，每个像素的值的总和，是所有高斯采样的加权总合。对于一个5 × 5的分布，标准差为1时，有：

ΣHBlur = G(0) + G(-1) + G(1) + G(-2) + G(2)
即
ΣHBlur = 0.9908656625

看起来似乎是正确的，其实不然。为了使明度不变，这个结果必须绝对是1。

基于此结果，在第二次运算后，它的值进一步下降为：ΣHVBlur = 0.9818147611

这就是说，我们必须增强加权值，通过确定的一个商，以取得正确的结果。答案非常简单，缺少了这个商，我们当然不能得到1：ΣHBlur^-1.

AugFactor = 1 / ΣHBlur
AugFactor = 1.009218543

如果我们再用这个增量，乘以该点的加权以及两个方向（水平、垂直）的运算，ΣHVBlur的值就是1了！



其次是标准差的问题。我使用的解决方案并不太“官方”，但是它确实有效。我们假设一个5 × 5的模糊必须有一个其值为1的标准差。现在我们知道，在一个5 × 5的分布中，距离中心最远的采样点，其加权值最小。其它尺寸的采样分布（比如7× 7），计算出各点的加权值也有这一规律（函数已经有了，你可以简单证明一下）。

要做的是，只调整标准差，以获取最后的采样点加权值，该值越接近这一结果越好。

σ = 1 -> G(2)aug = 0.054488685
σ = 1.745 -> G(3)aug = 0.054441945
σ = 2.7 -> G(4)aug = 0.054409483

这些都是我反复调试出的最接近的结果。所有这些权重增加，他们的和总是1。因此，寻找最佳标准差，最主要的是：尽可能多提取出模糊的采样数，而不产生偏差。

- 一维复合运算 | 二维单一运算 -

为什么会有一维和二维这两个函数呢？因为我们有两种选择：

1、使用一维函数的两次;一次横向，然后（以横向模糊的结果）再做一次垂直运算 ；
2、用二维函数，只需要一步就能完成。

你也许会问，既然有了二维函数，用它不就行了，何必要用一维函数进行两次计算，那多麻烦呀！我的第一反应是，这也许是因为早期Shader模型施加的一些限制。在做了更多的研究之后，我发现有一个更好的解释，来说明为什么要分开运算。

假设n是模糊的线性尺寸（或者说在水平/垂直方向的采样点数量），而p是整个画面的像素总数，那么：

在一维函数中，你要做2np次纹理采样
在二维函数中，你要做n²p次纹理采样

这意味着，如果你对一个512×512尺寸的图像做7×7采样的模糊，一位维函数需要做367万次搜索，而如果用二维函数，那么要完成这幅图像需要1284万次,是前者的3.5倍！

把一个二维坐标的点分解为两个一维的线性矢量是完全可能的，因为高斯模糊是一个可分割的卷积运算。具体的内容你可以到这里看 看：http://nuttybar.drama.uga.edu/pipermail/dirgames-l/2002-December /020874.html

所以，为了追求更快的速度、更高的效率，我宁可放弃二维函数。

- 执行！-

在hlsl中，执行一维高斯模糊最有效的方式是：

1、在顶点着色器（Vertex Shader）中，预先为不同的采样点计算出纹理的坐标偏移（coordinate offsets）。每个坐标占据一个float2 ，所以我能够用尺寸为4的float4阵列来实现9taps（x/y用一个坐标，z/w用另一个），而原始中心点在一个单独的float2里。
因为所有像素采样点的总和是奇数，所以最好的方法就是，让中心点作为一个单独的坐标，然后两个数组为正负两个方向采样点。
使用的“ W ”坐标的免费数据，在ps_1_4及更早的版本中是不允许的，但无论如何，我已经放弃了这些旧版本的Shader。

2、在像素着色器（Pixel Shader）中，使用矩阵的累积样本。如果需要，可以有一个矩阵为正向采样，另一个负向采样，虽然这在5 × 5的情况下是没有必要的。这些矩阵有i行和j列，假设i表示我们正在累加的采样数目，而j是目前我们正在处理的通道数目（通常是4：R,G,B,A,即 红、绿、蓝和透明通道）。一旦获取了采样，矩阵乘法之间的权向量和采样矩阵将给予加权平均…就这么简单！使用一个或两个矩阵，经过运算，得到一个或两个向 量，这时需要把它们加在一起，然后添加到已经加权的原始中心点。



希望你没被我弄晕。

还有不清楚的自己研究代码吧，一窍不通的话也没关系，我把这个Shader放出来，只管用就行了

Shader实例如下，希望它对你有帮助：

// -------------------------------------------------------------
  2 // Those settings are (and must be) set by the host program
  3 // -------------------------------------------------------------
  4 //#define TAPS 5
  5 //#define TAPS 7
  6 //#define TAPS 9
  7 
  8 // -------------------------------------------------------------
  9 // Texture & Sampler
 10 // -------------------------------------------------------------
 11 texture texTexture : TEXTURE0;
 12 sampler sampTexture = sampler_state {
 13  
 14    Texture = (texTexture);
 15     AddressU = Clamp;
 16     AddressV = Clamp;
 17 };
 18 
 19 // -------------------------------------------------------------
 20 // Parameters
 21 // -------------------------------------------------------------
 22 const float centerTapWeight;
 23 const float2 texelSize;
 24 #if TAPS == 5
 25     const float tapOffsets[4] = {-2, -1, 1, 2};
 26     const float4 tapWeights;
 27 #endif   
 28 #if TAPS == 7
 29     const float tapOffsets[3] = {1, 2, 3};
 30     const float3 tapWeights;
 31 #endif
 32 #if TAPS == 9
 33     const float tapOffsets[4] = {1, 2, 3, 4};
 34     const float4 tapWeights;
 35 #endif
 36 
 37 // -------------------------------------------------------------
 38 // Input/Output channels
 39 // -------------------------------------------------------------
 40 struct VS_INPUT
 41 {
 42     float4 position : POSITION;
 43     float2 texCoord : TEXCOORD0;
 44 };
 45 struct VS_OUTPUT
 46 {
 47     float4 position : POSITION;
 48     float2 centerTap : TEXCOORD0;   
 49     #if TAPS == 5
 50         float2 taps[4] : TEXCOORD1;
 51     #endif
 52     #if TAPS == 7
 53         float2 positiveTaps[3] : TEXCOORD1;
 54         float2 negativeTaps[3] : TEXCOORD4;       
 55     #endif
 56     #if TAPS == 9
 57         // Doesn't fit in float2 format!
 58         float4 positiveTaps[2] : TEXCOORD1;
 59         float4 negativeTaps[2] : TEXCOORD3;
 60     #endif       
 61 };
 62 #define PS_INPUT VS_OUTPUT
 63 
 64 // -------------------------------------------------------------
 65 // Vertex Shader
 66 // -------------------------------------------------------------
 67 VS_OUTPUT VS(const VS_INPUT IN, uniform float2 DIRECTION)
 68 {
 69     VS_OUTPUT OUT;
 70     OUT.position = IN.position;
 71     OUT.centerTap = IN.texCoord;   
 72    
 73     #if TAPS == 5
 74         for(int i=0; i<4; i++)
 75             OUT.taps[i] = IN.texCoord + tapOffsets[i] * DIRECTION * texelSize;
 76     #endif
 77     #if TAPS == 7
 78         for(int i=0; i<3; i++)
 79         {
 80             OUT.positiveTaps[i] = IN.texCoord + tapOffsets[i] * DIRECTION * texelSize;
 81             OUT.negativeTaps[i] = IN.texCoord - tapOffsets[i] * DIRECTION * texelSize;
 82         }       
 83     #endif       
 84     #if TAPS == 9
 85         for(int i=0; i<2; i++)
 86         {
 87             OUT.positiveTaps[i].xy = IN.texCoord + tapOffsets[i*2] * DIRECTION * texelSize;
 88             OUT.negativeTaps[i].xy = IN.texCoord - tapOffsets[i*2] * DIRECTION * texelSize;
 89             OUT.positiveTaps[i].zw = IN.texCoord + tapOffsets[i*2+1] * DIRECTION * texelSize;
 90             OUT.negativeTaps[i].zw = IN.texCoord - tapOffsets[i*2+1] * DIRECTION * texelSize;           
 91         }       
 92     #endif
 93    
 94     return OUT;
 95 }
 96 
 97 // -------------------------------------------------------------
 98 // Pixel Shader function
 99 // -------------------------------------------------------------
100 float4 PS(PS_INPUT IN) : COLOR
101 {
102     #if TAPS == 5
103         float4x4 samples;
104     #endif   
105     #if TAPS == 7
106         float3x4 positiveSamples;
107         float3x4 negativeSamples;
108     #endif
109     #if TAPS == 9
110         float4x4 positiveSamples;
111         float4x4 negativeSamples;
112     #endif
113    
114     float4 color = tex2D(sampTexture, IN.centerTap) * centerTapWeight;
115 
116     #if TAPS == 5
117         for(int i=0; i<4; i++)
118             samples[i] = tex2D(sampTexture, IN.taps[i]);
119     #endif
120     #if TAPS == 7
121         for(int i=0; i<3; i++)
122         {
123             positiveSamples[i] = tex2D(sampTexture, IN.positiveTaps[i]);
124             negativeSamples[i] = tex2D(sampTexture, IN.negativeTaps[i]);
125         }
126     #endif
127     #if TAPS == 9
128         for(int i=0; i<2; i++)
129         {
130             positiveSamples[i*2] = tex2D(sampTexture, IN.positiveTaps[i].xy);
131             negativeSamples[i*2] = tex2D(sampTexture, IN.negativeTaps[i].xy);
132             positiveSamples[i*2+1] = tex2D(sampTexture, IN.positiveTaps[i].zw);
133             negativeSamples[i*2+1] = tex2D(sampTexture, IN.negativeTaps[i].zw);       
134         }
135     #endif
136    
137     #if TAPS == 5
138         color += mul(tapWeights, samples);
139     #else
140         color += mul(tapWeights, positiveSamples) + mul(tapWeights, negativeSamples);   
141     #endif
142    
143     return color;
144 }
145 
146 // -------------------------------------------------------------
147 // Techniques
148 // -------------------------------------------------------------
149 technique TSM3
150 {
151 pass HBlur
152  
153    {
154         VertexShader = compile vs_3_0 VS(float2(1, 0));
155         PixelShader = compile ps_3_0 PS();
156     }
157     pass VBlur
158     {
159         VertexShader = compile vs_3_0 VS(float2(0, 1));
160         PixelShader = compile ps_3_0 PS();
161     }       
162 }
163 technique TSM2a
164 {
165     pass HBlur
166     {
167         VertexShader = compile vs_2_0 VS(float2(1, 0));
168         PixelShader = compile ps_2_a PS();
169     }
170     pass VBlur
171     {
172         VertexShader = compile vs_2_0 VS(float2(0, 1));
173         PixelShader = compile ps_2_a PS();
174     }       
175 }
176 technique TSM2b
177 {
178     pass HBlur
179     {
180         VertexShader = compile vs_2_0 VS(float2(1, 0));
181         PixelShader = compile ps_2_b PS();
182     }
183     pass VBlur
184     {
185         VertexShader = compile vs_2_0 VS(float2(0, 1));
186         PixelShader = compile ps_2_b PS();
187     }       
188 }
189 technique TSM2
190 {
191     pass HBlur
192     {
193         VertexShader = compile vs_2_0 VS(float2(1, 0));
194         PixelShader = compile ps_2_0 PS();
195     }
196     pass VBlur
197     {
198         VertexShader = compile vs_2_0 VS(float2(0, 1));
199         PixelShader = compile ps_2_0 PS();
200     }       
201 }

trackback:http://blog.sina.com.cn/s/blog_4b97ab670100aa3a.html