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

最新推荐文章于 2023-02-02 09:58:42 发布
最新推荐文章于 2023-02-02 09:58:42 发布
阅读量1.4w 收藏 21
点赞数 7
分类专栏： OpenCV
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengbingchun/article/details/51923392
版权

仿射变换(affine transformation),又称仿射映射,是指在几何中,一个向量空间进行一次线性变换并接上一个平移,变换为另一个向量空间.它是一种二维坐标到二维坐标之间的线性变换，保持二维图形的”平直性”(straightness，即变换后直线还是直线不会打弯，圆弧还是圆弧)和”平行性”(parallelness，保持二维图形间的相对位置关系不变，平行线还是平行线，而直线上点的位置顺序不变，但向量间夹角可能会发生变化)。

一个任意的仿射变换都能表示为：乘以一个矩阵(线性变换)接着再加上一个向量(平移)。仿射变换能够表示：旋转(rotation)、平移(translation)、缩放(scale)、翻转(flip)和错切(剪切、shear)操作。事实上，仿射变换代表了两幅图像之间的关系。通常使用2*3矩阵来表示仿射变换。

         有了仿射变换矩阵后，计算目的图像的公式为：

dst(x,y)= src(M11x + M12y + M13, M21x + M22y + M23)

这里对OpenCV中warpAffine函数进行了提取，目前支持uchar和float两种类型，经测试，与OpenCV3.1结果完全一致。

实现代码warpAffine.hpp：

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

#ifndef FBC_CV_WARP_AFFINE_HPP_
#define FBC_CV_WARP_AFFINE_HPP_

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

#include <typeinfo>
#include "core/mat.hpp"
#include "solve.hpp"
#include "imgproc.hpp"
#include "remap.hpp"

namespace fbc {

// Calculates an affine transform from three pairs of the corresponding points
FBC_EXPORTS int getAffineTransform(const Point2f src1[], const Point2f src2[], Mat_<double, 1>& dst);

// Applies an affine transformation to an image
// The function cannot operate in - place
// support type: uchar/float
template<typename _Tp1, typename _Tp2, int chs1, int chs2>
int warpAffine(const Mat_<_Tp1, chs1>& src, Mat_<_Tp1, chs1>& dst, const Mat_<_Tp2, chs2>& M_,
	int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, const Scalar& borderValue = Scalar())
{
	FBC_Assert(src.data != NULL && dst.data != NULL && M_.data != NULL);
	FBC_Assert(src.cols > 0 && src.rows > 0 && dst.cols > 0 && dst.rows > 0);
	FBC_Assert(src.data != dst.data);
	FBC_Assert(typeid(double) == typeid(_Tp2) && M_.rows == 2 && M_.cols == 3);
	FBC_Assert((typeid(uchar).name() == typeid(_Tp1).name()) || (typeid(float).name() == typeid(_Tp1).name())); // uchar/float

	double M[6];
	Mat_<double, 1> matM(2, 3, M);
	M_.convertTo(matM);

	int interpolation = flags & INTER_MAX;
	if (interpolation == INTER_AREA)
		interpolation = INTER_LINEAR;

	if (!(flags & WARP_INVERSE_MAP)) {
		double D = M[0] * M[4] - M[1] * M[3];
		D = D != 0 ? 1. / D : 0;
		double A11 = M[4] * D, A22 = M[0] * D;
		M[0] = A11; M[1] *= -D;
		M[3] *= -D; M[4] = A22;
		double b1 = -M[0] * M[2] - M[1] * M[5];
		double b2 = -M[3] * M[2] - M[4] * M[5];
		M[2] = b1; M[5] = b2;
	}

	int x;
	AutoBuffer<int> _abdelta(dst.cols * 2);
	int* adelta = &_abdelta[0], *bdelta = adelta + dst.cols;
	const int AB_BITS = MAX(10, (int)INTER_BITS);
	const int AB_SCALE = 1 << AB_BITS;

	for (x = 0; x < dst.cols; x++) {
		adelta[x] = saturate_cast<int>(M[0] * x*AB_SCALE);
		bdelta[x] = saturate_cast<int>(M[3] * x*AB_SCALE);
	}

	Range range(0, dst.rows);

	const int BLOCK_SZ = 64;
	short XY[BLOCK_SZ*BLOCK_SZ * 2], A[BLOCK_SZ*BLOCK_SZ];;
	int round_delta = interpolation == INTER_NEAREST ? AB_SCALE / 2 : AB_SCALE / INTER_TAB_SIZE / 2, y, x1, y1;

	int bh0 = std::min(BLOCK_SZ / 2, dst.rows);
	int bw0 = std::min(BLOCK_SZ*BLOCK_SZ / bh0, dst.cols);
	bh0 = std::min(BLOCK_SZ*BLOCK_SZ / bw0, dst.rows);

	for (y = range.start; y < range.end; y += bh0) {
		for (x = 0; x < dst.cols; x += bw0) {
			int bw = std::min(bw0, dst.cols - x);
			int bh = std::min(bh0, range.end - y);

			Mat_<short, 2> _XY(bh, bw, XY);
			Mat_<_Tp1, chs1> dpart;
			dst.getROI(dpart, Rect(x, y, bw, bh));

			for (y1 = 0; y1 < bh; y1++) {
				short* xy = XY + y1*bw * 2;
				int X0 = saturate_cast<int>((M[1] * (y + y1) + M[2])*AB_SCALE) + round_delta;
				int Y0 = saturate_cast<int>((M[4] * (y + y1) + M[5])*AB_SCALE) + round_delta;

				if (interpolation == INTER_NEAREST) {
					x1 = 0;
					for (; x1 < bw; x1++) {
						int X = (X0 + adelta[x + x1]) >> AB_BITS;
						int Y = (Y0 + bdelta[x + x1]) >> AB_BITS;
						xy[x1 * 2] = saturate_cast<short>(X);
						xy[x1 * 2 + 1] = saturate_cast<short>(Y);
					}
				} else {
					short* alpha = A + y1*bw;
					x1 = 0;
					for (; x1 < bw; x1++) {
						int X = (X0 + adelta[x + x1]) >> (AB_BITS - INTER_BITS);
						int Y = (Y0 + bdelta[x + x1]) >> (AB_BITS - INTER_BITS);
						xy[x1 * 2] = saturate_cast<short>(X >> INTER_BITS);
						xy[x1 * 2 + 1] = saturate_cast<short>(Y >> INTER_BITS);
						alpha[x1] = (short)((Y & (INTER_TAB_SIZE - 1))*INTER_TAB_SIZE +
							(X & (INTER_TAB_SIZE - 1)));
					}
				}
			}

			if (interpolation == INTER_NEAREST) {
				remap(src, dpart, _XY, Mat_<float, 1>(), interpolation, borderMode, borderValue);
			} else {
				Mat_<ushort, 1> _matA(bh, bw, A);
				remap(src, dpart, _XY, _matA, interpolation, borderMode, borderValue);
			}
		}
	}

	return 0;
}

} // namespace fbc

#endif // FBC_CV_WARP_AFFINE_HPP_

测试代码test_warpAffine.cpp： 

#include "test_warpAffine.hpp"
#include <assert.h>
#include <opencv2/opencv.hpp>
#include <core/mat.hpp>
#include <warpAffine.hpp>

int test_getAffineTransform()
{
	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;
	}

	fbc::Point2f srcTri[3];
	fbc::Point2f dstTri[3];

	// Set your 3 points to calculate the  Affine Transform
	srcTri[0] = fbc::Point2f(0, 0);
	srcTri[1] = fbc::Point2f(matSrc.cols - 1, 0);
	srcTri[2] = fbc::Point2f(0, matSrc.rows - 1);

	dstTri[0] = fbc::Point2f(matSrc.cols*0.0, matSrc.rows*0.33);
	dstTri[1] = fbc::Point2f(matSrc.cols*0.85, matSrc.rows*0.25);
	dstTri[2] = fbc::Point2f(matSrc.cols*0.15, matSrc.rows*0.7);

	// Get the Affine Transform
	fbc::Mat_<double, 1> warp_mat(2, 3);
	int ret = fbc::getAffineTransform(srcTri, dstTri, warp_mat);
	assert(ret == 0);

	cv::Point2f srcTri_[3];
	cv::Point2f dstTri_[3];

	// Set your 3 points to calculate the  Affine Transform
	srcTri_[0] = cv::Point2f(0, 0);
	srcTri_[1] = cv::Point2f(matSrc.cols - 1, 0);
	srcTri_[2] = cv::Point2f(0, matSrc.rows - 1);

	dstTri_[0] = cv::Point2f(matSrc.cols*0.0, matSrc.rows*0.33);
	dstTri_[1] = cv::Point2f(matSrc.cols*0.85, matSrc.rows*0.25);
	dstTri_[2] = cv::Point2f(matSrc.cols*0.15, matSrc.rows*0.7);

	// Get the Affine Transform
	cv::Mat warp_mat_(2, 3, CV_64FC1);
	warp_mat_ = cv::getAffineTransform(srcTri_, dstTri_);

	assert(warp_mat.cols == warp_mat_.cols && warp_mat.rows == warp_mat_.rows);
	assert(warp_mat.step == warp_mat_.step);
	for (int y = 0; y < warp_mat.rows; y++) {
		const fbc::uchar* p = warp_mat.ptr(y);
		const uchar* p_ = warp_mat_.ptr(y);

		for (int x = 0; x < warp_mat.step; x++) {
			assert(p[x] == p_[x]);
		}
	}

	return 0;
}

int test_warpAffine_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;
	}

	for (int interpolation = 0; interpolation < 5; interpolation++) {
		fbc::Point2f srcTri[3];
		fbc::Point2f dstTri[3];

		// Set your 3 points to calculate the  Affine Transform
		srcTri[0] = fbc::Point2f(0, 0);
		srcTri[1] = fbc::Point2f(matSrc.cols - 1, 0);
		srcTri[2] = fbc::Point2f(0, matSrc.rows - 1);

		dstTri[0] = fbc::Point2f(matSrc.cols*0.0, matSrc.rows*0.33);
		dstTri[1] = fbc::Point2f(matSrc.cols*0.85, matSrc.rows*0.25);
		dstTri[2] = fbc::Point2f(matSrc.cols*0.15, matSrc.rows*0.7);

		// Get the Affine Transform
		fbc::Mat_<double, 1> warp_mat(2, 3);
		int ret = fbc::getAffineTransform(srcTri, dstTri, warp_mat);
		assert(ret == 0);

		fbc::Mat_<uchar, 3> mat(matSrc.rows, matSrc.cols, matSrc.data);
		fbc::Mat_<uchar, 3> warp_dst;
		warp_dst.zeros(mat.rows, mat.cols);

		fbc::warpAffine(mat, warp_dst, warp_mat, interpolation);

		cv::Point2f srcTri_[3];
		cv::Point2f dstTri_[3];

		// Set your 3 points to calculate the  Affine Transform
		srcTri_[0] = cv::Point2f(0, 0);
		srcTri_[1] = cv::Point2f(matSrc.cols - 1, 0);
		srcTri_[2] = cv::Point2f(0, matSrc.rows - 1);

		dstTri_[0] = cv::Point2f(matSrc.cols*0.0, matSrc.rows*0.33);
		dstTri_[1] = cv::Point2f(matSrc.cols*0.85, matSrc.rows*0.25);
		dstTri_[2] = cv::Point2f(matSrc.cols*0.15, matSrc.rows*0.7);

		// Get the Affine Transform
		cv::Mat warp_mat_(2, 3, CV_64FC1);
		warp_mat_ = cv::getAffineTransform(srcTri_, dstTri_);

		// Set the dst image the same type and size as src
		cv::Mat warp_dst_ = cv::Mat::zeros(matSrc.rows, matSrc.cols, matSrc.type());
		cv::Mat mat_;
		matSrc.copyTo(mat_);

		// Apply the Affine Transform just found to the src image
		cv::warpAffine(mat_, warp_dst_, warp_mat_, warp_dst_.size(), interpolation);

		assert(warp_mat.cols == warp_mat_.cols && warp_mat.rows == warp_mat_.rows);
		assert(warp_mat.step == warp_mat_.step);
		for (int y = 0; y < warp_mat.rows; y++) {
			const fbc::uchar* p = warp_mat.ptr(y);
			const uchar* p_ = warp_mat_.ptr(y);

			for (int x = 0; x < warp_mat.step; x++) {
				assert(p[x] == p_[x]);
			}
		}
	}

	return 0;
}

int test_warpAffine_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);

	for (int interpolation = 0; interpolation < 5; interpolation++) {
		fbc::Point2f srcTri[3];
		fbc::Point2f dstTri[3];

		// Set your 3 points to calculate the  Affine Transform
		srcTri[0] = fbc::Point2f(0, 0);
		srcTri[1] = fbc::Point2f(matSrc.cols - 1, 0);
		srcTri[2] = fbc::Point2f(0, matSrc.rows - 1);

		dstTri[0] = fbc::Point2f(matSrc.cols*0.0, matSrc.rows*0.33);
		dstTri[1] = fbc::Point2f(matSrc.cols*0.85, matSrc.rows*0.25);
		dstTri[2] = fbc::Point2f(matSrc.cols*0.15, matSrc.rows*0.7);

		// Get the Affine Transform
		fbc::Mat_<double, 1> warp_mat(2, 3);
		int ret = fbc::getAffineTransform(srcTri, dstTri, warp_mat);
		assert(ret == 0);

		fbc::Mat_<float, 1> mat(matSrc.rows, matSrc.cols, matSrc.data);
		fbc::Mat_<float, 1> warp_dst;
		warp_dst.zeros(mat.rows, mat.cols);

		fbc::warpAffine(mat, warp_dst, warp_mat, interpolation);

		cv::Point2f srcTri_[3];
		cv::Point2f dstTri_[3];

		// Set your 3 points to calculate the  Affine Transform
		srcTri_[0] = cv::Point2f(0, 0);
		srcTri_[1] = cv::Point2f(matSrc.cols - 1, 0);
		srcTri_[2] = cv::Point2f(0, matSrc.rows - 1);

		dstTri_[0] = cv::Point2f(matSrc.cols*0.0, matSrc.rows*0.33);
		dstTri_[1] = cv::Point2f(matSrc.cols*0.85, matSrc.rows*0.25);
		dstTri_[2] = cv::Point2f(matSrc.cols*0.15, matSrc.rows*0.7);

		// Get the Affine Transform
		cv::Mat warp_mat_(2, 3, CV_64FC1);
		warp_mat_ = cv::getAffineTransform(srcTri_, dstTri_);

		// Set the dst image the same type and size as src
		cv::Mat warp_dst_ = cv::Mat::zeros(matSrc.rows, matSrc.cols, matSrc.type());
		cv::Mat mat_;
		matSrc.copyTo(mat_);

		// Apply the Affine Transform just found to the src image
		cv::warpAffine(mat_, warp_dst_, warp_mat_, warp_dst_.size(), interpolation);

		assert(warp_mat.cols == warp_mat_.cols && warp_mat.rows == warp_mat_.rows);
		assert(warp_mat.step == warp_mat_.step);
		for (int y = 0; y < warp_mat.rows; y++) {
			const fbc::uchar* p = warp_mat.ptr(y);
			const uchar* p_ = warp_mat_.ptr(y);

			for (int x = 0; x < warp_mat.step; x++) {
				assert(p[x] == p_[x]);
			}
		}
	}

	return 0;
}

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

fengbingchun
关注
  • 7
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
【C++】【Opencv】cv::warpAffine()仿射变换函数详解，实现平移、缩放和旋转等功能
不定时分享，互相学习，共同进步
11-19 5993
仿射变换是一种二维变换，它可以将一个二维图形映射到另一个二维图形上，保持了图形的“形状”和“大小”不变，但可能会改变图形的方向和位置。仿射变换可以用一个线性变换矩阵来表示，该矩阵包含了六个参数，可以进行平移、缩放、旋转等操作。通过原理、函数和示例进行解析，帮助大家理解和使用。
利用openCV实现图像旋转的C++程序源代码
05-01
这是利用openCV实现图像旋转的C++程序源代码，在VC++ 6.0下编译成功的。
opencv学习(三十五)之仿射变换warpAffine
热门推荐
烟雨博客
02-22 9万+
1.仿射变换介绍仿射变换是指在向量空间中进行一次线性变换(乘以一个矩阵)并加上一个平移(加上一个向量)，变换为另一个向量空间的过程。在有限维的情况下，每个仿射变换可以由一个矩阵A和一个向量b给出，它可以写作A和一个附加的列b。一个仿射变换对应于一个矩阵和一个向量的乘法，而仿射变换的复合对应于普通的矩阵乘法，只要加入一个额外的行到矩阵的底下，这一行全部是0除了最右边是一个1，而列向量的底下要加上一个1
opencv warpAffine()函数详解 -- 图像旋转与平移
qq_27278957的博客
03-28 4万+
简述 仿射变换是二维坐标间的线性变换，故而变换后的图像仍然具有原图的一些性质，包括“平直性”以及“平行性”，常用于图像翻转(Flip)、旋转(Rotations)、平移(Translations)、缩放(Scale operations)等，然而其实现的函数就是cv::warpAffine() 下面我们将对warpAffine()函数进行介绍，并且实现图像的旋转和平移。 warpAffine...
OpenCV 中的 warpAffine
yiran103的专栏
04-18 5341
warpAffine 是图像处理中比较常见的一种变换，可以将图像校正或对齐。 对于线性插值方式，OpenCV 首先将坐标映射保存成两张图，然后调用 remap 函数。第二步是比较耗时的部分，并且 warpPerspective 亦采用此处理。 remap 通过构建查找表来存储系数乘积，这样减少了乘法运算次数。 由于篇幅过长，将文章分成 warpAffine 和 remap 两部分。
opencv之warpAffine
chen_znn的博客
02-02 1315
opencv之warpAffine学习记录
OpenCV代码提取 warpPerspective函数的实现
hddryjv的博客
02-02 1530
OpenCV代码提取 warpPerspective函数的实现
OpenCV代码提取 remap函数的实现
hddryjv的博客
02-11 845
OpenCV代码提取 remap函数的实现
OpenCV 3计算机视觉：Python语言实现 随书源代码
02-17
《OpenCV 3计算机视觉：Python语言实现》是一本深入探讨计算机视觉理论和技术的书籍，其随书源代码提供了丰富的实例，帮助读者更好地理解和应用OpenCV库。OpenCV（开源计算机视觉库）是一个广泛用于图像处理和计算机...
Opencv 图像变换代码实现
04-25
本篇将详细讲解如何使用OpenCV进行图像变换的代码实现。 一、图像平移 图像平移是将图像在二维空间中沿水平或垂直方向移动。在OpenCV中，可以使用`cv2.warpAffine()`函数实现。该函数需要一个2x3的仿射变换矩阵，...
opencv-process:opencv实验室
03-28
4. **图像变换**：包括旋转、缩放、平移等，可以使用 `cv2.warpAffine()` 和 `cv2.warpPerspective()` 等函数实现。 5. **图像处理与滤波**：高斯滤波、中值滤波、Canny 边缘检测等都是常见的图像处理技术，可以...
OpenCV_LAB:图像处理LABWrok
03-10
图像平移是图像处理中的基本操作，通过使用`cv2.warpAffine()`或`cv2.copyMakeBorder()`函数可以实现。这些函数允许我们指定图像的位移量，从而将图像移动到新的位置。 4. **影像旋转**： 图像旋转涉及到图像坐标...
matlab中用ecc代码-learnopencv:学习opencv
05-26
接着，可以编写MATLAB代码来读取图像，提取特征，匹配特征，并使用ECC进行配准。 例如，一个简单的MATLAB脚本可能包含以下步骤： 1. **读取图像**：使用`imread`函数读取两张图像。 2. **预处理**：根据需要对图像...
python实现warpaffine，配上原理和代码
进击的菜鸟
10-28 1654
代码来源：https://github.com/shouxieai/tensorRT_Pro # 实现一个仿射变换，采用双线性插值方式实现一个warpaffine def pyWarpAffine(image, M, dst_size, constant=(0,0,0)): M = cv.invertAffineTransform(M) # 求仿射变换的逆矩阵，因为我们是把目的图片作为输入图片，因此需要使用逆矩阵求取原始图片的点 cons...
opencv图像仿射变换，cv2.warpAffine
秃头披风侠的博客
04-04 1万+
仿射变换原理介绍 仿射变换，又称仿射映射，是指在几何中，一个向量空间进行一次线性变换并接上一个平移，变换为另一个向量空间。 在有限维的情况，每个仿射变换可以由一个矩阵A和一个向量b给出，它可以写作A和一个附加的列b。一个仿射变换对应于一个矩阵和一个向量的乘法，而仿射变换的复合对应于普通的矩阵乘法，只要加入一个额外的行到矩阵的底下，这一行全部是0除了最右边是一个1，而列向量的底下要加上一个1。 在opencv中就相当于是对图像的坐标进行操作(x,y)，对坐标...
利用OpenCV的函数warpAffine()做图像的仿射变换【实现图像的平移、缩放、旋转、翻转等操作】
昊虹AI笔记
05-28 3458
利用OpenCV的函数warpAffine()做图像的仿射变换【实现图像的平移、缩放、旋转、翻转等操作】
matlab 通过矩阵变换使图像旋转平移_【图像处理】OpenCV系列十六 --- 仿射变换warpAffine...
weixin_39566864的博客
11-22 924
上一节我们学习了如何对一幅图像进行放大与缩小(resize函数)以及对插值算的原理进行了分析，相信大家对图像如何进行放大与缩小已经有了清晰的理解，那么我们这节学习OpenCV中比较重要的内容，即仿射变换(warpAffine)，仿射变换可以实现对稍微倾斜的图片进行矫正哦！！那么接下来我们就正式进入仿射变换的学习吧！一、原理仿射变换的功能是从二维坐标到二维坐标之间的线性变换，且保持二维图形的“平直性...
opencv学习笔记五：cv2.warpAffine()函数详解
耐心的小黑的博客
02-22 1万+
cv2.warpAffine()函数主要是利用变换矩阵M对图像进行如旋转、仿射、平移等变换，只需要我们提供一个2*3的变换矩阵M，就可以对图像进行变换。它一般是和cv2.getRotationMatrix2D和cv.GetAffineTransform两个函数在一起使用，这两个函数是用来获取变换矩阵M,这样就不需要我们自己设置M cv2.warpAffine(src, M, dsize,dst,f...
ROS安装配置与语法介绍文档、ROS代码文档、树莓派与ROS结合使用等相关文档
最新发布
07-08
ROS安装配置与语法介绍文档、ROS代码文档、树莓派与ROS结合使用等相关文档
opencv中有哪些函数
09-04
### 回答1： OpenCV是一个非常强大的计算机视觉库，提供了许多函数，下面是OpenCV中的一些常用函数： 1. cv::imread() - 读取图像文件 2. cv::imshow() - 显示图像 3. cv::waitKey() - 等待键盘输入 4. cv::cvtColor() - 转换图像颜色空间 5. cv::resize() - 调整图像大小 6. cv::flip() - 翻转图像 7. cv::threshold() - 图像阈值处理 8. cv::canny() - 边缘检测 9. cv::HoughLines() - 直线检测 10. cv::findContours() - 查找轮廓 除此之外，OpenCV还提供了许多其他的函数，可以用于图像处理、特征提取、目标检测、机器学习等任务。 ### 回答2： OpenCV是一个开源的计算机视觉库，提供了丰富的图像处理和计算机视觉算法。下面列举一些常见的OpenCV函数： 1. imread函数：用于读取图像文件并返回一个表示图像的矩阵。 2. imshow函数：用于显示图像。 3. blur函数：用于对图像进行模糊处理。 4. resize函数：用于调整图像的尺寸。 5. cvtColor函数：用于转换图像的颜色空间。 6. threshold函数：用于图像的二值化处理。 7. findContours函数：用于寻找图像中的轮廓。 8. drawContours函数：用于在图像上绘制轮廓。 9. matchTemplate函数：用于在图像中寻找与模板匹配的区域。 10. HoughLines函数：用于检测图像中的直线。 11. HoughCircles函数：用于检测图像中的圆。 12. cornerHarris函数：用于检测图像中的角点。 13. warpAffine函数：用于对图像进行仿射变换。 14. warpPerspective函数：用于对图像进行透视变换。 15. filter2D函数：用于对图像进行卷积操作。 这仅仅是OpenCV中的一小部分函数，OpenCV还提供了很多其他功能丰富的图像处理和计算机视觉函数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值