OpenCV代码提取：merge/split函数的实现

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

对OpenCV中的merge/split函数进行了实现，经测试，与OpenCV3.1结果完全一致。

merge实现代码merge.hpp：

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

#ifndef FBC_CV_MERGE_HPP_
#define FBC_CV_MERGE_HPP_

/* reference: include/opencv2/core.hpp
              core/src/convert.cpp
              core/src/merge.cpp
*/

#include <vector>
#include "core/mat.hpp"

#ifndef __cplusplus
	#error merge.hpp header must be compiled as C++
#endif

namespace fbc {

// merge several arrays to make a single multi-channel array
template<typename _Tp, int chs1, int chs2>
int merge(const std::vector<Mat_<_Tp, chs1>>& src, Mat_<_Tp, chs2>& dst)
{
	FBC_Assert(dst.data != NULL);
	FBC_Assert((src.size() > 0) && (src.size() == dst.channels) && (src.size() <= FBC_CN_MAX));
	int width = src[0].cols;
	int height = src[0].rows;
	FBC_Assert((dst.cols == width) && (dst.rows == height));
	for (int i = 0; i < src.size(); i++) {
		FBC_Assert(src[i].data != NULL);
		FBC_Assert((src[i].cols == width) && src[i].rows == height);
		FBC_Assert(src[i].channels == 1);
	}

	if (src.size() == 1) {
		memcpy(dst.data, src[0].data, dst.step * dst.rows);
		return 0;
	}

	_Tp* pDst = (_Tp*)dst.data;
	int len = width * height;
	int cn = dst.channels;

	for (int i = 0; i < src.size(); i++) {
		_Tp* pSrc = (_Tp*)src[i].data;

		for (int j = 0; j < len; j++) {
			pDst[j * cn + i] = pSrc[j];
		}
	}

	return 0;
}

} // namespace fbc

#endif // FBC_CV_MERGE_HPP_
split实现代码split.hpp： 

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

#ifndef FBC_CV_SPLIT_HPP_
#define FBC_CV_SPLIT_HPP_

/* reference: include/opencv2/core.hpp
              core/src/convert.cpp
	      core/src/split.cpp
*/

#include <vector>
#include "core/mat.hpp"

#ifndef __cplusplus
	#error split.hpp header must be compiled as C++
#endif

namespace fbc {

// split a multi-channel array into separate single-channel arrays
template<typename _Tp, int chs1, int chs2>
int split(const Mat_<_Tp, chs1>& src, std::vector<Mat_<_Tp, chs2>>& dst)
{
	FBC_Assert(src.data != NULL);
	FBC_Assert((dst.size() == chs1) && (chs2 == 1));
	for (int i = 0; i < dst.size(); i++) {
		FBC_Assert((dst[i].data != NULL) && (dst[i].rows == src.rows) && (dst[i].cols == src.cols));
	}

	int cn = src.channels;
	if (cn == 1) {
		memcpy(dst[0].data, src.data, src.step * src.rows);
		return 0;
	}

	_Tp* pSrc = (_Tp*)src.data;
	int len = src.rows * src.cols;

	for (int i = 0; i < cn; i++) {
		_Tp* pDst = (_Tp*)dst[i].data;

		for (int j = 0; j < len; j++) {
			pDst[j] = pSrc[j * cn + i];
		}
	}

	return 0;
}

} // namespace fbc

#endif // FBC_CV_SPLIT_HPP_
merge测试代码： 

#include <assert.h>
#include <vector>
#include <core/mat.hpp>
#include <merge.hpp>

#include <opencv2/opencv.hpp>

#include "test_merge.hpp"

int test_merge_uchar()
{
	cv::Mat matSrc1 = cv::imread("E:/GitCode/OpenCV_Test/test_images/lena.png", 1);
	cv::Mat matSrc2 = cv::imread("E:/GitCode/OpenCV_Test/test_images/1.jpg", 1);
	cv::Mat matSrc3 = cv::imread("E:/GitCode/OpenCV_Test/test_images/2.jpg", 1);
	if (!matSrc1.data || !matSrc2.data || !matSrc3.data) {
		std::cout << "read image fail" << std::endl;
		return -1;
	}

	int width = 500, height = 600;

	cv::cvtColor(matSrc1, matSrc1, CV_BGR2GRAY);
	cv::cvtColor(matSrc2, matSrc2, CV_BGR2GRAY);
	cv::cvtColor(matSrc3, matSrc3, CV_BGR2GRAY);
	cv::resize(matSrc1, matSrc1, cv::Size(width, height));
	cv::resize(matSrc2, matSrc2, cv::Size(width, height));
	cv::resize(matSrc3, matSrc3, cv::Size(width, height));

	fbc::Mat_<fbc::uchar, 1> mat1(height, width, matSrc1.data);
	fbc::Mat_<fbc::uchar, 1> mat2(height, width, matSrc2.data);
	fbc::Mat_<fbc::uchar, 1> mat3(height, width, matSrc3.data);
	std::vector<fbc::Mat_<fbc::uchar, 1>> mat;
	mat.push_back(mat1);
	mat.push_back(mat2);
	mat.push_back(mat3);
	fbc::Mat_<fbc::uchar, 3> matDst(height, width);
	fbc::merge(mat, matDst);

	std::vector<cv::Mat> mat_;
	mat_.push_back(matSrc1);
	mat_.push_back(matSrc2);
	mat_.push_back(matSrc3);
	cv::Mat matDst_;
	cv::merge(mat_, matDst_);

	assert(matDst.channels == matDst_.channels());
	assert((matDst.rows == matDst_.rows) && (matDst.cols == matDst_.cols));
	assert(matDst.step == matDst_.step);

	for (int i = 0; i < matDst.rows; i++) {
		const fbc::uchar* p1 = matDst.ptr(i);
		const uchar* p2 = matDst_.ptr(i);

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

	return 0;
}

int test_merge_float()
{
	cv::Mat matSrc1 = cv::imread("E:/GitCode/OpenCV_Test/test_images/lena.png", 1);
	cv::Mat matSrc2 = cv::imread("E:/GitCode/OpenCV_Test/test_images/1.jpg", 1);
	cv::Mat matSrc3 = cv::imread("E:/GitCode/OpenCV_Test/test_images/2.jpg", 1);
	if (!matSrc1.data || !matSrc2.data || !matSrc3.data) {
		std::cout << "read image fail" << std::endl;
		return -1;
	}

	int width = 500, height = 600;

	cv::cvtColor(matSrc1, matSrc1, CV_BGR2GRAY);
	cv::cvtColor(matSrc2, matSrc2, CV_BGR2GRAY);
	cv::cvtColor(matSrc3, matSrc3, CV_BGR2GRAY);
	cv::resize(matSrc1, matSrc1, cv::Size(width, height));
	cv::resize(matSrc2, matSrc2, cv::Size(width, height));
	cv::resize(matSrc3, matSrc3, cv::Size(width, height));
	matSrc1.convertTo(matSrc1, CV_32FC1);
	matSrc2.convertTo(matSrc2, CV_32FC1);
	matSrc3.convertTo(matSrc3, CV_32FC1);

	fbc::Mat_<float, 1> mat1(height, width, matSrc1.data);
	fbc::Mat_<float, 1> mat2(height, width, matSrc2.data);
	fbc::Mat_<float, 1> mat3(height, width, matSrc3.data);
	std::vector<fbc::Mat_<float, 1>> mat;
	mat.push_back(mat1);
	mat.push_back(mat2);
	mat.push_back(mat3);
	fbc::Mat_<float, 3> matDst(height, width);
	fbc::merge(mat, matDst);

	std::vector<cv::Mat> mat_;
	mat_.push_back(matSrc1);
	mat_.push_back(matSrc2);
	mat_.push_back(matSrc3);
	cv::Mat matDst_;
	cv::merge(mat_, matDst_);

	assert(matDst.channels == matDst_.channels());
	assert((matDst.rows == matDst_.rows) && (matDst.cols == matDst_.cols));
	assert(matDst.step == matDst_.step);

	for (int i = 0; i < matDst.rows; i++) {
		const fbc::uchar* p1 = matDst.ptr(i);
		const uchar* p2 = matDst_.ptr(i);

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

	return 0;
}
split测试代码： 

#include <assert.h>
#include <vector>
#include <core/mat.hpp>
#include <split.hpp>

#include <opencv2/opencv.hpp>

#include "test_split.hpp"

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

	int chs = mat.channels();
	int width = mat.cols;
	int height = mat.rows;

	fbc::Mat_<fbc::uchar, 3> mat1(height, width, mat.data);
	std::vector<fbc::Mat_<fbc::uchar, 1>> vecMat2;
	fbc::Mat_<fbc::uchar, 1>* mat2 = new fbc::Mat_<fbc::uchar, 1>[chs];
	for (int i = 0; i < chs; i++) {
		mat2[i] = fbc::Mat_<fbc::uchar, 1>(height, width);
		vecMat2.push_back(mat2[i]);
	}

	fbc::split(mat1, vecMat2);

	cv::Mat mat1_(height, width, CV_8UC3, mat.data);
	std::vector<cv::Mat> vecMat2_;
	cv::split(mat1_, vecMat2_);

	assert(vecMat2.size() == vecMat2_.size());
	for (int i = 0; i < vecMat2.size(); i++) {
		assert(vecMat2[i].rows == vecMat2_[i].rows && vecMat2[i].cols == vecMat2_[i].cols);
		assert(vecMat2[i].step == vecMat2_[i].step);
		assert(vecMat2[i].channels == vecMat2_[i].channels());

		for (int y = 0; y < vecMat2[i].rows; y++) {
			const fbc::uchar* p = vecMat2[i].ptr(y);
			const uchar* p_ = vecMat2_[i].ptr(y);

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

	delete[] mat2;

	return 0;
}

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

	int chs = mat.channels();
	int width = mat.cols;
	int height = mat.rows;

	fbc::Mat_<float, 3> mat1(height, width, mat.data);
	std::vector<fbc::Mat_<float, 1>> vecMat2;
	fbc::Mat_<float, 1>* mat2 = new fbc::Mat_<float, 1>[chs];
	for (int i = 0; i < chs; i++) {
		mat2[i] = fbc::Mat_<float, 1>(height, width);
		vecMat2.push_back(mat2[i]);
	}

	fbc::split(mat1, vecMat2);

	cv::Mat mat1_(height, width, CV_32FC3, mat.data);
	std::vector<cv::Mat> vecMat2_;
	cv::split(mat1_, vecMat2_);

	assert(vecMat2.size() == vecMat2_.size());
	for (int i = 0; i < vecMat2.size(); i++) {
		assert(vecMat2[i].rows == vecMat2_[i].rows && vecMat2[i].cols == vecMat2_[i].cols);
		assert(vecMat2[i].step == vecMat2_[i].step);
		assert(vecMat2[i].channels == vecMat2_[i].channels());

		for (int y = 0; y < vecMat2[i].rows; y++) {
			const fbc::uchar* p = vecMat2[i].ptr(y);
			const uchar* p_ = vecMat2_[i].ptr(y);

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

	delete[] mat2;

	return 0;
}

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



fengbingchun
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【opencv-c++】cv::merge通道合并
jn10010537的博客
10-04 1122
图像通道的分离，参考博客： 【opencv-c++】cv::split通道分离 https://blog.csdn.net/jn10010537/article/details/127159126cv::merge是cv::split函数的逆向操作，cv::merge将多个数组组合成更多通道数的多通道数组! 简而言之，cv::merge将多个单通道图像合并为一个多通道的图像。cv::merge的函数 注意：可以看到merge通过函数重载，有两个实现。
opencv-split-merge.zip
05-28
在“opencv-split-merge.zip”这个压缩包中，我们很可能是得到了一个关于如何使用OpenCV进行图像拆分和合并的教程或示例代码。 图像拆分是指将一张图像分割成多个部分，这在处理多区域图像、提取特定特征或进行像素...
opencv中的merge函数
热门推荐
alickr的博客
05-27 2万+
该函数用来合并通道 原型 void merge(const Mat* mv, size_t count, OutputArray dst); 第一个参数是图像矩阵数组，第二个参数是需要合并矩阵的个数，第三个参数是输出 void merge(const vector& mv, OutputArray dst );第一个参数是图像矩阵向量容器，第二个参数是输出，这种方法无需说
opencv merge使用
最新发布
weixin_48329769的博客
05-02 369
函数也提供了相同的功能，用于合并多个单通道或多通道的图像。函数将这两个图像合并成一个多通道的图像。最后，显示合并后的图像。函数用于将多个单通道或多通道的图像合并成一个多通道的图像。在这个例子中，我们首先读取了两个图像，然后创建了一个。容器来保存这两个图像。在C++中，OpenCV的。
OpenCv——merge（）函数数据合并
helloword111222的博客
10-06 3203
import numpy as np import matplotlib.pyplot as plt import cv2 image=cv2.imread("dog.jpg")#读取要处理的图片 B,G,R = cv2.split(image) #分离出图片的B，R，G颜色通道 zeros = np.zeros(image.shape[:2],dtype="uint8")#创建与image相同大小的零矩阵 re_image=cv2.merge([R,G,B]).
【OpenCV】OpenCV函数精讲之 -- 通道合并：merge()函数
中科院AI算法工程师的博客
12-05 4014
merge()函数是将多个数组合并成一个多通道的数组。将一些孤立的单通道数组合并成一个多通道数组，创建一个由多个单通道阵列组成的多通道阵列。 merge()函数的C++有两个版本： void merge(const Mat& mv, size_tcount, OutputArray dst); void merge(InputArrayOfArray mv, OutputArray ...
OpenCV split函数与merge函数
WuDong
12-17 1162
split Divides a multi-channel array into several single-channel arrays. C++: void split(const Mat&amp; src, Mat* mvbegin) C++: void split(InputArray m, OutputArrayOfArrays mv) Python: cv2.split(m[...
OpenCV Mat实例详解三源代码
02-15
在处理多通道图像时，`Mat::split`和`Mat::merge`函数分别用于拆分和合并通道。这些函数对于处理RGB或BGR图像尤其有用。 此外，`Mat::col`和`Mat::row`成员函数可以提取矩阵的列或行，形成新的`Mat`对象。这对于...
Opencv 函数功能总结.zip
07-10
**OpenCV 函数功能总结** OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉库，它包含了众多图像处理和计算机视觉的算法，广泛应用于图像分析、识别、追踪、重建等领域。以下是对OpenCV中一些...
OpenCV实现多通道图像混合（C++实现）.zip
04-12
此外，还可以结合其他OpenCV函数进行预处理（如直方图均衡化、滤波）或后处理（如边缘检测、轮廓提取）。 在给定的压缩包文件"OpenCV实现多通道图像混合（C++实现）"中，包含的项目代码很可能是为了演示或测试这种...
Opencv实现傅里叶变换
08-27
Opencv是一个功能强大的计算机视觉库，它提供了许多有用的函数和类来实现图像处理和计算机视觉任务。傅里叶变换是信号处理和图像处理的基本工具，它可以将图像从空域转换到频域，从而实现图像的频率域分析。Opencv...
Opencv的merge函数-通道合并
qq_23880193的专栏
08-27 3784
#include #include #include using namespace std; using namespace cv; int main() { Mat blue_channels = imread("【蓝色通道】.jpg"); Mat green_channels = imread("【绿色通道】.jpg"); Mat red_channels = imread("【红
毛星云opencv之5.3分离颜色通道之merge函数
weixin_52634719的博客
10-26 188
我只是抄了关键代码，运行，然后啥事也没有发生 #include <opencv2/opencv.hpp> #include<opencv2/core/core.hpp> #include"opencv2/highgui/highgui.hpp" #include<opencv2/imgproc/imgproc.hpp> #include<iostream> using namespace std; using namespace cv; int main
Qt-OpenCV学习笔记--基本函数操作--cv::merge（图像通道合并）
ssismm的博客
11-02 1422
另外，cv::merge()用于实现图像通道的合并，是split的逆向操作。在OpenCV中，cv::split()用于实现图像通道的分离。在图像处理中，有时需要对各个通道进行分离，分别处理。
opencv split和merge操作
crkres9527
01-11 2723
#include   #include   #include   #include   using namespace cv;   using namespace std;   int main()   {       Mat srcImage=imread("e:/huangshan.jpg");       Mat imageBlue,imageGreen,imageRed;
opencv：通道合并—merge()函数
南国之邱
05-11 3715
函数原型如下：
OpenCV-通道合并cv::merge
翟天保的博客
06-05 1万+
函数原型：void merge(const Mat* mv, size_t count, OutputArray dst);
【知识---OpenCV库中的图像处理的基本操作--cv::resize、cv::cvtColor、cv::split 、 cv::merge、cv::Rect、cv::flip等】
fyc300的博客
01-22 1600
OpenCV（Open Source Computer Vision Library）是一款开源的计算机视觉和机器学习软件库。它提供了一套全面的工具，用于图像和视频处理、计算机视觉以及机器学习。图像处理： OpenCV提供了广泛的图像处理功能，涵盖了从基本操作到高级计算机视觉和图像处理任务的广泛范围，包括调整大小、裁剪、旋转、阈值处理、滤波和形态学操作等。这些操作对于操作和增强图像至关重要。以上就是OpenCV中的有关于图像的一些基本操作，如有不足之处，还请大家斧正！！！
opencv c++ （5）：通道分离与合并
m0_59156726的博客
11-07 415
很简单，就split和merge api，例子在下面。
cv::split和cv::merge区被
06-09
cv::split 和 cv::merge 是 OpenCV 中用于多通道图像处理的函数。 cv::split 函数可以将一个多通道的矩阵分离成多个单通道的矩阵，存储在一个 vector 中。例如，将一个 RGB 彩色图像分离成三个单通道的矩阵，分别...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值