canny算法的实现（android加载图片，数组写入文件换行）
Canny边缘检测首先要对图像进行高斯去噪，前面讲到了高斯去噪处理，这里从对图像灰度进行微分运算讲起吧。微分运算常用的方法是利用模板算子，把模板中心对应到图像的每一个像素位置，然后按照模板对应的公式对中心像素和它周围的像素进行数学运算，算出图像对应像素点的值实验中模板矩阵选取了Laplacian算子[44]、Soble算子、Roberts算子。拉普拉兹算子是2阶微分算子，它的精度还算比较高，但对噪声过于敏感，有噪声的情况下效果很差。罗伯特算子在光照不均匀时候效果也很差，针对噪声影响也较为敏感。下面以较为简单的模板作为样例做出讲解：
1、计算x和y方向的梯度值从而得到灰度的梯度幅值和梯度方向
Gx=(hd[x][y+1]-hd[x][y]+hd[x+1][y+1]-hd[x+1][y])/2;
Gy=(hd[x][y]-hd[x+1][y]+hd[x][y+1]-hd[x+1][y+1])/2;
G[x][y]=(int)Math.sqrt(Gy*Gy+Gx*Gx);
angle[x][y]=Math.atan2(Gy,Gx);
2、高低阈值的选取。通常canny算子的高阈值Th和低阈值Tl的0.4，Tl=0.4*Th，而高阈值根据二值化的目的选择不同的值，先验知识通常Th选择方式：梯度幅值矩阵统计在梯度值，将所有梯度累加求和，取在q%(q%在0.75-0.85之间)的那个振幅值作为高阈值。
3、非极大值抑制，这是边缘检测的关键，是将区域内的梯度振幅值的极值当作边缘点，如下图：
对整个梯度振幅图扫描，如图若（x,y）的点大于dTmp1点和dTmp2的振幅则将（x,y）视为预选边缘点，将起值置为255。由图可以看出dTmp1点振幅值可以G(g1) + (1-cot（sigma）) *（G(g2)-G(g1)）同理可以得到dTmp2点的梯度振幅值。G这样得到一个预选边缘点矩阵：
int [][] mayEdgeMatrix = getMaxmaiLimitMatrix(Gxy,angle);
4、扫描mayEdgeMatrix里所有预选边缘点，将梯度振幅大于等于Th的则视为边缘点置为255；将低于Tl的直接置为0，视为非边缘点；介于Tl、Th之间的的置为125，视为待检测点。这样得到了一个初步的边缘图点。
5、边缘连接，对上一部得到的图像进行扫描，将255周围的8领域点进行检测，若有为125的视为边缘点，置为255，再以这些新置为255的点8领域查找待检测点，若有就将其置为255，直到没有新的边缘点产生为止。
下面给出实现的类,在下面会给出调用的方法和相应的activity
package com.example.lammy.imagetest; import android.graphics.Bitmap; import java.util.LinkedList; /** * Created by Lammy on 2016/11/12. */ public class MyCanny { private int Th; private int Tl; private float ratioOfTh; private Bitmap bitmap; private int h, w; private int[][] Gxy; private double[][] angle; private static int mayEdgePointGrayValue = 125; public MyCanny(Bitmap bitmap, float ratioOfTh) { this.bitmap = bitmap; this.ratioOfTh = ratioOfTh; init(); } private void init() { h = bitmap.getHeight(); w = bitmap.getWidth(); Gxy = new int[h][w]; angle = new double[h][w]; } //得到高斯模板矩阵 public float[][] get2DKernalData(int n, float sigma) { int size = 2 * n + 1; float sigma22 = 2 * sigma * sigma; float sigma22PI = (float) Math.PI * sigma22; float[][] kernalData = new float[size][size]; int row = 0; for (int i = -n; i <= n; i++) { int column = 0; for (int j = -n; j <= n; j++) { float xDistance = i * i; float yDistance = j * j; kernalData[row][column] = (float) Math .exp(-(xDistance + yDistance) / sigma22) / sigma22PI; column++; } row++; } return kernalData; } //获得图的灰度矩阵 public int[][] getGrayMatrix(Bitmap bitmap) { int h = bitmap.getHeight(); int w = bitmap.getWidth(); int grayMatrix[][] = new int[h][w]; for (int i = 0; i < h; i++) for (int j = 0; j < w; j++) { int argb = bitmap.getPixel(j, i); int r = (argb >> 16) & 0xFF; int g = (argb >> 8) & 0xFF; int b = (argb >> 0) & 0xFF; int grayPixel = (int) (r + g + b) / 3; grayMatrix[i][j] = grayPixel; } return grayMatrix; } //获得高斯模糊后的灰度矩阵 public int[][] GS(int[][] hd, int size, float sigma) { float[][] gs = get2DKernalData(size, sigma); int outmax = 0; int inmax = 0; for (int x = size; x < w - size; x++) for (int y = size; y < h - size; y++) { float hc1 = 0; if (hd[y][x] > inmax) inmax = hd[y][x]; for (int k = -size; k < size + 1; k++) for (int j = -size; j < size + 1; j++) { hc1 = gs[size + k][j + size] * hd[y + j][x + k] + hc1; } hd[y][x] = (int) (hc1); if (outmax < hc1) outmax = (int) (hc1); } float rate = inmax / outmax; for (int x = size; x < w - size; x++) for (int y = size; y < h - size; y++) { hd[y][x] = (int) (hd[y][x] * rate); } return hd; } //获得Gxy 和angle即梯度振幅和梯度方向 public void getGxyAndAngle(int[][] Gs) { for (int x = 1; x < h - 1; x++) for (int y = 1; y < w - 1; y++) { int Gx = (Gs[x][y + 1] - Gs[x][y] + Gs[x + 1][y + 1] - Gs[x + 1][y]) / 2;//hd[x][y+1]-hd[x][y];// int Gy = (Gs[x][y] - Gs[x + 1][y] + Gs[x][y + 1] - Gs[x + 1][y + 1]) / 2;//hd[x+1][y]-hd[x][y];// //另外一种算子 // int Gx = (Gs[x - 1][y + 1] + 2 * Gs[x][y + 1] // + Gs[x + 1][y + 1] - Gs[x - 1][y - 1] - 2 // * Gs[x][y - 1] - Gs[x + 1][y - 1]) / 4; // int Gy=(Gs[x-1][y-1]+2*Gs[x-1][y]+Gs[x-1][y+1]-Gs[x+1][y-1]-2*Gs[x+1][y]-Gs[x+1][y+1])/4; //G[x][y]=Math.sqrt(Math.pow(Gx, 2)+Math.pow(Gy, 2)); Gxy[x][y] = (int) Math.sqrt(Gy * Gy + Gx * Gx); angle[x][y] = Math.atan2(Gy, Gx); //将梯度方向值转向(0,2*PI) if (angle[x][y] < 0) { angle[x][y] = angle[x][y] + 2 * Math.PI; } } } //非极大值抑制,将极值点存到edge边缘矩阵中,极值点是可能为边缘的点 public int[][] getMaxmaiLimitMatrix(int[][]Gxy,double[][]angle) { int[][] edge =new int[h][w]; for (int x = 0; x < h - 1; x++) for (int y = 0; y < w - 1; y++) { double angle1 = angle[x][y] / (Math.PI); if ((angle1 > 0 && angle1 <= 0.25) | (angle1 > 1 && angle1 <= 1.25)) { double dTmp1 = Gxy[x][y + 1] + Math.abs(Math.tan(angle[x][y]) * (Gxy[x - 1][y + 1] - Gxy[x][y + 1])); double dTmp2 = Gxy[x][y - 1] + Math.abs(Math.tan(angle[x][y]) * (Gxy[x + 1][y - 1] - Gxy[x][y - 1])); double dTmp = Gxy[x][y]; if (dTmp > dTmp1 && dTmp > dTmp2) edge[x][y] = 255; } if ((angle1 <= 2 && angle1 > 1.75) | (angle1 <= 1 && angle1 > 0.75)) { double dTmp1 = Gxy[x][y + 1] + Math.abs(Math.tan(angle[x][y])) * (Gxy[x + 1][y + 1] - Gxy[x][y + 1]); double dTmp2 = Gxy[x][y - 1] + Math.abs(Math.tan(angle[x][y])) * (Gxy[x - 1][y - 1] - Gxy[x][y - 1]); double dTmp = Gxy[x][y]; if (dTmp > dTmp1 && dTmp > dTmp2) edge[x][y] = 255; } if ((angle1 > 1 / 4 && angle1 <= 0.5) | (angle1 > 5 / 4 && angle1 <= 1.5)) { double dTmp1 = Gxy[x - 1][y] + Math.abs(1 / Math.tan(angle[x][y])) * (Gxy[x - 1][y + 1] - Gxy[x - 1][y]); double dTmp2 = Gxy[x + 1][y] + Math.abs(1 / Math.tan(angle[x][y])) * (Gxy[x + 1][y - 1] - Gxy[x + 1][y]); double dTmp = Gxy[x][y]; if (dTmp > dTmp1 && dTmp > dTmp2) edge[x][y] = 255; } if ((angle1 > 1.5 && angle1 <= 1.75) | (angle1 > 0.5 && angle1 <= 0.75)) { double dTmp1 = Gxy[x - 1][y] + Math.abs(1 / Math.tan(angle[x][y])) * (Gxy[x - 1][y - 1] - Gxy[x - 1][y]); double dTmp2 = Gxy[x + 1][y] + Math.abs(1 / Math.tan(angle[x][y])) * (Gxy[x + 1][y + 1] - Gxy[x + 1][y]); double dTmp = Gxy[x][y]; if (dTmp > dTmp1 && dTmp > dTmp2) edge[x][y] = 255; } } return edge; } public void ThTlLimitPoints(int [][] maxmaiLimitMatrix,int Th , int Tl) { //上面得到的为255的才可能是边缘点，下面根据高低阈值再次去掉小于Tl点，高于Th的仍然为255，定为边缘点，125的为预选点 for(int x=1;x<h-1;x++) for(int y=1;y<w-1;y++) { if(maxmaiLimitMatrix[x][y]==255) { if(Gxy[x][y]<Tl) maxmaiLimitMatrix[x][y]=0; if(Gxy[x][y]>Tl&&Gxy[x][y]<Th) maxmaiLimitMatrix[x][y]=mayEdgePointGrayValue; } } } //获得高阈值 private int getTh(int [][] Gxy) { //梯度振幅统计，因为通过计算振幅的最大值不超过500，因此用500的矩阵统计 int []amplitudeStatistics=new int[500]; for(int x=1;x<h-1;x++) for(int y=1;y<w-1;y++){ amplitudeStatistics[Gxy[x][y]]++; } int pointNumber=0; int max=0; for(int i=1;i<500;i++){ if(amplitudeStatistics[i]>0) { max=i; } pointNumber=pointNumber+amplitudeStatistics[i]; } int ThNumber=(int)(ratioOfTh*pointNumber); int ThCount=0; int Th=0; for(int i=1;i<=max;i++) { if(ThCount<ThNumber) ThCount=ThCount+amplitudeStatistics[i]; else { Th=i-1; break; } } return Th; } private int getTl(int Th) { return (int)(Th*0.4); } //canny算法的边缘连接 public void traceEdge(double maybeEdgePointGrayValue, int edge[][]){ int [][]liantongbiaoji = new int [h][w]; for(int i = 0 ; i < h ; i++) for(int j = 0 ; j < w; j++) { if(edge[i][j]==255&&liantongbiaoji[i][j]==0) { if ((edge[i][j] >= maybeEdgePointGrayValue) && liantongbiaoji[i][j] == 0) { liantongbiaoji[i][j] = 1; LinkedList<Point> qu = new LinkedList<Point>(); qu.add(new Point(i, j)); while (!qu.isEmpty()) { Point cur = qu.removeFirst(); for (int a = -1; a <= 1; a++) for (int b = -1; b <= 1; b++) { if (cur.x + a >= 0 && cur.x + a < h && cur.y + b >= 0 && cur.y + b < w) { if (edge[cur.x + a][cur.y + b] >= maybeEdgePointGrayValue && liantongbiaoji[cur.x + a][cur.y + b] == 0) { qu.add(new Point(cur.x + a, cur.y + b)); liantongbiaoji[cur.x + a][cur.y + b] = 1; edge[cur.x + a][cur.y + b] = 255; } } } } } } } } //由灰度矩阵创建灰度图 public Bitmap createGrayImage(int[][]grayMatrix) { int h=grayMatrix.length; int w = grayMatrix[0].length; Bitmap bt=Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888); for(int i=0;i<h;i++) for(int j=0;j<w;j++) { int grayValue=grayMatrix[i][j]; int color = ((0xFF << 24)+(grayValue << 16)+(grayValue << 8)+grayValue); bt.setPixel(j, i, color); } return bt; } public Bitmap getEdgeBitmap() { int grayMatrix[][] = getGrayMatrix(bitmap); int GS[][] = GS(grayMatrix , 1 , 0.6f); getGxyAndAngle(GS); Th = getTh(Gxy); int [][] mayEdgeMatrix = getMaxmaiLimitMatrix(Gxy,angle); Tl = getTl(Th); ThTlLimitPoints(mayEdgeMatrix , Th , Tl); traceEdge(mayEdgePointGrayValue , mayEdgeMatrix); for(int x=1;x<h-1;x++) for(int y=1;y<w-1;y++) { if(mayEdgeMatrix[x][y]!=255) mayEdgeMatrix[x][y]=0; } return createGrayImage(mayEdgeMatrix); } class Point { Point(int a, int b) { this.x = a; this.y = b; } int x; int y; } }
实现了上述算法移植到手机，发现在java平台上实现后运行效果非常好，而运行在手机端上效果很差。同样的算法为何结果相差如此之大呢？
经过一步步的排查，将每一步得到的数组打印到文件与java打印的数组比较，最终发现了原因，罪魁祸首就是安卓加载jpg、png甚至是bitmap到内存时图片的宽高都会变大，且比率不一定相同，这样导致我加载同一张图片时，android自动对图片进行了放大，导致手机的边缘更加模糊且无故增加了一些细节。为了解决这个问问题，我先获取未加载时候图片的宽高，在加载图片后再压缩回加载前图片的大小。 在acitiviy里有讲解，下面直接贴出代码：
package com.example.lammy.imagetest; import android.content.ContentResolver; import android.content.Context; import android.content.Intent; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Matrix; import android.media.ThumbnailUtils; import android.net.Uri; import android.os.Environment; import android.provider.MediaStore; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.util.DisplayMetrics; import android.view.View; import android.widget.ImageView; import android.widget.Toast; import java.io.BufferedOutputStream; import java.io.BufferedWriter; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.FileWriter; import java.io.InputStream; import java.io.Writer; public class MainActivity extends AppCompatActivity { ImageView imageView; Bitmap bt; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); imageView = (ImageView) findViewById(R.id.image); int scr =R.drawable.xl; //获取源图像的宽和高（因为android在加载图片到手机里的时候会使得图片宽高变大,且比率不一定一样，为了让其不变形必须记下加载前的图片宽高）再压缩回去 BitmapFactory.Options options=new BitmapFactory.Options(); options.inJustDecodeBounds=true;//(设为true 图片不加入内存效率高) BitmapFactory.decodeResource(getResources(),scr , options); int outWidth = options.outWidth; int outHeight = options.outHeight; System.out.println("jpg图原图"+outHeight+","+outWidth); options.inJustDecodeBounds=false; bt = BitmapFactory.decodeResource(getResources(),scr ); System.out.println("加载后图："+bt.getHeight()+","+bt.getWidth()); //将图片压缩到加载前的宽高，当然图片太大也可以宽高同比率压缩。 bt = ThumbnailUtils.extractThumbnail(bt,outWidth,outHeight); imageView.setImageBitmap(bt); // jpg图原图271,482 // 加载后图：711,1265 } public void click(View view) { MyCanny myCanny =new MyCanny(bt,0.85f); int Gs [][] =myCanny.GS(myCanny.getGrayMatrix(bt) , 1 , 0.6f); try { outPutArray(Gs ,"grayMatrix.txt"); } catch (Exception e) { e.printStackTrace(); } Bitmap edge = myCanny.getEdgeBitmap(); edge = ThumbnailUtils.extractThumbnail(edge,1000,600); imageView.setImageBitmap(edge); } // 将数组写入到data目录 public void outPutArray(int[] [] a ,String filename) throws Exception { try { File file = new File("data/data/com.example.lammy.imagetest/files/"+filename); FileWriter fileWriter = new FileWriter(file); BufferedWriter bw=new BufferedWriter(fileWriter); int size = 15; for(int i = 0 ; i < size ; i ++) { for (int j = 0; j < size; j++) { String s = a[i][j] + " "; bw.write(s); bw.flush(); } bw.newLine(); bw.flush(); } bw.flush(); bw.close(); }catch (Exception e){ System.out.println("mmmmmmmmmmmmmmmmmmmmm"); } } }
打印了一下加载图前后的大小：
jpg图原图271,482
加载后图：711,1265
发现加载到内存后放大了2.6倍左右（原因：decodeResource这个方法会根据drawable所在的资源目录适配不同的dpi，因此放大了），且为了适应手机屏幕的分辨率，宽高放大的比率不相等（相近），这导致了我们算法的效果变差的主要原因，因此我将图像压缩回加载前的大小，再使用canny算法边缘检测，效果就和java的差不多了。下面是效果：
原图的灰度图 边缘图
