OpenCV代码提取：dilate函数的实现

最新推荐文章于 2024-07-04 12:14:21 发布
最新推荐文章于 2024-07-04 12:14:21 发布
阅读量7.6k 收藏 4
点赞数 4
分类专栏： OpenCV
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengbingchun/article/details/52333643
版权

Morphological Operations: A set of operations that process images based on shapes.Morphological operations apply a structuring element to an input image and generate an output image.

The most basic morphological operations are two: Erosion and Dilation. They have a wide array of uses, i.e.:

(1)、Removing noise.

(2)、Isolation of individual elements and joining disparate elements in an image.

(3)、Finding of intensity bumps or holes in an image.

数学形态学可以理解为一种滤波行为，因此也称为形态学滤波。滤波中用到的滤波器(kernal)，在形态学中称为结构元素。结构元素往往是由一个特殊的形状构成,如线条、矩形、圆等。

OpenCV中的dilate函数支持多通道，各个通道膨胀处理过程独立。膨胀针对白色部分(高亮部分)。膨胀即是求局部最大值的操作，图像A与核B作卷积运算，计算核B覆盖区域的像素点的最大值，并把这个值赋值给锚点(anchor point)指定的像素。

Dilation:

(1)、This operations consists of convoluting an image A with some kernel(B), which can have any shape or size, usually a square or circle.

(2)、The kernel B has a defined anchor point, usually being the center of the kernel.

(3)、As the kernel B is scanned over the image, we compute the maximal pixel value overlapped by B and replace the image pixel in the anchor point position with that maximal value. As you can deduce, this maximizing operation causes bright regions within an image to “grow” (therefore the name dilation).


目前fbc_cv库中支持uchar和float两种数据类型，经测试，与OpenCV3.1结果完全一致。

实现代码dilate.cpp：

// fbc_cv is free software and uses the same licence as OpenCV
// Email: fengbingchun@163.com

#ifndef FBC_CV_DILATE_HPP_
#define FBC_CV_DILATE_HPP_

/* reference: include/opencv2/imgproc.hpp
              modules/imgproc/src/morph.cpp
*/

#include <typeinfo>
#include "core/mat.hpp"
#include "imgproc.hpp"
#include "filterengine.hpp"
#include "core/core.hpp"
#include "morph.hpp"

namespace fbc {

// Dilates an image by using a specific structuring element
// \f[\texttt{dst} (x,y) =  \max _{(x',y'):  \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f]
// In case of multi - channel images, each channel is processed independently.
// support type: uchar/float, multi-channels
template<typename _Tp, int chs>
int dilate(const Mat_<_Tp, chs>& src, Mat_<_Tp, chs>& dst, Mat_<uchar, 1>& kernel,
	Point anchor = Point(-1, -1), int iterations = 1, int borderType = BORDER_CONSTANT, const Scalar& borderValue = Scalar::all(DBL_MAX))
{
	FBC_Assert(typeid(uchar).name() == typeid(_Tp).name() || typeid(float).name() == typeid(_Tp).name()); // uchar || float
	if (dst.empty()) {
		dst = Mat_<_Tp, chs>(src.rows, src.cols);
	} else {
		FBC_Assert(src.rows == dst.rows && src.cols == dst.cols);
	}

	Size ksize = !kernel.empty() ? kernel.size() : Size(3, 3);
	anchor = normalizeAnchor(anchor, ksize);

	if (iterations == 0 || kernel.rows * kernel.cols == 1) {
		src.copyTo(dst);
		return 0;
	}

	if (kernel.empty()) {
		kernel = Mat_<uchar, 1>(1 + iterations * 2, 1 + iterations * 2);
		getStructuringElement(kernel, MORPH_RECT, Size(1 + iterations * 2, 1 + iterations * 2));
		anchor = Point(iterations, iterations);
		iterations = 1;
	} else if (iterations > 1 && countNonZero(kernel) == kernel.rows * kernel.cols) {
		anchor = Point(anchor.x*iterations, anchor.y*iterations);
		kernel = Mat_<uchar, 1>(ksize.height + (iterations - 1)*(ksize.height - 1), ksize.width + (iterations - 1)*(ksize.width - 1));
		getStructuringElement(kernel, MORPH_RECT,
			Size(ksize.width + (iterations - 1)*(ksize.width - 1), ksize.height + (iterations - 1)*(ksize.height - 1)), anchor);
		iterations = 1;
	}

	anchor = normalizeAnchor(anchor, kernel.size());

	Ptr<BaseRowFilter> rowFilter;
	Ptr<BaseColumnFilter> columnFilter;
	Ptr<BaseFilter> filter2D;

	if (countNonZero(kernel) == kernel.rows*kernel.cols) {
		// rectangular structuring element
		rowFilter = getMorphologyRowFilter<_Tp, chs>(1, kernel.cols, anchor.x);
		columnFilter = getMorphologyColumnFilter<_Tp, chs>(1, kernel.rows, anchor.y);
	} else {
		filter2D = getMorphologyFilter<_Tp, chs>(1, kernel, anchor);
	}

	Scalar borderValue_ = borderValue;
	if (borderType == BORDER_CONSTANT && borderValue_ == Scalar::all(DBL_MAX)) {
		if (sizeof(_Tp) == 1) // CV_8U
			borderValue_ = Scalar::all(0.);
		else // CV_32F
			borderValue_ = Scalar::all(-FLT_MAX);
	}

	Ptr<FilterEngine<_Tp, _Tp, _Tp, chs, chs, chs>> f = makePtr<FilterEngine<_Tp, _Tp, _Tp, chs, chs, chs>>(filter2D, rowFilter, columnFilter, borderType, borderType, borderValue_);
	f->apply(src, dst);
	for (int i = 1; i < iterations; i++)
		f->apply(dst, dst);

	return 0;
}

} // namespace fbc

#endif // FBC_CV_DILATE_HPP_

测试代码test_dilate.cpp： 

#include "test_dilate.hpp"
#include <assert.h>

#include <dilate.hpp>
#include <opencv2/opencv.hpp>

int test_getStructuringElement()
{
	for (int elem = 0; elem < 3; elem++) {
		for (int size = 0; size < 10; size++) {
			int type;
			if (elem == 0){ type = fbc::MORPH_RECT; }
			else if (elem == 1){ type = fbc::MORPH_CROSS; }
			else if (elem == 2) { type = fbc::MORPH_ELLIPSE; }

			fbc::Mat_<uchar, 1> element(2*size+1, 2*size+1);
			fbc::getStructuringElement(element, type, fbc::Size(2 * size + 1, 2 * size + 1), fbc::Point(size, size));

			int type_;
			if (elem == 0){ type_ = cv::MORPH_RECT; }
			else if (elem == 1){ type_ = cv::MORPH_CROSS; }
			else if (elem == 2) { type_ = cv::MORPH_ELLIPSE; }

			cv::Mat element_ = cv::getStructuringElement(type_, cv::Size(2 * size + 1, 2 * size + 1), cv::Point(size, size));

			assert(element.rows == element_.rows && element.cols == element.cols && element.step == element_.step);
			for (int y = 0; y < element.rows; y++) {
				const fbc::uchar* p1 = element.ptr(y);
				const uchar* p2 = element_.ptr(y);

				for (int x = 0; x < element.step; x++) {
					assert(p1[x] == p2[x]);
					if (size == 5)
						fprintf(stderr, "%d  ", p1[x]);
				}
				if (size == 5)
					fprintf(stderr, "\n");
			}

			if (size == 5)
				fprintf(stderr, "\n");
		}
	}

	return 0;
}

int test_dilate_uchar()
{
	cv::Mat matSrc = cv::imread("E:/GitCode/OpenCV_Test/test_images/lena.png", 1);
	if (!matSrc.data) {
		std::cout << "read image fail" << std::endl;
		return -1;
	}

	int width = matSrc.cols;
	int height = matSrc.rows;

	for (int elem = 0; elem < 3; elem++) {
		for (int size = 0; size < 10; size++) {
			for (int iterations = 1; iterations < 5; iterations++) {
				int type;
				if (elem == 0){ type = fbc::MORPH_RECT; }
				else if (elem == 1){ type = fbc::MORPH_CROSS; }
				else if (elem == 2) { type = fbc::MORPH_ELLIPSE; }

				fbc::Mat_<uchar, 1> element(2 * size + 1, 2 * size + 1);
				fbc::getStructuringElement(element, type, fbc::Size(2 * size + 1, 2 * size + 1), fbc::Point(size, size));

				int type_;
				if (elem == 0){ type_ = cv::MORPH_RECT; }
				else if (elem == 1){ type_ = cv::MORPH_CROSS; }
				else if (elem == 2) { type_ = cv::MORPH_ELLIPSE; }

				cv::Mat element_ = cv::getStructuringElement(type_, cv::Size(2 * size + 1, 2 * size + 1), cv::Point(size, size));

				assert(element.rows == element_.rows && element.cols == element.cols && element.step == element_.step);
				for (int y = 0; y < element.rows; y++) {
					const fbc::uchar* p1 = element.ptr(y);
					const uchar* p2 = element_.ptr(y);

					for (int x = 0; x < element.step; x++) {
						assert(p1[x] == p2[x]);
					}
				}

				fbc::Mat3BGR mat1(height, width, matSrc.data);
				fbc::Mat3BGR mat2(height, width);
				fbc::dilate(mat1, mat2, element, fbc::Point(-1, -1), iterations, 0, fbc::Scalar::all(128));

				cv::Mat mat1_(height, width, CV_8UC3, matSrc.data);
				cv::Mat mat2_;
				cv::dilate(mat1_, mat2_, element_, cv::Point(-1, -1), iterations, 0, cv::Scalar::all(128));

				assert(mat2.rows == mat2_.rows && mat2.cols == mat2_.cols && mat2.step == mat2_.step);
				for (int y = 0; y < mat2.rows; y++) {
					const fbc::uchar* p1 = mat2.ptr(y);
					const uchar* p2 = mat2_.ptr(y);

					for (int x = 0; x < mat2.step; x++) {
						assert(p1[x] == p2[x]);
					}
				}
			}
		}
	}

	return 0;
}

int test_dilate_float()
{
	cv::Mat matSrc = cv::imread("E:/GitCode/OpenCV_Test/test_images/lena.png", 1);
	if (!matSrc.data) {
		std::cout << "read image fail" << std::endl;
		return -1;
	}
	cv::cvtColor(matSrc, matSrc, CV_BGR2GRAY);
	matSrc.convertTo(matSrc, CV_32FC1);

	int width = matSrc.cols;
	int height = matSrc.rows;

	for (int elem = 0; elem < 3; elem++) {
		for (int size = 0; size < 10; size++) {
			for (int iterations = 1; iterations < 5; iterations++) {
				int type;
				if (elem == 0){ type = fbc::MORPH_RECT; }
				else if (elem == 1){ type = fbc::MORPH_CROSS; }
				else if (elem == 2) { type = fbc::MORPH_ELLIPSE; }

				fbc::Mat_<uchar, 1> element(2 * size + 1, 2 * size + 1);
				fbc::getStructuringElement(element, type, fbc::Size(2 * size + 1, 2 * size + 1), fbc::Point(size, size));

				int type_;
				if (elem == 0){ type_ = cv::MORPH_RECT; }
				else if (elem == 1){ type_ = cv::MORPH_CROSS; }
				else if (elem == 2) { type_ = cv::MORPH_ELLIPSE; }

				cv::Mat element_ = cv::getStructuringElement(type_, cv::Size(2 * size + 1, 2 * size + 1), cv::Point(size, size));

				assert(element.rows == element_.rows && element.cols == element.cols && element.step == element_.step);
				for (int y = 0; y < element.rows; y++) {
					const fbc::uchar* p1 = element.ptr(y);
					const uchar* p2 = element_.ptr(y);

					for (int x = 0; x < element.step; x++) {
						assert(p1[x] == p2[x]);
					}
				}

				fbc::Mat_<float, 1> mat1(height, width, matSrc.data);
				fbc::Mat_<float, 1> mat2(height, width);
				fbc::dilate(mat1, mat2, element, fbc::Point(-1, -1), iterations, 0, fbc::Scalar::all(128));

				cv::Mat mat1_(height, width, CV_32FC1, matSrc.data);
				cv::Mat mat2_;
				cv::dilate(mat1_, mat2_, element_, cv::Point(-1, -1), iterations, 0, cv::Scalar::all(128));

				assert(mat2.rows == mat2_.rows && mat2.cols == mat2_.cols && mat2.step == mat2_.step);
				for (int y = 0; y < mat2.rows; y++) {
					const fbc::uchar* p1 = mat2.ptr(y);
					const uchar* p2 = mat2_.ptr(y);

					for (int x = 0; x < mat2.step; x++) {
						assert(p1[x] == p2[x]);
					}
				}
			}
		}
	}

	return 0;
}

GitHub： https://github.com/fengbingchun/OpenCV_Test

fengbingchun
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++OpenCV3源代码dilate函数用法
04-28
C++OpenCV3编程源代码dilate函数用法示例提取方式是百度网盘分享地址
opencv之dilate()函数
热门推荐
duwangthefirst的博客
04-19 4万+
概述 dilate()函数可以对输入图像用特定结构元素进行膨胀操作，该结构元素确定膨胀操作过程中的邻域的形状，各点像素值将被替换为对应邻域上的最大值： API说明 C++ API： void cv::dilate ( InputArray src, （原始图像：通道数不限，depth必须是CV_8U，CV_16U，CV_16S，CV_32F或CV_64F） ...
OpenCV中的cv2.dilate(）
qq_42591591的博客
07-04 307
膨胀操作通常用于填补前景对象中的小洞、连接邻近的对象等。然而，它也可能导致前景对象在视觉上变大或与其他对象合并。膨胀是图像形态学操作的一种，与腐蚀操作相反，它用于增大图像中亮区域（通常是前景对象）的大小。
Opencv膨胀-dilate函数
qq_23880193的专栏
09-16 1522
#include #include using namespace std; using namespace cv; Mat srcImage, dstImage; int g_nDilateValue = 0; //有滚动条事件时，可以进入回调函数 void on_Trackbar(int, void *) { Mat element = getStructuringElement(MO
OPenCV膨胀函数dilate()的使用
jndingxin的专栏
02-07 1万+
OPenCV版本：4.4 IDE：VS2007 功能描述 简述：使用一个指定的核元素去膨胀一个图像，图像膨胀的过程类似于一个卷积的过程，源图像矩阵A以及结构元素B，B在A矩阵上依次移动，每个位置上B所覆盖元素的最大值替换B的中心位置值（即锚点处），完成整个膨胀的过程。 函数使用一个指定的核元素去膨胀源图像，内核有一个可定义的 锚点，我们叫他内核中心点，膨胀操作时，获取内核覆盖区域最大像素值，并代替锚点的像素，最大值通过以下公式获取： dst(x,y)=max⁡(x′,y′): element(x′,y′.
OpenCV 形态学膨胀——dilate函数
Eroslol的博客
09-16 755
http://blog.csdn.net/poem_qianmo/article/details/23710721 //-----------------------------------【头文件包含部分】--------------------------------------- // 描述：包含程序所依赖的头文件 //-------------------------------
opencv 实现特定颜色线条提取与定位操作
09-16
在OpenCV库中，提取和定位特定颜色的线条是一个常见的图像处理任务，广泛应用于自动驾驶、机器人导航、工业检测等领域。本篇文章将详细讲解如何利用OpenCV实现这一功能。 首先，我们要将原始的RGB图像转换为HSV色彩...
BgSubtractorMOG_Opencv背景提取_
09-29
在OpenCV库中，BgSubtractorMOG（Moving Object Detection using Gaussian Mixture Models）是一种用于背景提取和前景检测的算法。这个算法是基于高斯混合模型（Gaussian Mixture Models，GMM）来区分背景与前景物体...
基于opencv的骨架提取代码
12-25
在OpenCV中，我们可以使用`cv::morphologyEx`函数实现骨架提取，该函数接受多个参数，包括原始图像、目标图像、操作类型、结构元素以及迭代次数。骨架提取通常通过多次腐蚀和膨胀的交替进行，以逐渐减小对象的宽度，...
与opencv一起玩：OPENCV基本知识和微型项目
02-14
OpenCV的`dilate()`函数用于实现这一过程。 - **图像侵蚀**：侵蚀操作则可以减小边缘，移除小的白点或黑点。对应的函数是`erode()`。这两种操作常用于去除噪声，分离连接的物体。 6. **Numpy集成** - OpenCV与...
OpenCV中的Dilate（膨胀）与Erode（腐蚀）
01-06
目录   Dilate 膨胀 Erode 腐蚀 Sample 示例 Code 代码 Erosion Demo Dilation Demo Dilate 膨胀 Dilation Demo 作者：山庄的铁匠
OpenCV-Python图像处理：腐蚀和膨胀原理及erode、dilate函数介绍.rar
09-16
本篇文章将深入探讨OpenCV-Python中的两种基本形态学操作：腐蚀和膨胀，以及如何利用`erode()`和`dilate()`函数来实现这些操作。 首先，腐蚀和膨胀是形态学图像处理中的基础操作，主要用于去除噪声、连接断开的线条...
opencv 数学形态学(2) 膨胀运算：dilate
黎国溥
12-09 2075
                   opencv 数学形态学(2) 膨胀运算：dilate     dilate 函数原型如下： void dilate( InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDE...
毛星云opencv之膨胀函数dilate及其操作
weixin_52634719的博客
10-31 2138
#include <opencv2/opencv.hpp> #include<opencv2/core/core.hpp> #include"opencv2/highgui/highgui.hpp" #include<opencv2/imgproc/imgproc.hpp> #include<iostream> #include<time.h> using namespace std; using namespace cv; int mai.
OpenCV每日函数 图像过滤模块 (5) dilate膨胀函数
学以致用 知行合一
06-12 2366
通过使用特定的结构元素来扩大图像。该函数使用指定的结构元素扩展源图像，该结构元素确定取最大值的像素邻域的形状： 膨胀可以应用数次（迭代）。 在多通道图像的情况下，每个通道都是独立处理的。............
图像形态学操作-膨胀操作 1.cv2.dilate(进行膨胀操作)
newbeixue的博客
10-09 1214
图像形态学操作-膨胀操作 1.cv2.dilate(进行膨胀操作) https://www.cnblogs.com/my-love-is-python/p/10394908.html
dilate函数
qq_18343569的博客
08-20 3766
dilate函数 函数的调用形式： void dilate(InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, intborderType=BORDER_CONSTANT, const Scalar& borderValue=morpholo
JVC AV-29L31彩电维修手册和图纸.rar
最新发布
08-19
JVC AV-29L31彩电维修手册和图纸
OpenCV图像处理指南：关键函数与应用
- **FindContours** 和相关函数：寻找并提取图像中的轮廓，用于形状检测和物体识别。 - **PyramidSegmentation**: 金字塔层次上的区域分割。 这些功能只是OpenCV图像处理部分的冰山一角，实际使用中还有许多其他...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值