目标

在本教程中，您将学习如何

使用 OpenCV 函数 cv::Canny 来实现 Canny 边缘检测器。

理论

Canny 边缘检测器 [49] 由 John F. Canny 于 1986 年开发。Canny 算法也被许多人称为最优检测器，旨在满足三个主要标准：

低错误率： 意味着只检测到实际存在的边缘。
良好的定位： 检测到的边缘像素与真实边缘像素之间的距离必须最小化。
最小响应： 每条边缘只有一个检测器响应。

步骤

滤除噪声。高斯滤波器用于此目的。下面显示了一个可能使用的 \(size = 5\) 的高斯核示例：

\[K = \dfrac{1}{159}\begin{bmatrix} 2 & 4 & 5 & 4 & 2 \\ 4 & 9 & 12 & 9 & 4 \\ 5 & 12 & 15 & 12 & 5 \\ 4 & 9 & 12 & 9 & 4 \\ 2 & 4 & 5 & 4 & 2 \end{bmatrix}\]
找到图像的强度梯度。为此，我们遵循类似于 Sobel 的步骤：
1. 应用一对卷积核（在 \(x\) 和 \(y\) 方向）：
  \[G_{x} = \begin{bmatrix} -1 & 0 & +1 \\ -2 & 0 & +2 \\ -1 & 0 & +1 \end{bmatrix}\]
  
  \[G_{y} = \begin{bmatrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ +1 & +2 & +1 \end{bmatrix}\]
2. 用以下公式找到梯度强度和方向：
  \[\begin{array}{l} G = \sqrt{ G_{x}^{2} + G_{y}^{2} } \\ \theta = \arctan(\dfrac{ G_{y} }{ G_{x} }) \end{array}\]
  方向被四舍五入到四个可能的角度之一（即 0、45、90 或 135 度）。
应用非极大值抑制。这会移除不被认为是边缘一部分的像素。因此，只剩下细线（候选边缘）。
滞后阈值：最后一步。Canny 使用两个阈值（高阈值和低阈值）：
1. 如果像素梯度高于高阈值，则该像素被接受为边缘。
2. 如果像素梯度值低于低阈值，则被拒绝。
3. 如果像素梯度介于两个阈值之间，则只有当它连接到高于高阈值的像素时才会被接受。
Canny 建议高阈值与低阈值的比率在 2:1 到 3:1 之间。
更多细节，您可以查阅您喜欢的计算机视觉书籍。

代码

教程代码如下所示。您也可以从此处下载。

#include "opencv2/imgproc.hpp"

#include "opencv2/highgui.hpp"

#include <iostream>

using namespace cv;

Mat src, src_gray;

Mat dst, detected_edges;

int lowThreshold = 0;

const int max_lowThreshold = 100;

const int ratio = 3;

const int kernel_size = 3;

const char* window_name = "Edge Map";

static void CannyThreshold(int, void*)

{

blur( src_gray, detected_edges, Size(3,3) );

Canny( detected_edges, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size );

dst = Scalar::all(0);

src.copyTo( dst, detected_edges);

imshow( window_name, dst );

}

int main( int argc, char** argv )

{

CommandLineParser parser( argc, argv, "{@input | fruits.jpg | input image}" );

src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR ); // Load an image

if( src.empty() )

{

std::cout << "Could not open or find the image!\n" << std::endl;

std::cout << "Usage: " << argv[0] << " <Input image>" << std::endl;

return -1;

}

dst.create( src.size(), src.type() );

cvtColor( src, src_gray, COLOR_BGR2GRAY );

namedWindow( window_name, WINDOW_AUTOSIZE );

createTrackbar( "Min Threshold:", window_name, &lowThreshold, max_lowThreshold, CannyThreshold );

CannyThreshold(0, 0);

waitKey(0);

return 0;

}

bool empty() const
如果数组没有元素，则返回 true。
int64_t int64

cv::Mat
n 维密集数组类
定义 mat.hpp:830

cv::Mat::size
MatSize size
定义 mat.hpp:2187

cv::Mat::copyTo
void copyTo(OutputArray m) const
将矩阵复制到另一个矩阵。

cv::Mat::create
void create(int rows, int cols, int type)
如果需要，分配新的数组数据。

定义 interface.h:61
cv::getTickFrequency
double getTickFrequency()

cv::Mat::type
int type() const
返回矩阵元素的类型。

cv::Size_
用于指定图像或矩形大小的模板类。
Definition types.hpp:335

cv::String
std::string String
定义 cvstd.hpp:151

highgui.hpp

main
int main(int argc, char *argv[])
定义 highgui_qt.cpp:3

imgproc.hpp

cv
定义 core.hpp:107

教程代码如下所示。您也可以从此处下载。
import java.awt.BorderLayout;

import java.awt.Container;

import java.awt.Image;

import javax.swing.BoxLayout;

import javax.swing.ImageIcon;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JSlider;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import org.opencv.core.Core;

import org.opencv.core.CvType;

import org.opencv.core.Mat;

import org.opencv.core.Scalar;

import org.opencv.core.Size;

import org.opencv.highgui.HighGui;

import org.opencv.imgcodecs.Imgcodecs;

import org.opencv.imgproc.Imgproc;

public class CannyDetectorDemo {

private static final int MAX_LOW_THRESHOLD = 100;

private static final int RATIO = 3;

private static final int KERNEL_SIZE = 3;

private static final Size BLUR_SIZE = new Size(3,3);

private int lowThresh = 0;

private Mat src;

private Mat srcBlur = new Mat();

private Mat detectedEdges = new Mat();

private Mat dst = new Mat();

private JFrame frame;

private JLabel imgLabel;

public CannyDetectorDemo(String[] args) {

String imagePath = args.length > 0 ? args[0] : "../data/fruits.jpg";

src = Imgcodecs.imread(imagePath);

if (src.empty()) {

System.out.println("Empty image: " + imagePath);

System.exit(0);

}

// Create and set up the window.

frame = new JFrame("Edge Map (Canny detector demo)");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// Set up the content pane.

Image img = HighGui.toBufferedImage(src);

addComponentsToPane(frame.getContentPane(), img);

// Use the content pane's default BorderLayout. No need for

// setLayout(new BorderLayout());

// Display the window.

frame.pack();

frame.setVisible(true);

}

private void addComponentsToPane(Container pane, Image img) {

if (!(pane.getLayout() instanceof BorderLayout)) {

pane.add(new JLabel("Container doesn't use BorderLayout!"));

return;

}

JPanel sliderPanel = new JPanel();

sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));

sliderPanel.add(new JLabel("Min Threshold:"));

JSlider slider = new JSlider(0, MAX_LOW_THRESHOLD, 0);

slider.setMajorTickSpacing(10);

slider.setMinorTickSpacing(5);

slider.setPaintTicks(true);

slider.setPaintLabels(true);

slider.addChangeListener(new ChangeListener() {

@Override

public void stateChanged(ChangeEvent e) {

JSlider source = (JSlider) e.getSource();

lowThresh = source.getValue();

update();

}

});

sliderPanel.add(slider);

pane.add(sliderPanel, BorderLayout.PAGE_START);

imgLabel = new JLabel(new ImageIcon(img));

pane.add(imgLabel, BorderLayout.CENTER);

}

private void update() {

Imgproc.blur(src, srcBlur, BLUR_SIZE);

Imgproc.Canny(srcBlur, detectedEdges, lowThresh, lowThresh * RATIO, KERNEL_SIZE, false);

dst = new Mat(src.size(), CvType.CV_8UC3, Scalar.all(0));

src.copyTo(dst, detectedEdges);

Image img = HighGui.toBufferedImage(dst);

imgLabel.setIcon(new ImageIcon(img));

frame.repaint();

}

public static void main(String[] args) {

// 加载本地 OpenCV 库

System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

// Schedule a job for the event dispatch thread

// creating and showing this application's GUI.

javax.swing.SwingUtilities.invokeLater(new Runnable() {

@Override

public void run() {

new CannyDetectorDemo(args);

}

});

}

}

cv::Scalar_::all
static Scalar_< _Tp > all(_Tp v0)
返回一个标量，其中所有元素都设置为 v0

cv::Scalar
Scalar_< double > Scalar
定义 types.hpp:709

教程代码如下所示。您也可以从此处下载。
from __future__ import print_function

import cv2 as cv

import argparse

max_lowThreshold = 100

window_name = 'Edge Map'

title_trackbar = 'Min Threshold:'

ratio = 3

kernel_size = 3

def CannyThreshold(val)

low_threshold = val

img_blur = cv.blur(src_gray, (3,3))

detected_edges = cv.Canny(img_blur, low_threshold, low_threshold*ratio, kernel_size)

mask = detected_edges != 0

dst = src * (mask[:,:,None].astype(src.dtype))

cv.imshow(window_name, dst)

parser = argparse.ArgumentParser(description='Code for Canny Edge Detector tutorial.')

parser.add_argument('--input', help='Path to input image.', default='fruits.jpg')

args = parser.parse_args()

src = cv.imread(cv.samples.findFile(args.input))

if src is None

print('Could not open or find the image: ', args.input)

exit(0)

src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)

cv.namedWindow(window_name)

cv.createTrackbar(title_trackbar, window_name , 0, max_lowThreshold, CannyThreshold)

CannyThreshold(0)

cv.waitKey()

cv::samples::findFile
cv::String findFile(const cv::String &relative_path, bool required=true, bool silentMode=false)
尝试查找请求的数据文件。

cv::imshow
void imshow(const String &winname, InputArray mat)
在指定窗口中显示图像。

cv::waitKey
int waitKey(int delay=0)
等待按键按下。

cv::namedWindow
void namedWindow(const String &winname, int flags=WINDOW_AUTOSIZE)
创建窗口。

cv::createTrackbar
int createTrackbar(const String &trackbarname, const String &winname, int *value, int count, TrackbarCallback onChange=0, void *userdata=0)
创建滑动条并将其附加到指定窗口。

cv::imread
CV_EXPORTS_W Mat imread(const String &filename, int flags=IMREAD_COLOR_BGR)
从文件加载图像。

cv::cvtColor
void cvtColor(InputArray src, OutputArray dst, int code, int dstCn=0, AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)
将图像从一个颜色空间转换为另一个颜色空间。

cv::Canny
void Canny(InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false)
使用 Canny 算法 canny86 在图像中查找边缘。

cv::blur
void blur(InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)
使用归一化盒式滤波器模糊图像。

此程序的作用是什么？

要求用户输入一个数值来设置我们的 Canny 边缘检测器的低阈值（通过滚动条）。
应用 Canny 检测器并生成一个掩码（在黑色背景上代表边缘的亮线）。
将获得的掩码应用于原始图像并在窗口中显示。

解释 (C++ 代码)

创建一些必要的变量
Mat src, src_gray;

Mat dst, detected_edges;

int lowThreshold = 0;

const int max_lowThreshold = 100;

const int ratio = 3;

const int kernel_size = 3;

const char* window_name = "Edge Map";

请注意以下几点：
1. 我们设置低阈值与高阈值的比例为 3:1（使用变量 ratio）。
2. 我们设置 Sobel 运算的核大小为 \(3\)（Canny 函数内部会执行这些运算）。
3. 我们设置低阈值的最大值为 \(100\)。
加载源图像
CommandLineParser parser( argc, argv, "{@input | fruits.jpg | input image}" );

src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR ); // 加载图像

if( src.empty() )

{

std::cout << "Could not open or find the image!\n" << std::endl;

std::cout << "Usage: " << argv[0] << " <Input image>" << std::endl;

return -1;

}
创建一个与 src 相同类型和大小的矩阵（作为 dst）
dst.create( src.size(), src.type() );
将图像转换为灰度图（使用函数 cv::cvtColor）
cvtColor( src, src_gray, COLOR_BGR2GRAY );
创建一个窗口来显示结果
namedWindow( window_name, WINDOW_AUTOSIZE );
创建一个滚动条，供用户输入 Canny 检测器的低阈值
createTrackbar( "Min Threshold:", window_name, &lowThreshold, max_lowThreshold, CannyThreshold );

请注意以下几点：
1. 由滚动条控制的变量是 lowThreshold，其上限为 max_lowThreshold（我们之前设置为 100）
2. 每次滚动条记录一个动作时，都会调用回调函数 CannyThreshold。
让我们一步步查看 CannyThreshold 函数：
1. 首先，我们使用核大小为 3 的滤波器对图像进行模糊处理
  blur( src_gray, detected_edges, Size(3,3) );
2. 其次，我们应用 OpenCV 函数 cv::Canny
  Canny( detected_edges, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size );
  
  其中参数为：
  - detected_edges：源图像，灰度图
  - detected_edges：检测器的输出（可以与输入相同）
  - lowThreshold：用户通过移动滚动条输入的值
  - highThreshold：在程序中设置为低阈值的三倍（遵循 Canny 的建议）
  - kernel_size：我们将其定义为 3（内部使用的 Sobel 核的大小）
我们将 dst 图像填充为零（意味着图像完全是黑色的）。
dst = Scalar::all(0);
最后，我们将使用函数 cv::Mat::copyTo 来仅映射图像中被识别为边缘的区域（在黑色背景上）。cv::Mat::copyTo 将 src 图像复制到 dst。但是，它只会复制像素值非零位置的像素。由于 Canny 检测器的输出是黑色背景上的边缘轮廓，因此生成的 dst 除了检测到的边缘外，所有区域都将是黑色的。
src.copyTo( dst, detected_edges);
我们显示结果
imshow( window_name, dst );

结果

编译上述代码后，我们可以通过提供图像路径作为参数来运行它。例如，使用以下图像作为输入：

移动滑块，尝试不同的阈值，我们得到以下结果：

请注意图像是如何在边缘区域叠加到黑色背景上的。


原始作者	Ana Huamán
兼容性	OpenCV >= 3.0

目录

目标

理论

步骤

代码

解释 (C++ 代码)

结果