前言
基于opencv的c++接口，实现常用的图像边缘检测方法，包括了图像差分、拉普拉斯边缘检测、canny边缘检测、sobel边缘检测、prewitt边缘检测、roberts边缘检测以及Marr-Hildreth边缘检测。
相关的opencv接口解析
CV_EXPORTS_W void addWeighted(InputArray src1, double alpha, InputArray src2,
double beta, double gamma, OutputArray dst, int dtype = -1);
函数 addWeighted 用于计算两个数组的加权和，该函数可以替换为矩阵表达式：
dst = src1alpha + src2beta + gamma；
@param src1 第一个输入数组。
@param alpha 第一个数组元素的 alpha 权重。
@param src2 与 src1 大小和通道号相同的第二个输入数组。
@param beta 第二个数组元素的beta权重。
@param gamma 标量添加到每个总和。
@param dst 输出数组，其大小和通道数与输入数组相同。
@param dtype 输出数组的可选深度； 当两个输入数组具有相同的深度时，可以将 dtype 设置为 -1，这将等效于 src1.depth()。
CV_EXPORTS_W void Laplacian( InputArray src, OutputArray dst, int ddepth,
int ksize = 1, double scale = 1, double delta = 0,
int borderType = BORDER_DEFAULT );
该函数通过将使用 Sobel 算子计算的第二个 x 和 y 导数相加来计算源图像的拉普拉斯算子。
@param src 源图像。
@param dst 与 src 大小和通道数相同的目标图像。
@param ddepth 目标图像的所需深度。
@param ksize 用于计算二阶导数滤波器的孔径大小。 有关详细信息，请参阅#getDerivKernels。 大小必须是正数和奇数。
@param scale 计算的拉普拉斯值的可选比例因子。 默认情况下，不应用缩放。 有关详细信息，请参阅#getDerivKernels。
@param delta 在将结果存储到 dst 之前添加到结果中的可选 delta 值。
@param borderType 像素外推法，见#BorderTypes。 不支持#BORDER_WRAP。
enum BorderTypes {
BORDER_CONSTANT = 0, //!< `iiiiii|abcdefgh|iiiiiii` with some specified `i`
BORDER_REPLICATE = 1, //!< `aaaaaa|abcdefgh|hhhhhhh`
BORDER_REFLECT = 2, //!< `fedcba|abcdefgh|hgfedcb`
BORDER_WRAP = 3, //!< `cdefgh|abcdefgh|abcdefg`
BORDER_REFLECT_101 = 4, //!< `gfedcb|abcdefgh|gfedcba`
BORDER_TRANSPARENT = 5, //!< `uvwxyz|abcdefgh|ijklmno`
BORDER_REFLECT101 = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101
BORDER_DEFAULT = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101
BORDER_ISOLATED = 16 //!< do not look outside of ROI
};
CV_EXPORTS_W void Canny( InputArray image, OutputArray edges,
double threshold1, double threshold2,
int apertureSize = 3, bool L2gradient = false );
该函数在输入图像中查找边缘，并使用 Canny 算法在输出地图边缘中标记它们。 threshold1 和 threshold2 之间的最小值用于边缘链接。 这最大值用于查找强边缘的初始段。 看http://en.wikipedia.org/wiki/Canny_edge_detector
@param image 8 位输入图像。
@param edges 输出边缘图； 单通道 8 位图像，其大小与 image 相同。
@param threshold1 滞后过程的第一个阈值。
@param threshold2 滞后过程的第二个阈值。
@param apertureSize Sobel 算子的孔径大小。
@param L2gradient 一个标志，表示是否更准确的L2范数应该用于计算图像梯度幅度 (
L2gradient=true ），或者默认L1范数（L2gradient=false ）。
CV_EXPORTS_W void Sobel( InputArray src, OutputArray dst, int ddepth,
int dx, int dy, int ksize = 3,
double scale = 1, double delta = 0,
int borderType = BORDER_DEFAULT );
该函数通过将使用 Sobel 算子计算图像x和y方向的梯度。
@param src 输入图像。
@param dst 输出与 src 大小和通道数相同的图像。
@param ddepth 输出图像深度，见@ref filter_depths “combinations”；在 8 位输入图像的情况下，它将导致截断导数。
@param dx 导数 x 的顺序。
@param dy 导数 y 的顺序。
@param ksize 扩展 Sobel 内核的大小；它必须是 1、3、5 或 7。
@param scale 计算导数值的可选比例因子；默认情况下，没有缩放
已应用（有关详细信息，请参阅#getDerivKernels）。
@param delta 在将结果存储到 dst 之前添加到结果中的可选 delta 值。
@param borderType 像素外推方法，参见#BorderTypes。不支持#BORDER_WRAP。
示例代码
edge.h
#pragma once
#include <iostream>
#include <opencv2\highgui\highgui.hpp>
#include <opencv2\core\core.hpp>
#include <opencv2\imgproc\imgproc.hpp>
using namespace std;
using namespace cv;
#define PROCESS_IMG_SUCESS 0
#define PROCESS_IMG_FAIL 1
namespace ImgEnhance
{
//边缘检测
class EdgeDetect
{
public:
EdgeDetect() {
cout << "EdgeDetect is being created" << endl; } // 这是构造函数声明
~EdgeDetect() {
cout << "EdgeDetect is being deleted" << endl; } // 这是析构函数声明
void diffOperation(const cv::Mat srcImage, cv::Mat& edgeXImage, cv::Mat& edgeYImage);// 图像差分操作
int ImgDifference(cv::Mat srcImage, cv::Mat &dstImage, double vValue, double hValue, double fixedValue);//图像差分
int LaplaceEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage);//拉普拉斯边缘检测
int CannyEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage, double threshold1, double threshold2);//canny边缘检测
int SobelEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage, double vValue, double hValue, double fixedValue);//sobel边缘检测
int PrewittEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage, double vValue, double hValue, double fixedValue);//prewitt边缘检测
Mat roberts(Mat srcImage);//Roberts算子实现
int RobertsEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage);//roberts边缘检测
void marrEdge(const Mat src, Mat& result, int kerValue, double delta);//Marr-Hildreth检测算法实现（高斯平滑滤波器和拉普拉斯锐化器结合起来）
int MarrEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage, int kerValue, double delta);//marr边缘检测
};
}
edge.cpp
#include"edge.h"
// 图像差分操作
void ImgEnhance::EdgeDetect::diffOperation(const cv::Mat srcImage, cv::Mat& edgeXImage, cv::Mat& edgeYImage)
{
cv::Mat tempImage = srcImage.clone();
int nRows = tempImage.rows;
int nCols = tempImage.cols;
for (int i = 0; i < nRows - 1; i++)
{
for (int j = 0; j < nCols - 1; j++)
{
// 计算垂直边边缘
edgeXImage.at<uchar>(i, j) =
abs(tempImage.at<uchar>(i + 1, j) -
tempImage.at<uchar>(i, j));
// 计算水平边缘
edgeYImage.at<uchar>(i, j) =
abs(tempImage.at<uchar>(i, j + 1) -
tempImage.at<uchar>(i, j));
}
}
}
int ImgEnhance::EdgeDetect::ImgDifference(cv::Mat srcImage, cv::Mat &dstImage, double vValue, double hValue, double fixedValue)
{
if (srcImage.empty())
{
printf("cannot load!!\n");
return 1;
}
cv::Mat edgeXImage(srcImage.size(), srcImage.type());
cv::Mat edgeYImage(srcImage.size(), srcImage.type());
// 计算查分图像
diffOperation(srcImage, edgeXImage, edgeYImage);
cv::imshow("edgeXImage", edgeXImage);
cv::imshow("edgeYImage", edgeYImage);
//cv::Mat edgeImage(srcImage.size(), srcImage.type());
// 水平与垂直边缘图像叠加
addWeighted(edgeXImage, vValue, edgeYImage, hValue, fixedValue, dstImage);
return 0;
}
int ImgEnhance::EdgeDetect::LaplaceEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage)
{
if (srcImage.empty())
{
printf("cannot load!!\n");
return 1;
}
//使用Laplace函数
//第三个参数：目标图像深度；第四个参数：滤波器孔径尺寸；第五个参数：比例因子；第六个参数：表示结果存入目标图
Mat dstImage0;
Laplacian(srcImage, dstImage0, CV_16S, 3, 1, 0, BORDER_DEFAULT);
//计算绝对值，并将结果转为8位
convertScaleAbs(dstImage0, dstImage);
return 0;
}
int ImgEnhance::EdgeDetect::CannyEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage, double threshold1, double threshold2)
{
if (srcImage.empty())
{
printf("cannot load!!\n");
return 1;
}
//运行canny算子
Canny(srcImage, dstImage, threshold1, threshold2, 3);
return 0;
}
int ImgEnhance::EdgeDetect::SobelEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage, double vValue, double hValue, double fixedValue)
{
if (srcImage.empty())
{
printf("cannot load!!\n");
return 1;
}
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y;
//求x方向梯度
Sobel(srcImage, grad_x, CV_16S, 1, 0, 3, 1, 1, BORDER_DEFAULT);
convertScaleAbs(grad_x, abs_grad_x);
imshow("x方向soble", abs_grad_x);
//求y方向梯度
Sobel(srcImage, grad_y, CV_16S, 0, 1, 3, 1, 1, BORDER_DEFAULT);
convertScaleAbs(grad_y, abs_grad_y);
imshow("y向soble", abs_grad_y);
// 水平与垂直边缘图像叠加
addWeighted(abs_grad_x, vValue, abs_grad_y, hValue, fixedValue, dstImage);
return 0;
}
int ImgEnhance::EdgeDetect::PrewittEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage, double vValue, double hValue, double fixedValue)
{
if (srcImage.empty())
{
printf("cannot load!!\n");
return 1;
}
Mat Kernelx, Kernely;
Kernelx = (Mat_<double>(3, 3) << 1, 1, 1, 0, 0, 0, -1, -1, -1);
Kernely = (Mat_<double>(3, 3) << -1, 0, 1, -1, 0, 1, -1, 0, 1);
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y;
filter2D(srcImage, grad_x, CV_16S, Kernelx, Point(-1, -1));
filter2D(srcImage, grad_y, CV_16S, Kernely, Point(-1, -1));
convertScaleAbs(grad_x, abs_grad_x);
convertScaleAbs(grad_y, abs_grad_y);
imshow("y方向prewitt", abs_grad_x);
imshow("x方向prewitt", abs_grad_y);
// 水平与垂直边缘图像叠加
addWeighted(abs_grad_x, vValue, abs_grad_y, hValue, fixedValue, dstImage);
return 0;
}
//Roberts算子实现
Mat ImgEnhance::EdgeDetect::roberts(Mat srcImage)
{
Mat dstImage = srcImage.clone();
int nRows = dstImage.rows;
int nCols = dstImage.cols;
for (int i = 0; i < nRows - 1; i++) {
for (int j = 0; j < nCols - 1; j++) {
//根据公式计算
int t1 = (srcImage.at<uchar>(i, j) -
srcImage.at<uchar>(i + 1, j + 1))*
(srcImage.at<uchar>(i, j) -
srcImage.at<uchar>(i + 1, j + 1));
int t2 = (srcImage.at<uchar>(i + 1, j) -
srcImage.at<uchar>(i, j + 1))*
(srcImage.at<uchar>(i + 1, j) -
srcImage.at<uchar>(i, j + 1));
//计算g（x,y）
dstImage.at<uchar>(i, j) = (uchar)sqrt(t1 + t2);
}
}
return dstImage;
}
int ImgEnhance::EdgeDetect::RobertsEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage)
{
if (srcImage.empty())
{
printf("cannot load!!\n");
return 1;
}
dstImage = roberts(srcImage);
return 0;
}
//Marr-Hildreth检测算法实现（高斯平滑滤波器和拉普拉斯锐化器结合起来）
void ImgEnhance::EdgeDetect::marrEdge(const Mat src, Mat& result, int kerValue, double delta)
{
// 计算LOG算子
Mat kernel;
// 半径
int kerLen = kerValue / 2;
kernel = Mat_<double>(kerValue, kerValue);
// 滑窗
for (int i = -kerLen; i <= kerLen; i++)
{
for (int j = -kerLen; j <= kerLen; j++)
{
// 核因子生成
kernel.at<double>(i + kerLen, j + kerLen) =
exp(-((pow(j, 2) + pow(i, 2)) /
(pow(delta, 2) * 2)))
* (((pow(j, 2) + pow(i, 2) - 2 *
pow(delta, 2)) / (2 * pow(delta, 4))));
}
}
// 输出参数设置
int kerOffset = kerValue / 2;
Mat laplacian = (Mat_<double>(src.rows - kerOffset * 2,
src.cols - kerOffset * 2));
result = Mat::zeros(src.rows - kerOffset * 2,
src.cols - kerOffset * 2, src.type());
double sumLaplacian;
// 遍历计算卷积图像的Lapace算子
for (int i = kerOffset; i < src.rows - kerOffset; ++i)
{
for (int j = kerOffset; j < src.cols - kerOffset; ++j)
{
sumLaplacian = 0;
for (int k = -kerOffset; k <= kerOffset; ++k)
{
for (int m = -kerOffset; m <= kerOffset; ++m)
{
// 计算图像卷积
sumLaplacian += src.at<uchar>(i + k, j + m) *
kernel.at<double>(kerOffset + k,
kerOffset + m);
}
}
// 生成Lapace结果
laplacian.at<double>(i - kerOffset,
j - kerOffset) = sumLaplacian;
}
}
// 过零点交叉 寻找边缘像素
for (int y = 1; y < result.rows - 1; ++y)
{
for (int x = 1; x < result.cols - 1; ++x)
{
result.at<uchar>(y, x) = 0;
// 邻域判定
if (laplacian.at<double>(y - 1, x) *
laplacian.at<double>(y + 1, x) < 0)
{
result.at<uchar>(y, x) = 255;
}
if (laplacian.at<double>(y, x - 1) *
laplacian.at<double>(y, x + 1) < 0)
{
result.at<uchar>(y, x) = 255;
}
if (laplacian.at<double>(y + 1, x - 1) *
laplacian.at<double>(y - 1, x + 1) < 0)
{
result.at<uchar>(y, x) = 255;
}
if (laplacian.at<double>(y - 1, x - 1) *
laplacian.at<double>(y + 1, x + 1) < 0)
{
result.at<uchar>(y, x) = 255;
}
}
}
}
int ImgEnhance::EdgeDetect::MarrEdgeDetect(cv::Mat srcImage, cv::Mat &dstImage, int kerValue, double delta)
{
if (srcImage.empty())
{
printf("cannot load!!\n");
return 1;
}
marrEdge(srcImage, dstImage, kerValue, delta);
return 0;
}
test.cpp
#include"edge.h"
ImgEnhance::EdgeDetect ImgE;//边缘检测
int main()
{
// 读取源图像及判断
cv::Mat srcImage = cv::imread("flower.jpg");
if (!srcImage.data)
{
return 1;
}
/*cv::namedWindow("原始图", 0);
cv::imshow("原始图", srcImage);*/
// 转化为灰度图像
cv::Mat srcGray;
if (srcImage.channels() == 3)
{
cv::cvtColor(srcImage, srcGray, COLOR_RGB2GRAY);
}
else
{
srcGray = srcImage.clone();
}
cv::namedWindow("灰度图", 0);
cv::imshow("灰度图", srcGray);
Mat difImage;
//图像差分
ImgE.ImgDifference(srcGray, difImage, 0.5, 0.5, 0);
cv::namedWindow("图像差分结果图", 0);
cv::imshow("图像差分结果图", difImage);
Mat laplaceImage;
//拉普拉斯边缘检测
ImgE.LaplaceEdgeDetect(srcGray, laplaceImage);
cv::namedWindow("拉普拉斯边缘检测结果图", 0);
cv::imshow("拉普拉斯边缘检测结果图", laplaceImage);
Mat cannyImage;
//canny边缘检测
ImgE.CannyEdgeDetect(srcGray, cannyImage, 30, 90);
cv::namedWindow("canny边缘检测结果图", 0);
cv::imshow("canny边缘检测结果图", cannyImage);
Mat sobelImage;
//sobel边缘检测
ImgE.SobelEdgeDetect(srcGray, sobelImage, 0.5, 0.5, 0);
cv::namedWindow("sobel边缘检测结果图", 0);
cv::imshow("sobel边缘检测结果图", sobelImage);
Mat prewittImage;
//prewitt边缘检测
ImgE.PrewittEdgeDetect(srcGray, prewittImage, 0.5, 0.5, 0);
cv::namedWindow("prewitt边缘检测结果图", 0);
cv::imshow("prewitt边缘检测结果图", prewittImage);
Mat robertsImage;
//roberts边缘检测
ImgE.RobertsEdgeDetect(srcGray, robertsImage);
cv::namedWindow("roberts边缘检测结果图", 0);
cv::imshow("roberts边缘检测结果图", robertsImage);
Mat marrImage;
//marr边缘检测
ImgE.MarrEdgeDetect(srcGray, marrImage, 9, 1.6);
cv::namedWindow("marr边缘检测结果图", 0);
cv::imshow("marr边缘检测结果图", marrImage);
cv::waitKey(0);
return 0;
}
结果展示
