碼上歡樂
相關內容    簡體    繁體

圖像處理之Canny邊緣檢測

本文轉載自   查看原文   2015-11-10 21:16   2037    圖像處理

http://blog.csdn.net/jia20003/article/details/41173767

圖像處理之Canny 邊緣檢測

一：歷史

Canny邊緣檢測算法是1986年有John F. Canny開發出來一種基於圖像梯度計算的邊緣

檢測算法，同時Canny本人對計算圖像邊緣提取學科的發展也是做出了很多的貢獻。盡

管至今已經許多年過去，但是該算法仍然是圖像邊緣檢測方法經典算法之一。

二：Canny邊緣檢測算法

經典的Canny邊緣檢測算法通常都是從高斯模糊開始，到基於雙閾值實現邊緣連接結束

。但是在實際工程應用中，考慮到輸入圖像都是彩色圖像，最終邊緣連接之后的圖像要

二值化輸出顯示，所以完整的Canny邊緣檢測算法實現步驟如下：

1.      彩色圖像轉換為灰度圖像

2.      對圖像進行高斯模糊

3.      計算圖像梯度，根據梯度計算圖像邊緣幅值與角度

4.      非最大信號壓制處理（邊緣細化）

5.      雙閾值邊緣連接處理

6.      二值化圖像輸出結果

三：各步詳解與代碼實現

1.      彩色圖像轉灰度圖像

根據彩色圖像RGB轉灰度公式：gray  =  R * 0.299 + G * 0.587 + B * 0.114

將彩色圖像中每個RGB像素轉為灰度值的代碼如下：

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
 
  1. <span style="font-size:18px;">int gray = (int) (0.299 * tr + 0.587 * tg + 0.114 * tb);</span>  

 

 

2.      對圖像進行高斯模糊

圖像高斯模糊時，首先要根據輸入參數確定高斯方差與窗口大小，這里我設置默認方

差值窗口大小為16x16，根據這兩個參數生成高斯卷積核算子的代碼如下：

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
 
  1. <span style="font-size:18px;">      float kernel[][] = new float[gaussianKernelWidth][gaussianKernelWidth];  
  2.         for(int x=0; x<gaussianKernelWidth; x++)  
  3.         {  
  4.             for(int y=0; y<gaussianKernelWidth; y++)  
  5.             {  
  6.                 kernel[x][y] = gaussian(x, y, gaussianKernelRadius);  
  7.             }  
  8.         }</span>  

 

獲取了高斯卷積算子之后，我們就可以對圖像高斯卷積模糊，關於高斯圖像模糊更詳

細的解釋可以參見這里：http://blog.csdn.net/jia20003/article/details/7234741實現

圖像高斯卷積模糊的代碼如下：

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
 
  1. <span style="font-size:18px;">// 高斯模糊 -灰度圖像  
  2. int krr = (int)gaussianKernelRadius;  
  3. for (int row = 0; row < height; row++) {  
  4.     for (int col = 0; col < width; col++) {  
  5.         index = row * width + col;  
  6.         double weightSum = 0.0;  
  7.         double redSum = 0;  
  8.         for(int subRow=-krr; subRow<=krr; subRow++)  
  9.         {  
  10.             int nrow = row + subRow;  
  11.             if(nrow >= height || nrow < 0)  
  12.             {  
  13.                 nrow = 0;  
  14.             }  
  15.             for(int subCol=-krr; subCol<=krr; subCol++)  
  16.             {  
  17.                 int ncol = col + subCol;  
  18.                 if(ncol >= width || ncol <=0)  
  19.                 {  
  20.                     ncol = 0;  
  21.                 }  
  22.                 int index2 = nrow * width + ncol;  
  23.                 int tr1 = (inPixels[index2] >> 16) & 0xff;  
  24.                 redSum += tr1*kernel[subRow+krr][subCol+krr];  
  25.                 weightSum += kernel[subRow+krr][subCol+krr];  
  26.             }  
  27.         }  
  28.         int gray = (int)(redSum / weightSum);  
  29.         outPixels[index] = gray;  
  30.     }  
  31. }</span>  

3.      計算圖像X方向與Y方向梯度，根據梯度計算圖像邊緣幅值與角度大小

高斯模糊的目的主要為了整體降低圖像噪聲，目的是為了更准確計算圖像梯度及邊緣

幅值。計算圖像梯度可以選擇算子有Robot算子、Sobel算子、Prewitt算子等。關於

圖像梯度計算更多的解釋可以看這里：

http://blog.csdn.net/jia20003/article/details/7664777。

這里采用更加簡單明了的2x2的算子，其數學表達如下：

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
 
  1. <span style="font-size:18px;">// 計算梯度-gradient, X放與Y方向  
  2. data = new float[width * height];  
  3. magnitudes = new float[width * height];  
  4. for (int row = 0; row < height; row++) {  
  5.     for (int col = 0; col < width; col++) {  
  6.         index = row * width + col;  
  7.         // 計算X方向梯度  
  8.         float xg = (getPixel(outPixels, width, height, col, row+1) -   
  9.                 getPixel(outPixels, width, height, col, row) +   
  10.                 getPixel(outPixels, width, height, col+1, row+1) -  
  11.                 getPixel(outPixels, width, height, col+1, row))/2.0f;  
  12.         float yg = (getPixel(outPixels, width, height, col, row)-  
  13.                 getPixel(outPixels, width, height, col+1, row) +  
  14.                 getPixel(outPixels, width, height, col, row+1) -  
  15.                 getPixel(outPixels, width, height, col+1, row+1))/2.0f;  
  16.         // 計算振幅與角度  
  17.         data[index] = hypot(xg, yg);  
  18.         if(xg == 0)  
  19.         {  
  20.             if(yg > 0)  
  21.             {  
  22.                 magnitudes[index]=90;                         
  23.             }  
  24.             if(yg < 0)  
  25.             {  
  26.                 magnitudes[index]=-90;  
  27.             }  
  28.         }  
  29.         else if(yg == 0)  
  30.         {  
  31.             magnitudes[index]=0;  
  32.         }  
  33.         else  
  34.         {  
  35.             magnitudes[index] = (float)((Math.atan(yg/xg) * 180)/Math.PI);                    
  36.         }  
  37.         // make it 0 ~ 180  
  38.         magnitudes[index] += 90;  
  39.     }  
  40. }</span>  

在獲取了圖像每個像素的邊緣幅值與角度之后

4.      非最大信號壓制

信號壓制本來是數字信號處理中經常用的，這里的非最大信號壓制主要目的是實現邊

緣細化，通過該步處理邊緣像素進一步減少。非最大信號壓制主要思想是假設3x3的

像素區域，中心像素P(x,y) 根據上一步中計算得到邊緣角度值angle，可以將角度分

為四個離散值0、45、90、135分類依據如下：

 

其中黃色區域取值范圍為0~22.5 與157.5～180

綠色區域取值范圍為22.5 ~ 67.5

藍色區域取值范圍為67.5~112.5

紅色區域取值范圍為112.5~157.5

分別表示上述四個離散角度的取值范圍。得到角度之后，比較中心像素角度上相鄰

兩個像素，如果中心像素小於其中任意一個，則舍棄該邊緣像素點，否則保留。一

個簡單的例子如下：

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
 
  1. <span style="font-size:18px;">// 非最大信號壓制算法 3x3  
  2. Arrays.fill(magnitudes, 0);  
  3. for (int row = 0; row < height; row++) {  
  4.     for (int col = 0; col < width; col++) {  
  5.         index = row * width + col;  
  6.         float angle = magnitudes[index];  
  7.         float m0 = data[index];  
  8.         magnitudes[index] = m0;  
  9.         if(angle >=0 && angle < 22.5) // angle 0  
  10.         {  
  11.             float m1 = getPixel(data, width, height, col-1, row);  
  12.             float m2 = getPixel(data, width, height, col+1, row);  
  13.             if(m0 < m1 || m0 < m2)  
  14.             {  
  15.                 magnitudes[index] = 0;  
  16.             }  
  17.         }  
  18.         else if(angle >= 22.5 && angle < 67.5) // angle +45  
  19.         {  
  20.             float m1 = getPixel(data, width, height, col+1, row-1);  
  21.             float m2 = getPixel(data, width, height, col-1, row+1);  
  22.             if(m0 < m1 || m0 < m2)  
  23.             {  
  24.                 magnitudes[index] = 0;  
  25.             }  
  26.         }  
  27.         else if(angle >= 67.5 && angle < 112.5) // angle 90  
  28.         {  
  29.             float m1 = getPixel(data, width, height, col, row+1);  
  30.             float m2 = getPixel(data, width, height, col, row-1);  
  31.             if(m0 < m1 || m0 < m2)  
  32.             {  
  33.                 magnitudes[index] = 0;  
  34.             }  
  35.         }  
  36.         else if(angle >=112.5 && angle < 157.5) // angle 135 / -45  
  37.         {  
  38.             float m1 = getPixel(data, width, height, col-1, row-1);  
  39.             float m2 = getPixel(data, width, height, col+1, row+1);  
  40.             if(m0 < m1 || m0 < m2)  
  41.             {  
  42.                 magnitudes[index] = 0;  
  43.             }  
  44.         }  
  45.         else if(angle >=157.5) // angle 0  
  46.         {  
  47.             float m1 = getPixel(data, width, height, col, row+1);  
  48.             float m2 = getPixel(data, width, height, col, row-1);  
  49.             if(m0 < m1 || m0 < m2)  
  50.             {  
  51.                 magnitudes[index] = 0;  
  52.             }  
  53.         }  
  54.     }  
  55. }</span>  

 

1.      雙閾值邊緣連接

非最大信號壓制以后，輸出的幅值如果直接顯示結果可能會少量的非邊緣像素被包

含到結果中，所以要通過選取閾值進行取舍，傳統的基於一個閾值的方法如果選擇

的閾值較小起不到過濾非邊緣的作用，如果選擇的閾值過大容易丟失真正的圖像邊

緣，Canny提出基於雙閾值(Fuzzy threshold)方法很好的實現了邊緣選取，在實際

應用中雙閾值還有邊緣連接的作用。雙閾值選擇與邊緣連接方法通過假設兩個閾值

其中一個為高閾值TH另外一個為低閾值TL則有

a.      對於任意邊緣像素低於TL的則丟棄

b.      對於任意邊緣像素高於TH的則保留

c.      對於任意邊緣像素值在TL與TH之間的，如果能通過邊緣連接到一個像素大於

TH而且邊緣所有像素大於最小閾值TL的則保留，否則丟棄。代碼實現如下：

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
 
  1. <span style="font-size:18px;">Arrays.fill(data, 0);  
  2. int offset = 0;  
  3. for (int row = 0; row < height; row++) {  
  4.     for (int col = 0; col < width; col++) {  
  5.         if(magnitudes[offset] >= highThreshold && data[offset] == 0)  
  6.         {  
  7.             edgeLink(col, row, offset, lowThreshold);  
  8.         }  
  9.         offset++;  
  10.     }  
  11. }</span>  

基於遞歸的邊緣尋找方法edgeLink的代碼如下：

 

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
 
  1. <span style="font-size:18px;">private void edgeLink(int x1, int y1, int index, float threshold) {  
  2.     int x0 = (x1 == 0) ? x1 : x1 - 1;  
  3.     int x2 = (x1 == width - 1) ? x1 : x1 + 1;  
  4.     int y0 = y1 == 0 ? y1 : y1 - 1;  
  5.     int y2 = y1 == height -1 ? y1 : y1 + 1;  
  6.       
  7.     data[index] = magnitudes[index];  
  8.     for (int x = x0; x <= x2; x++) {  
  9.         for (int y = y0; y <= y2; y++) {  
  10.             int i2 = x + y * width;  
  11.             if ((y != y1 || x != x1)  
  12.                 && data[i2] == 0   
  13.                 && magnitudes[i2] >= threshold) {  
  14.                 edgeLink(x, y, i2, threshold);  
  15.                 return;  
  16.             }  
  17.         }  
  18.     }  
  19. }</span>  

 

6.      結果二值化顯示 - 不說啦，直接點，自己看吧，太簡單啦

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
 
  1. <span style="font-size:18px;">// 二值化顯示  
  2. for(int i=0; i<inPixels.length; i++)  
  3. {  
  4.     int gray = clamp((int)data[i]);  
  5.     outPixels[i] = gray > 0 ? -1 : 0xff000000;       
  6. }</span>  

最終運行結果：

 


四：完整的Canny算法源代碼

 

[java]  view plain copy 在CODE上查看代碼片 派生到我的代碼片
 
  1. package com.gloomyfish.filter.study;  
  2.   
  3. import java.awt.image.BufferedImage;  
  4. import java.util.Arrays;  
  5.   
  6. public class CannyEdgeFilter extends AbstractBufferedImageOp {  
  7.     private float gaussianKernelRadius = 2f;  
  8.     private int gaussianKernelWidth = 16;  
  9.     private float lowThreshold;  
  10.     private float highThreshold;  
  11.     // image width, height  
  12.     private int width;  
  13.     private int height;  
  14.     private float[] data;  
  15.     private float[] magnitudes;  
  16.   
  17.     public CannyEdgeFilter() {  
  18.         lowThreshold = 2.5f;  
  19.         highThreshold = 7.5f;  
  20.         gaussianKernelRadius = 2f;  
  21.         gaussianKernelWidth = 16;  
  22.     }  
  23.   
  24.     public float getGaussianKernelRadius() {  
  25.         return gaussianKernelRadius;  
  26.     }  
  27.   
  28.     public void setGaussianKernelRadius(float gaussianKernelRadius) {  
  29.         this.gaussianKernelRadius = gaussianKernelRadius;  
  30.     }  
  31.   
  32.     public int getGaussianKernelWidth() {  
  33.         return gaussianKernelWidth;  
  34.     }  
  35.   
  36.     public void setGaussianKernelWidth(int gaussianKernelWidth) {  
  37.         this.gaussianKernelWidth = gaussianKernelWidth;  
  38.     }  
  39.   
  40.     public float getLowThreshold() {  
  41.         return lowThreshold;  
  42.     }  
  43.   
  44.     public void setLowThreshold(float lowThreshold) {  
  45.         this.lowThreshold = lowThreshold;  
  46.     }  
  47.   
  48.     public float getHighThreshold() {  
  49.         return highThreshold;  
  50.     }  
  51.   
  52.     public void setHighThreshold(float highThreshold) {  
  53.         this.highThreshold = highThreshold;  
  54.     }  
  55.   
  56.     @Override  
  57.     public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
  58.         width = src.getWidth();  
  59.         height = src.getHeight();  
  60.         if (dest == null)  
  61.             dest = createCompatibleDestImage(src, null);  
  62.         // 圖像灰度化  
  63.         int[] inPixels = new int[width * height];  
  64.         int[] outPixels = new int[width * height];  
  65.         getRGB(src, 0, 0, width, height, inPixels);  
  66.         int index = 0;  
  67.         for (int row = 0; row < height; row++) {  
  68.             int ta = 0, tr = 0, tg = 0, tb = 0;  
  69.             for (int col = 0; col < width; col++) {  
  70.                 index = row * width + col;  
  71.                 ta = (inPixels[index] >> 24) & 0xff;  
  72.                 tr = (inPixels[index] >> 16) & 0xff;  
  73.                 tg = (inPixels[index] >> 8) & 0xff;  
  74.                 tb = inPixels[index] & 0xff;  
  75.                 int gray = (int) (0.299 * tr + 0.587 * tg + 0.114 * tb);  
  76.                 inPixels[index] = (ta << 24) | (gray << 16) | (gray << 8)  
  77.                         | gray;  
  78.             }  
  79.         }  
  80.           
  81.         // 計算高斯卷積核  
  82.         float kernel[][] = new float[gaussianKernelWidth][gaussianKernelWidth];  
  83.         for(int x=0; x<gaussianKernelWidth; x++)  
  84.         {  
  85.             for(int y=0; y<gaussianKernelWidth; y++)  
  86.             {  
  87.                 kernel[x][y] = gaussian(x, y, gaussianKernelRadius);  
  88.             }  
  89.         }  
  90.         // 高斯模糊 -灰度圖像  
  91.         int krr = (int)gaussianKernelRadius;  
  92.         for (int row = 0; row < height; row++) {  
  93.             for (int col = 0; col < width; col++) {  
  94.                 index = row * width + col;  
  95.                 double weightSum = 0.0;  
  96.                 double redSum = 0;  
  97.                 for(int subRow=-krr; subRow<=krr; subRow++)  
  98.                 {  
  99.                     int nrow = row + subRow;  
  100.                     if(nrow >= height || nrow < 0)  
  101.                     {  
  102.                         nrow = 0;  
  103.                     }  
  104.                     for(int subCol=-krr; subCol<=krr; subCol++)  
  105.                     {  
  106.                         int ncol = col + subCol;  
  107.                         if(ncol >= width || ncol <=0)  
  108.                         {  
  109.                             ncol = 0;  
  110.                         }  
  111.                         int index2 = nrow * width + ncol;  
  112.                         int tr1 = (inPixels[index2] >> 16) & 0xff;  
  113.                         redSum += tr1*kernel[subRow+krr][subCol+krr];  
  114.                         weightSum += kernel[subRow+krr][subCol+krr];  
  115.                     }  
  116.                 }  
  117.                 int gray = (int)(redSum / weightSum);  
  118.                 outPixels[index] = gray;  
  119.             }  
  120.         }  
  121.           
  122.         // 計算梯度-gradient, X放與Y方向  
  123.         data = new float[width * height];  
  124.         magnitudes = new float[width * height];  
  125.         for (int row = 0; row < height; row++) {  
  126.             for (int col = 0; col < width; col++) {  
  127.                 index = row * width + col;  
  128.                 // 計算X方向梯度  
  129.                 float xg = (getPixel(outPixels, width, height, col, row+1) -   
  130.                         getPixel(outPixels, width, height, col, row) +   
  131.                         getPixel(outPixels, width, height, col+1, row+1) -  
  132.                         getPixel(outPixels, width, height, col+1, row))/2.0f;  
  133.                 float yg = (getPixel(outPixels, width, height, col, row)-  
  134.                         getPixel(outPixels, width, height, col+1, row) +  
  135.                         getPixel(outPixels, width, height, col, row+1) -  
  136.                         getPixel(outPixels, width, height, col+1, row+1))/2.0f;  
  137.                 // 計算振幅與角度  
  138.                 data[index] = hypot(xg, yg);  
  139.                 if(xg == 0)  
  140.                 {  
  141.                     if(yg > 0)  
  142.                     {  
  143.                         magnitudes[index]=90;                         
  144.                     }  
  145.                     if(yg < 0)  
  146.                     {  
  147.                         magnitudes[index]=-90;  
  148.                     }  
  149.                 }  
  150.                 else if(yg == 0)  
  151.                 {  
  152.                     magnitudes[index]=0;  
  153.                 }  
  154.                 else  
  155.                 {  
  156.                     magnitudes[index] = (float)((Math.atan(yg/xg) * 180)/Math.PI);                    
  157.                 }  
  158.                 // make it 0 ~ 180  
  159.                 magnitudes[index] += 90;  
  160.             }  
  161.         }  
  162.           
  163.         // 非最大信號壓制算法 3x3  
  164.         Arrays.fill(magnitudes, 0);  
  165.         for (int row = 0; row < height; row++) {  
  166.             for (int col = 0; col < width; col++) {  
  167.                 index = row * width + col;  
  168.                 float angle = magnitudes[index];  
  169.                 float m0 = data[index];  
  170.                 magnitudes[index] = m0;  
  171.                 if(angle >=0 && angle < 22.5) // angle 0  
  172.                 {  
  173.                     float m1 = getPixel(data, width, height, col-1, row);  
  174.                     float m2 = getPixel(data, width, height, col+1, row);  
  175.                     if(m0 < m1 || m0 < m2)  
  176.                     {  
  177.                         magnitudes[index] = 0;  
  178.                     }  
  179.                 }  
  180.                 else if(angle >= 22.5 && angle < 67.5) // angle +45  
  181.                 {  
  182.                     float m1 = getPixel(data, width, height, col+1, row-1);  
  183.                     float m2 = getPixel(data, width, height, col-1, row+1);  
  184.                     if(m0 < m1 || m0 < m2)  
  185.                     {  
  186.                         magnitudes[index] = 0;  
  187.                     }  
  188.                 }  
  189.                 else if(angle >= 67.5 && angle < 112.5) // angle 90  
  190.                 {  
  191.                     float m1 = getPixel(data, width, height, col, row+1);  
  192.                     float m2 = getPixel(data, width, height, col, row-1);  
  193.                     if(m0 < m1 || m0 < m2)  
  194.                     {  
  195.                         magnitudes[index] = 0;  
  196.                     }  
  197.                 }  
  198.                 else if(angle >=112.5 && angle < 157.5) // angle 135 / -45  
  199.                 {  
  200.                     float m1 = getPixel(data, width, height, col-1, row-1);  
  201.                     float m2 = getPixel(data, width, height, col+1, row+1);  
  202.                     if(m0 < m1 || m0 < m2)  
  203.                     {  
  204.                         magnitudes[index] = 0;  
  205.                     }  
  206.                 }  
  207.                 else if(angle >=157.5) // angle 0  
  208.                 {  
  209.                     float m1 = getPixel(data, width, height, col, row+1);  
  210.                     float m2 = getPixel(data, width, height, col, row-1);  
  211.                     if(m0 < m1 || m0 < m2)  
  212.                     {  
  213.                         magnitudes[index] = 0;  
  214.                     }  
  215.                 }  
  216.             }  
  217.         }  
  218.         // 尋找最大與最小值  
  219.         float min = 255;  
  220.         float max = 0;  
  221.         for(int i=0; i<magnitudes.length; i++)  
  222.         {  
  223.             if(magnitudes[i] == 0) continue;  
  224.             min = Math.min(min, magnitudes[i]);  
  225.             max = Math.max(max, magnitudes[i]);  
  226.         }  
  227.         System.out.println("Image Max Gradient = " + max + " Mix Gradient = " + min);  
  228.   
  229.         // 通常比值為 TL : TH = 1 : 3， 根據兩個閾值完成二值化邊緣連接  
  230.         // 邊緣連接-link edges  
  231.         Arrays.fill(data, 0);  
  232.         int offset = 0;  
  233.         for (int row = 0; row < height; row++) {  
  234.             for (int col = 0; col < width; col++) {  
  235.                 if(magnitudes[offset] >= highThreshold && data[offset] == 0)  
  236.                 {  
  237.                     edgeLink(col, row, offset, lowThreshold);  
  238.                 }  
  239.                 offset++;  
  240.             }  
  241.         }  
  242.           
  243.         // 二值化顯示  
  244.         for(int i=0; i<inPixels.length; i++)  
  245.         {  
  246.             int gray = clamp((int)data[i]);  
  247.             outPixels[i] = gray > 0 ? -1 : 0xff000000;       
  248.         }  
  249.         setRGB(dest, 0, 0, width, height, outPixels );  
  250.         return dest;  
  251.     }  
  252.       
  253.     public int clamp(int value) {  
  254.         return value > 255 ? 255 :  
  255.             (value < 0 ? 0 : value);  
  256.     }  
  257.       
  258.     private void edgeLink(int x1, int y1, int index, float threshold) {  
  259.         int x0 = (x1 == 0) ? x1 : x1 - 1;  
  260.         int x2 = (x1 == width - 1) ? x1 : x1 + 1;  
  261.         int y0 = y1 == 0 ? y1 : y1 - 1;  
  262.         int y2 = y1 == height -1 ? y1 : y1 + 1;  
  263.           
  264.         data[index] = magnitudes[index];  
  265.         for (int x = x0; x <= x2; x++) {  
  266.             for (int y = y0; y <= y2; y++) {  
  267.                 int i2 = x + y * width;  
  268.                 if ((y != y1 || x != x1)  
  269.                     && data[i2] == 0   
  270.                     && magnitudes[i2] >= threshold) {  
  271.                     edgeLink(x, y, i2, threshold);  
  272.                     return;  
  273.                 }  
  274.             }  
  275.         }  
  276.     }  
  277.       
  278.     private float getPixel(float[] input, int width, int height, int col,  
  279.             int row) {  
  280.         if(col < 0 || col >= width)  
  281.             col = 0;  
  282.         if(row < 0 || row >= height)  
  283.             row = 0;  
  284.         int index = row * width + col;  
  285.         return input[index];  
  286.     }  
  287.       
  288.     private float hypot(float x, float y) {  
  289.         return (float) Math.hypot(x, y);  
  290.     }  
  291.       
  292.     private int getPixel(int[] inPixels, int width, int height, int col,  
  293.             int row) {  
  294.         if(col < 0 || col >= width)  
  295.             col = 0;  
  296.         if(row < 0 || row >= height)  
  297.             row = 0;  
  298.         int index = row * width + col;  
  299.         return inPixels[index];  
  300.     }  
  301.       
  302.     private float gaussian(float x, float y, float sigma) {  
  303.         float xDistance = x*x;  
  304.         float yDistance = y*y;  
  305.         float sigma22 = 2*sigma*sigma;  
  306.         float sigma22PI = (float)Math.PI * sigma22;  
  307.         return (float)Math.exp(-(xDistance + yDistance)/sigma22)/sigma22PI;  
  308.     }  
  309.   
  310. }  

轉載請務必注明出自本博客-gloomyfish


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 圖像處理之邊緣檢測概述 Canny邊緣檢測 數字圖像處理-邊緣檢測 MATLAB Canny邊緣檢測 Canny高低閾值邊緣檢測 opencv::Canny邊緣檢測 8. matlab圖像處理基礎——邊緣檢測+形態學變換+圖像增強 c語言數字圖像處理（九）：邊緣檢測 matlab-圖像處理-邊緣檢測算法五種 學習筆記-canny邊緣檢測
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM