欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Java实现Canny算子边缘提取

程序员文章站 2022-07-14 11:57:06
...

如下代码:

import java.util.Arrays;

import javafx.scene.image.PixelReader;
import javafx.scene.image.PixelWriter;
import javafx.scene.image.WritableImage;

public class Canny {
    private float gaussianKernelRadius = 2f;  
    private int gaussianKernelWidth = 16;  
    private float lowThreshold = 2.5f;  
    private float highThreshold = 7.5f;  
    // image width, height  
    private int width;  
    private int height;  
    private float[] data;  
    private float[] magnitudes;

    //传入被处理图片,返回边缘提取效果图
    public WritableImage filter(WritableImage src) {  
        width = (int) src.getWidth();  
        height = (int) src.getHeight(); 

        WritableImage outImage = new WritableImage(width,height);

        // 图像灰度化  
        int[] inPixels = new int[width * height];  
        int[] outPixels = new int[width * height];  
        getRGB(src, width, height, inPixels);  
        int index = 0;  
        for (int row = 0; row < height; row++) {  
            int ta = 0, tr = 0, tg = 0, tb = 0;  
            for (int col = 0; col < width; col++) {  
                index = row * width + col;  
                ta = (inPixels[index] >> 24) & 0xff;  
                tr = (inPixels[index] >> 16) & 0xff;  
                tg = (inPixels[index] >> 8) & 0xff;  
                tb = inPixels[index] & 0xff;  
                int gray = (int) (0.299 * tr + 0.587 * tg + 0.114 * tb);  
                inPixels[index] = (ta << 24) | (gray << 16) | (gray << 8)  
                        | gray;  
            }  
        }  

        // 计算高斯卷积核  
        float kernel[][] = new float[gaussianKernelWidth][gaussianKernelWidth];  
        for(int x=0; x<gaussianKernelWidth; x++)  
        {  
            for(int y=0; y<gaussianKernelWidth; y++)  
            {  
                kernel[x][y] = gaussian(x, y, gaussianKernelRadius);  
            }  
        }  
        // 高斯模糊 -灰度图像  
        int krr = (int)gaussianKernelRadius;  
        for (int row = 0; row < height; row++) {  
            for (int col = 0; col < width; col++) {  
                index = row * width + col;  
                double weightSum = 0.0;  
                double redSum = 0;  
                for(int subRow=-krr; subRow<=krr; subRow++)  
                {  
                    int nrow = row + subRow;  
                    if(nrow >= height || nrow < 0)  
                    {  
                        nrow = 0;  
                    }  
                    for(int subCol=-krr; subCol<=krr; subCol++)  
                    {  
                        int ncol = col + subCol;  
                        if(ncol >= width || ncol <=0)  
                        {  
                            ncol = 0;  
                        }  
                        int index2 = nrow * width + ncol;  
                        int tr1 = (inPixels[index2] >> 16) & 0xff;  
                        redSum += tr1*kernel[subRow+krr][subCol+krr];  
                        weightSum += kernel[subRow+krr][subCol+krr];  
                    }  
                }  
                int gray = (int)(redSum / weightSum);  
                outPixels[index] = gray;  
            }  
        }  

        // 计算梯度-gradient, X放与Y方向  
        data = new float[width * height];  
        magnitudes = new float[width * height];  
        for (int row = 0; row < height; row++) {  
            for (int col = 0; col < width; col++) {  
                index = row * width + col;  
                // 计算X方向梯度  
                float xg = (getPixel(outPixels, width, height, col, row+1) -   
                        getPixel(outPixels, width, height, col, row) +   
                        getPixel(outPixels, width, height, col+1, row+1) -  
                        getPixel(outPixels, width, height, col+1, row))/2.0f;  
                float yg = (getPixel(outPixels, width, height, col, row)-  
                        getPixel(outPixels, width, height, col+1, row) +  
                        getPixel(outPixels, width, height, col, row+1) -  
                        getPixel(outPixels, width, height, col+1, row+1))/2.0f;  
                // 计算振幅与角度  
                data[index] = hypot(xg, yg);  
                if(xg == 0)  
                {  
                    if(yg > 0)  
                    {  
                        magnitudes[index]=90;                         
                    }  
                    if(yg < 0)  
                    {  
                        magnitudes[index]=-90;  
                    }  
                }  
                else if(yg == 0)  
                {  
                    magnitudes[index]=0;  
                }  
                else  
                {  
                    magnitudes[index] = (float)((Math.atan(yg/xg) * 180)/Math.PI);                    
                }  
                // make it 0 ~ 180  
                magnitudes[index] += 90;  
            }  
        }  

        // 非最大信号压制算法 3x3  
        Arrays.fill(magnitudes, 0);  

        for (int row = 0; row < height; row++) {  
            for (int col = 0; col < width; col++) {  
                index = row * width + col;  
                float angle = magnitudes[index];  
                float m0 = data[index];  
                magnitudes[index] = m0;  
                if(angle >=0 && angle < 22.5) // angle 0  
                {  
                    float m1 = getPixel(data, width, height, col-1, row);  
                    float m2 = getPixel(data, width, height, col+1, row);  
                    if(m0 < m1 || m0 < m2)  
                    {  
                        magnitudes[index] = 0;  
                    }  
                }  
                else if(angle >= 22.5 && angle < 67.5) // angle +45  
                {  
                    float m1 = getPixel(data, width, height, col+1, row-1);  
                    float m2 = getPixel(data, width, height, col-1, row+1);  
                    if(m0 < m1 || m0 < m2)  
                    {  
                        magnitudes[index] = 0;  
                    }  
                }  
                else if(angle >= 67.5 && angle < 112.5) // angle 90  
                {  
                    float m1 = getPixel(data, width, height, col, row+1);  
                    float m2 = getPixel(data, width, height, col, row-1);  
                    if(m0 < m1 || m0 < m2)  
                    {  
                        magnitudes[index] = 0;  
                    }  
                }  
                else if(angle >=112.5 && angle < 157.5) // angle 135 / -45  
                {  
                    float m1 = getPixel(data, width, height, col-1, row-1);  
                    float m2 = getPixel(data, width, height, col+1, row+1);  
                    if(m0 < m1 || m0 < m2)  
                    {  
                        magnitudes[index] = 0;  
                    }  
                }  
                else if(angle >=157.5) // angle 0  
                {  
                    float m1 = getPixel(data, width, height, col, row+1);  
                    float m2 = getPixel(data, width, height, col, row-1);  
                    if(m0 < m1 || m0 < m2)  
                    {  
                        magnitudes[index] = 0;  
                    }  
                }  
            }  
        }  
        // 寻找最大与最小值  
        float min = 255;  
        float max = 0;  
        for(int i=0; i<magnitudes.length; i++)  
        {  
            if(magnitudes[i] == 0) continue;  
            min = Math.min(min, magnitudes[i]);  
            max = Math.max(max, magnitudes[i]);  
        }  
        System.out.println("Image Max Gradient = " + max + " Mix Gradient = " + min);  

        // 通常比值为 TL : TH = 1 : 3, 根据两个阈值完成二值化边缘连接  
        // 边缘连接-link edges  
        Arrays.fill(data, 0); 

        int offset = 0;  
        for (int row = 0; row < height; row++) {  
            for (int col = 0; col < width; col++) {  
                if(magnitudes[offset] >= highThreshold && data[offset] == 0)  
                {  
                    edgeLink(col, row, offset, lowThreshold);  
                }  
                offset++;  
            }  
        }  

        // 二值化显示  
        for(int i=0; i<inPixels.length; i++)  
        {  
            int gray = clamp((int)data[i]);  
            outPixels[i] = gray > 0 ? -1 : 0xff000000;       
        }  

        PixelWriter pixel = outImage.getPixelWriter();

        for(int i=0;i<height;i++) {
            for(int j=0;j<width;j++) {
                pixel.setArgb(j, i, outPixels[i*width+j]);
            }
        }
        return outImage;  
    }  

    public int clamp(int value) {  
        return value > 255 ? 255 :  
            (value < 0 ? 0 : value);  
    }  

    private void edgeLink(int x1, int y1, int index, float threshold) {  
        int x0 = (x1 == 0) ? x1 : x1 - 1;  
        int x2 = (x1 == width - 1) ? x1 : x1 + 1;  
        int y0 = y1 == 0 ? y1 : y1 - 1;  
        int y2 = y1 == height -1 ? y1 : y1 + 1;  

        data[index] = magnitudes[index];  
        for (int x = x0; x <= x2; x++) {  
            for (int y = y0; y <= y2; y++) {  
                int i2 = x + y * width;  
                if ((y != y1 || x != x1)  
                    && data[i2] == 0   
                    && magnitudes[i2] >= threshold) {  
                    edgeLink(x, y, i2, threshold);  
                    return;  
                }  
            }  
        }  
    }  

    private float getPixel(float[] input, int width, int height, int col,  
            int row) {  
        if(col < 0 || col >= width)  
            col = 0;  
        if(row < 0 || row >= height)  
            row = 0;  
        int index = row * width + col;  
        return input[index];  
    }  

    private float hypot(float x, float y) {  
        return (float) Math.hypot(x, y);  
    }  

    private int getPixel(int[] inPixels, int width, int height, int col,  
            int row) {  
        if(col < 0 || col >= width)  
            col = 0;  
        if(row < 0 || row >= height)  
            row = 0;  
        int index = row * width + col;  
        return inPixels[index];  
    }  

    private float gaussian(float x, float y, float sigma) {  
        float xDistance = x*x;  
        float yDistance = y*y;  
        float sigma22 = 2*sigma*sigma;  
        float sigma22PI = (float)Math.PI * sigma22;  
        return (float)Math.exp(-(xDistance + yDistance)/sigma22)/sigma22PI;  
    }  

    private void getRGB(WritableImage image, int width, int height, int[] inPixel) {
        PixelReader reader = image.getPixelReader();
        for(int i=0;i<height;i++) {
            for(int j=0;j<width;j++) {
                inPixel[i*width+j] = reader.getArgb(j, i);
            }
        }
    }
}

效果如下:
Java实现Canny算子边缘提取
原文使用 BeferBufferedImage 类处理。本文更改至FX下Image,PixelReader。。。等类处理。

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