之所以不寫系列文章一、系列文章二這樣的標題，是因為我不知道我能堅持多久。我知道我對事情的表達能力和語言的豐富性方面的天賦不高。而一段代碼需要我去用心的把他從基本原理--》初步實現--》優化速度 等過程用文字的方式表述清楚，恐怕不是一件很容易的事情。
我所掌握的一些Photoshop中的算法,不能說百分之一百就是正確的，但是從執行的效果中，大的方向肯定是沒有問題的。
目前，從別人的文章、開源的代碼以及自己的思考中我掌握的PS的算法可能有近100個吧。如果時間容許、自身的耐心容許，我會將這些東西慢慢的整理開來，雖然在很多人看來，這些算法並不具有什么研究的價值了，畢竟人家都已經商業化了。說的也有道理，我姑且把他作為自我欣賞和自我滿足的一種方式吧。
今天，我們講講查找邊緣算法。可能我說了原理，很多人就不會看下去了，可有幾人層仔細的研究過呢。
先貼個效果圖吧：
原理：常見的Sobel邊緣算子的結果進行反色即可。
為了能吸引你繼續看下去，我先給出我的代碼的執行速度： 針對3000*4000*3的數碼圖片，處理時間300ms。
何為Sobel，從百度抄幾張圖過來了並修改地址后：
對上面兩個式子不做過多解釋，你只需要知道其中A為輸入圖像，把G作為A的輸出圖像就可以了，最后還要做一步： G=255-G，就是查找邊緣算法。
查找邊緣類算法都有個問題，對圖像物理邊緣處的像素如何處理，在平日的處理代碼中，很多人就是忽略四個邊緣的像素，作為專業的圖像處理軟件，這可是違反最基本的原則的。對邊緣進行的單獨的代碼處理，又會給編碼帶來冗余和繁瑣的問題。解決問題的最簡單又高效的方式就是采用哨兵邊界。
寫多了特效類算法的都應該知道，除了那種對單個像素進行處理的算法不需要對原始圖像做個備份（不一定去全局備份），那些需要領域信息的算法由於算法的前一步修改了一個像素，而算法的當前步需要未修改的像素值，因此，一般這種算法都會在開始前對原始圖像做個克隆，在計算時，需要的領域信息從克隆的數據中讀取。如果這個克隆的過程不是完完全全的克隆，而是擴展適當邊界后再克隆，就有可能解決上述的邊界處理問題。
比如對下面的一個圖，19×14像素大小，我們的備份圖為上下左右各擴展一個像素的大小，並用邊緣的值填充，變為21*16大小：
這樣，在計算原圖的3*3領域像素時，從擴展后的克隆圖對應點取樣，就不會出現不在圖像范圍內的問題了，編碼中即可以少很多判斷，可讀性也加強了。
在計算速度方面，注意到上面的計算式G中有個開方運算，這是個耗時的過程，由於圖像數據的特殊性，都必須是整數，可以采用查找表的方式優化速度，這就需要考慮表的建立。
針對本文的具體問題，我們分兩步討論，第一：針對根號下的所有可能情況建立查找表。看看GX和GY的計算公式，考慮下兩者的平方和的最大值是多少，可能要考慮一會吧。第二：就是只建立0^2到255^2范圍內的查找表，然后確保根號下的數字不大於255^2。為什么可以這樣做，就是因為圖像數據的最大值就是255，如果根號下的數字大於255^2，在求出開方值后，還是需要規整為255的。因此，本算法中應該取后者。
貼出代碼：
private void CmdFindEdgesArray_Click(object sender, EventArgs e) { int X, Y; int Width, Height, Stride, StrideC, HeightC; int Speed, SpeedOne, SpeedTwo, SpeedThree; int BlueOne, BlueTwo, GreenOne, GreenTwo, RedOne, RedTwo; int PowerRed, PowerGreen, PowerBlue; Bitmap Bmp = (Bitmap)Pic.Image; if (Bmp.PixelFormat != PixelFormat.Format24bppRgb) throw new Exception("不支持的圖像格式."); byte[] SqrValue = new byte[65026]; for (Y = 0; Y < 65026; Y++) SqrValue[Y] = (byte)(255 - (int)Math.Sqrt(Y)); // 計算查找表，注意已經砸查找表里進行了反色
Width = Bmp.Width; Height = Bmp.Height; Stride = (int)((Bmp.Width * 3 + 3) & 0XFFFFFFFC); StrideC = (Width + 2) * 3; HeightC = Height + 2; // 寬度和高度都擴展2個像素
byte[] ImageData = new byte[Stride * Height]; // 用於保存圖像數據，（處理前后的都為他)
byte[] ImageDataC = new byte[StrideC * HeightC]; // 用於保存擴展后的圖像數據
fixed (byte* Scan0 = &ImageData[0]) { BitmapData BmpData = new BitmapData(); BmpData.Scan0 = (IntPtr)Scan0; // 設置為字節數組的的第一個元素在內存中的地址
BmpData.Stride = Stride; Bmp.LockBits(new Rectangle(0, 0, Bmp.Width, Bmp.Height), ImageLockMode.ReadWrite | ImageLockMode.UserInputBuffer, PixelFormat.Format24bppRgb, BmpData); Stopwatch Sw = new Stopwatch(); // 只獲取計算用時
Sw.Start(); for (Y = 0; Y < Height; Y++) { System.Buffer.BlockCopy(ImageData, Stride * Y, ImageDataC, StrideC * (Y + 1), 3); // 填充擴展圖的左側第一列像素(不包括第一個和最后一個點)
System.Buffer.BlockCopy(ImageData, Stride * Y + (Width - 1) * 3, ImageDataC, StrideC * (Y + 1) + (Width + 1) * 3, 3); // 填充最右側那一列的數據
System.Buffer.BlockCopy(ImageData, Stride * Y, ImageDataC, StrideC * (Y + 1) + 3, Width * 3); } System.Buffer.BlockCopy(ImageDataC, StrideC, ImageDataC, 0, StrideC); // 第一行
System.Buffer.BlockCopy(ImageDataC, (HeightC - 2) * StrideC, ImageDataC, (HeightC - 1) * StrideC, StrideC); // 最后一行
for (Y = 0; Y < Height; Y++) { Speed = Y * Stride; SpeedOne = StrideC * Y; for (X = 0; X < Width; X++) { SpeedTwo = SpeedOne + StrideC; // 盡量減少計算
SpeedThree = SpeedTwo + StrideC; // 下面的就是嚴格的按照Sobel算字進行計算，代碼中的*2一般會優化為移位或者兩個Add指令的，如果你不放心，當然可以直接改成移位
BlueOne = ImageDataC[SpeedOne] + 2 * ImageDataC[SpeedTwo] + ImageDataC[SpeedThree] - ImageDataC[SpeedOne + 6] - 2 * ImageDataC[SpeedTwo + 6] - ImageDataC[SpeedThree + 6]; GreenOne = ImageDataC[SpeedOne + 1] + 2 * ImageDataC[SpeedTwo + 1] + ImageDataC[SpeedThree + 1] - ImageDataC[SpeedOne + 7] - 2 * ImageDataC[SpeedTwo + 7] - ImageDataC[SpeedThree + 7]; RedOne = ImageDataC[SpeedOne + 2] + 2 * ImageDataC[SpeedTwo + 2] + ImageDataC[SpeedThree + 2] - ImageDataC[SpeedOne + 8] - 2 * ImageDataC[SpeedTwo + 8] - ImageDataC[SpeedThree + 8]; BlueTwo = ImageDataC[SpeedOne] + 2 * ImageDataC[SpeedOne + 3] + ImageDataC[SpeedOne + 6] - ImageDataC[SpeedThree] - 2 * ImageDataC[SpeedThree + 3] - ImageDataC[SpeedThree + 6]; GreenTwo = ImageDataC[SpeedOne + 1] + 2 * ImageDataC[SpeedOne + 4] + ImageDataC[SpeedOne + 7] - ImageDataC[SpeedThree + 1] - 2 * ImageDataC[SpeedThree + 4] - ImageDataC[SpeedThree + 7]; RedTwo = ImageDataC[SpeedOne + 2] + 2 * ImageDataC[SpeedOne + 5] + ImageDataC[SpeedOne + 8] - ImageDataC[SpeedThree + 2] - 2 * ImageDataC[SpeedThree + 5] - ImageDataC[SpeedThree + 8]; PowerBlue = BlueOne * BlueOne + BlueTwo * BlueTwo; PowerGreen = GreenOne * GreenOne + GreenTwo * GreenTwo; PowerRed = RedOne * RedOne + RedTwo * RedTwo; if (PowerBlue > 65025) PowerBlue = 65025; // 處理掉溢出值
if (PowerGreen > 65025) PowerGreen = 65025; if (PowerRed > 65025) PowerRed = 65025; ImageData[Speed] = SqrValue[PowerBlue]; // 查表
ImageData[Speed + 1] = SqrValue[PowerGreen]; ImageData[Speed + 2] = SqrValue[PowerRed]; Speed += 3; // 跳往下一個像素
SpeedOne += 3; } } Sw.Stop(); this.Text = "計算用時: " + Sw.ElapsedMilliseconds.ToString() + " ms"; Bmp.UnlockBits(BmpData); // 必須先解鎖，否則Invalidate失敗
} Pic.Invalidate(); }
為簡單的起見，這里先是用的C#的一維數組實現的，並且計時部分未考慮圖像數據的獲取和更新， 因為真正的圖像處理過程中圖像數據肯定是已經獲得的了。
針對上述代碼，編譯為Release模式后，執行編譯后的EXE，對於3000*4000*3的彩色圖像，耗時約480ms，如果你是在IDE的模式先運行，記得一定要在選項--》調試--》常規里不勾選 在模塊加載時取消JIT優化（僅限托管）一欄。
上述代碼中的填充克隆圖數據時並沒有新建一副圖，然后再填充其中的圖像數據，而是直接填充一個數組，圖像其實不就是一片連續內存加一點頭信息嗎，頭信息已經有了，所以只要一片內存就夠了。
克隆數據的填充采用了系統Buffer.BlockCopy函數，該函數類似於我們以前常用CopyMemory，速度非常快。
為進一步調高執行速度，我們首先來看看算法的關鍵耗時部位的代碼，即for (X = 0; X < Width; X++)內部的代碼，我們取一行代碼的反編譯碼來看看：
BlueOne = ImageDataC[SpeedOne] + 2 * ImageDataC[SpeedTwo] + ImageDataC[SpeedThree] - ImageDataC[SpeedOne + 6] - 2 * ImageDataC[SpeedTwo + 6] - ImageDataC[SpeedThree + 6];
00000302 cmp ebx,edi 00000304 jae 0000073C // 數組是否越界？ 0000030a movzx eax,byte ptr [esi+ebx+8] // 將ImageDataC[SpeedOne]中的數據傳送的eax寄存器 0000030f mov dword ptr [ebp-80h],eax 00000312 mov edx,dword ptr [ebp-2Ch] 00000315 cmp edx,edi 00000317 jae 0000073C // 數組是否越界？ 0000031d movzx edx,byte ptr [esi+edx+8] // 將ImageDataC[SpeedTwo]中的數據傳送到edx寄存器 00000322 add edx,edx // 計算2*ImageDataC[SpeedTwo] 00000324 add eax,edx // 計算ImageDataC[SpeedOne]+2*ImageDataC[SpeedTwo]，並保存在eax寄存器中 00000326 cmp ecx,edi 00000328 jae 0000073C 0000032e movzx edx,byte ptr [esi+ecx+8] // 將ImageDataC[SpeedThree]中的數據傳送到edx寄存器 00000333 mov dword ptr [ebp+FFFFFF78h],edx 00000339 add eax,edx 0000033b lea edx,[ebx+6] 0000033e cmp edx,edi 00000340 jae 0000073C 00000346 movzx edx,byte ptr [esi+edx+8] 0000034b mov dword ptr [ebp+FFFFFF7Ch],edx 00000351 sub eax,edx 00000353 mov edx,dword ptr [ebp-2Ch] 00000356 add edx,6
00000359 cmp edx,edi 0000035b jae 0000073C 00000361 movzx edx,byte ptr [esi+edx+8] 00000366 add edx,edx 00000368 sub eax,edx 0000036a lea edx,[ecx+6] 0000036d cmp edx,edi 0000036f jae 0000073C 00000375 movzx edx,byte ptr [esi+edx+8] 0000037a mov dword ptr [ebp+FFFFFF74h],edx 00000380 sub eax,edx 00000382 mov dword ptr [ebp-30h],eax
上述匯編碼我只注釋一點點，其中最0000073c 標號，我們跟蹤后返現是調用了另外一個函數：
0000073c call 685172A4
我們看到在獲取每一個數組元素前，都必須執行一個cmp 和 jae指令，從分析我認為這里是做類似於判斷數組的下標是否越界之類的工作的。如果我們能確保我們的算法那不會產生越界，這部分代碼有很用呢，不是耽誤我做正事嗎。
為此，我認為需要在C#中直接利用指針來實現算法，C#中有unsafe模式，也有指針，所以很方便，而且指針的表達即可以用*，也可以用[]，比如*(P+4) 和P[4]是一個意思。那么只要做很少的修改就可以將上述代碼修改為指針版。
private void CmdFindEdgesPointer_Click(object sender, EventArgs e) { int X, Y; int Width, Height, Stride, StrideC, HeightC; int Speed, SpeedOne, SpeedTwo, SpeedThree; int BlueOne, BlueTwo, GreenOne, GreenTwo, RedOne, RedTwo; int PowerRed, PowerGreen, PowerBlue; Bitmap Bmp = (Bitmap)Pic.Image; if (Bmp.PixelFormat != PixelFormat.Format24bppRgb) throw new Exception("不支持的圖像格式."); byte[] SqrValue = new byte[65026]; for (Y = 0; Y < 65026; Y++) SqrValue[Y] = (byte)(255 - (int)Math.Sqrt(Y)); // 計算查找表，注意已經砸查找表里進行了反色
Width = Bmp.Width; Height = Bmp.Height; Stride = (int)((Bmp.Width * 3 + 3) & 0XFFFFFFFC); StrideC = (Width + 2) * 3; HeightC = Height + 2; // 寬度和高度都擴展2個像素
byte[] ImageData = new byte[Stride * Height]; // 用於保存圖像數據，（處理前后的都為他)
byte[] ImageDataC = new byte[StrideC * HeightC]; // 用於保存擴展后的圖像數據
fixed (byte* P = &ImageData[0], CP = &ImageDataC[0], LP = &SqrValue[0]) { byte* DataP = P, DataCP = CP, LutP = LP; BitmapData BmpData = new BitmapData(); BmpData.Scan0 = (IntPtr)DataP; // 設置為字節數組的的第一個元素在內存中的地址
BmpData.Stride = Stride; Bmp.LockBits(new Rectangle(0, 0, Bmp.Width, Bmp.Height), ImageLockMode.ReadWrite | ImageLockMode.UserInputBuffer, PixelFormat.Format24bppRgb, BmpData); Stopwatch Sw = new Stopwatch(); // 只獲取計算用時
Sw.Start(); for (Y = 0; Y < Height; Y++) { System.Buffer.BlockCopy(ImageData, Stride * Y, ImageDataC, StrideC * (Y + 1), 3); // 填充擴展圖的左側第一列像素(不包括第一個和最后一個點)
System.Buffer.BlockCopy(ImageData, Stride * Y + (Width - 1) * 3, ImageDataC, StrideC * (Y + 1) + (Width + 1) * 3, 3); // 填充最右側那一列的數據
System.Buffer.BlockCopy(ImageData, Stride * Y, ImageDataC, StrideC * (Y + 1) + 3, Width * 3); } System.Buffer.BlockCopy(ImageDataC, StrideC, ImageDataC, 0, StrideC); // 第一行
System.Buffer.BlockCopy(ImageDataC, (HeightC - 2) * StrideC, ImageDataC, (HeightC - 1) * StrideC, StrideC); // 最后一行
for (Y = 0; Y < Height; Y++) { Speed = Y * Stride; SpeedOne = StrideC * Y; for (X = 0; X < Width; X++) { SpeedTwo = SpeedOne + StrideC; // 盡量減少計算
SpeedThree = SpeedTwo + StrideC; // 下面的就是嚴格的按照Sobel算字進行計算，代碼中的*2一般會優化為移位或者兩個Add指令的，如果你不放心，當然可以直接改成移位
BlueOne = DataCP[SpeedOne] + 2 * DataCP[SpeedTwo] + DataCP[SpeedThree] - DataCP[SpeedOne + 6] - 2 * DataCP[SpeedTwo + 6] - DataCP[SpeedThree + 6]; GreenOne = DataCP[SpeedOne + 1] + 2 * DataCP[SpeedTwo + 1] + DataCP[SpeedThree + 1] - DataCP[SpeedOne + 7] - 2 * DataCP[SpeedTwo + 7] - DataCP[SpeedThree + 7]; RedOne = DataCP[SpeedOne + 2] + 2 * DataCP[SpeedTwo + 2] + DataCP[SpeedThree + 2] - DataCP[SpeedOne + 8] - 2 * DataCP[SpeedTwo + 8] - DataCP[SpeedThree + 8]; BlueTwo = DataCP[SpeedOne] + 2 * DataCP[SpeedOne + 3] + DataCP[SpeedOne + 6] - DataCP[SpeedThree] - 2 * DataCP[SpeedThree + 3] - DataCP[SpeedThree + 6]; GreenTwo = DataCP[SpeedOne + 1] + 2 * DataCP[SpeedOne + 4] + DataCP[SpeedOne + 7] - DataCP[SpeedThree + 1] - 2 * DataCP[SpeedThree + 4] - DataCP[SpeedThree + 7]; RedTwo = DataCP[SpeedOne + 2] + 2 * DataCP[SpeedOne + 5] + DataCP[SpeedOne + 8] - DataCP[SpeedThree + 2] - 2 * DataCP[SpeedThree + 5] - DataCP[SpeedThree + 8]; PowerBlue = BlueOne * BlueOne + BlueTwo * BlueTwo; PowerGreen = GreenOne * GreenOne + GreenTwo * GreenTwo; PowerRed = RedOne * RedOne + RedTwo * RedTwo; if (PowerBlue > 65025) PowerBlue = 65025; // 處理掉溢出值
if (PowerGreen > 65025) PowerGreen = 65025; if (PowerRed > 65025) PowerRed = 65025; DataP[Speed] = LutP[PowerBlue]; // 查表
DataP[Speed + 1] = LutP[PowerGreen]; DataP[Speed + 2] = LutP[PowerRed]; Speed += 3; // 跳往下一個像素
SpeedOne += 3; } } Sw.Stop(); this.Text = "計算用時: " + Sw.ElapsedMilliseconds.ToString() + " ms"; Bmp.UnlockBits(BmpData); // 必須先解鎖，否則Invalidate失敗
} Pic.Invalidate(); }
同樣的效果，同樣的圖像，計算用時330ms。
我們在來看看相同代碼的匯編碼：
BlueOne = DataCP[SpeedOne] + 2 * DataCP[SpeedTwo] + DataCP[SpeedThree] - DataCP[SpeedOne + 6] - 2 * DataCP[SpeedTwo + 6] - DataCP[SpeedThree + 6];
00000318 movzx eax,byte ptr [esi+edi] 0000031c mov dword ptr [ebp-74h],eax 0000031f movzx edx,byte ptr [esi+ebx] 00000323 add edx,edx 00000325 add eax,edx 00000327 movzx edx,byte ptr [esi+ecx] 0000032b mov dword ptr [ebp-7Ch],edx 0000032e add eax,edx 00000330 movzx edx,byte ptr [esi+edi+6] 00000335 mov dword ptr [ebp-78h],edx 00000338 sub eax,edx 0000033a movzx edx,byte ptr [esi+ebx+6] 0000033f add edx,edx 00000341 sub eax,edx 00000343 movzx edx,byte ptr [esi+ecx+6] 00000348 mov dword ptr [ebp-80h],edx 0000034b sub eax,edx 0000034d mov dword ptr [ebp-30h],eax
生產的匯編碼簡潔，意義明確，對比下少了很多指令。當然速度會快很多。
注意這一段代碼：
fixed (byte* P = &ImageData[0], CP = &ImageDataC[0], LP = &SqrValue[0]) { byte* DataP = P, DataCP = CP, LutP = LP;
如果你把更換為：
fixed (byte* DataP = &ImageData[0], DataCP = &ImageDataC[0], LutP = &SqrValue[0]) {
代碼的速度反而比純數組版的還慢，至於為什么，實踐為王吧，我也沒有去分析，反正我知道有這個結果。你可以參考鐵哥的一篇文章：
閑談.Net類型之public的不public，fixed的不能fixed
當然這個還可以進一步做小動作的的優化，比如movzx eax,byte ptr [esi+edi] 這句中，esi其實就是數組的基地址，向這樣寫DataCP[SpeedOne] ，每次都會有這個基址+偏移的計算的，如果能實時直接動態控制一個指針變量，使他直接指向索要的位置，則少了一次加法，雖然優化不是很明顯，基本可以達到問中之前所提到的300ms的時間了。具體的代碼可見附件。
很多人可能對我這些東西不感冒，說這些東西丟給GPU比你現在的.......希望這些朋友也不要過分的打擊吧，每個人都有自己的愛好,我只愛好CPU。
完整工程下載地址：http://files.cnblogs.com/Imageshop/FindEdges.rar
同一個圖片，本例和PS所得結果有10%左右的差異。
***************************作者： laviewpbt 時間： 2013.7.4 聯系QQ: 33184777 轉載請保留本行信息*************************