2. 程式人生 > >OpenCV使用pthread實現多執行緒加速處理影象（C++）

OpenCV使用pthread實現多執行緒加速處理影象（C++）

阿新 • • 發佈：2019-02-06

OpenCV使用pthread實現多執行緒加速處理影象

目錄

    POSIX執行緒（POSIX threads），簡稱Pthreads，是執行緒的POSIX標準。Pthread是由POSIX提出的一套通用的執行緒庫，在linux平臺下，它被廣泛的支援，而在windows平臺下，需要下載pthreads-w32庫。之所以選擇Pthreads庫作為多執行緒處理庫，是因此Android NDK開發時，可以使用pthread在C++中實現多執行緒處理，這樣，可以方便OpenCV的影象加速處理和演算法的移植。

1.pthread多執行緒加速

     下面是使用多執行緒（3個子執行緒）實現OpenCV影象加速的的方法，基本思路就是：先將影象分塊，比如分成3塊，每塊使用一個子執行緒進行處理，處理完後再合併成一塊影象，這樣就實現了OpenCV多執行緒加速影象處理的方法。

// pthreadDemo.cpp : 定義控制檯應用程式的入口點。
//

#include <stdio.h>
#include <pthread.h>
#include <assert.h>
#include <string>
#include <opencv2/opencv.hpp>
using namespace std;
#define THREAD_NUMS 3

/*paramThread用於傳遞執行緒需要的引數值*/
struct paramThread
{
	int w;
	int h;
	uchar * data;
};

/********************************************************
*	@brief       : 多執行緒處理函式
*	@param  args : 多執行緒傳入的引數
*	@return      : void
********************************************************/
void * threadProcess(void* args) {

	pthread_t myid = pthread_self();
	paramThread *para = (paramThread *)args;
	int w = para->w;
	int h = para->h;
	cv::Mat image(h,w,CV_8UC3,(uchar *)para->data);
	//cv::cvtColor(image, image, cv::COLOR_BGR2RGB);
	cv::blur(image, image,cv::Size(7,7), cv::Point(-1, -1), cv::BORDER_REPLICATE);
	//printf("thread id = %d, w=%d, h=%d\n", myid, w,h);
	//cv::imshow("image", image); cv::waitKey(2000);
	pthread_exit(NULL);
	return NULL;
}

/********************************************************
*	@brief       : 實現影象分割，
*	@param  num  :  分割個數
*	@param  type : 0：垂直分割(推薦)，1：水平分割（不推薦）
*	@return      : vector<cv::Mat>
*   PS：使用水平分割時（type=1），處理完後必須呼叫catImage進行拼接，
*   使用垂直分割時（type=0），可以不進行catImage，因為是對原圖進行操作的
********************************************************/
vector<cv::Mat> splitImage(cv::Mat image, int num,int type) {
	int rows = image.rows;
	int cols = image.cols;
	vector<cv::Mat> v;
	if (type == 0) {//垂直分割
		for (size_t i = 0; i < num; i++) {
			int star = rows / num*i;
			int end = rows / num*(i + 1);
			if (i == num - 1) {
				end = rows;
			}
			//cv::Mat b = image.rowRange(star, end);
			v.push_back(image.rowRange(star, end));
		}
	}
	else if (type == 1) {//水平分割
		for (size_t i = 0; i < num; i++){
			int star = cols / num*i;
			int end = cols / num*(i + 1);
			if (i == num - 1) {
				end = cols;
			}
			//cv::Mat b = image.colRange(star, end);
			/*解決水平分割的Bug:必須clone()*/
			v.push_back(image.colRange(star, end).clone());
		}
	}
	return  v;
}

/********************************************************
*	@brief       : 實現影象拼接，
*	@param  v    :  
*	@param  type : 0：垂直拼接，1：水平拼接
*	@return      : Mat
********************************************************/
cv::Mat catImage(vector<cv::Mat> v, int type) {
	cv::Mat dest= v.at(0);
	for (size_t i = 1; i < v.size(); i++)
	{
		if (type == 0)//垂直拼接
		{
			cv::vconcat(dest, v.at(i), dest);
		}
		else if (type == 1)//水平拼接
		{
			cv::hconcat(dest, v.at(i), dest);
		}
	}
	return dest;
}

int main() {
	string path = "D:\\imageEnhance\\images\\test.jpg";
	cv::Mat src = cv::imread(path);
	printf("image size =  w=%d, h=%d\n", src.cols, src.rows);

	cv::Mat image1 = src.clone();
	cv::Mat image2 = src.clone();
	cv::imshow("src", src); cv::waitKey(30);

	double T0 = static_cast<double>(cv::getTickCount());
	/*不使用多執行緒影象處理*/
	cv::blur(image1, image1, cv::Size(7, 7));
	double T1 = static_cast<double>(cv::getTickCount());

	/*使用多執行緒影象處理*/
	int type = 0;
	vector<cv::Mat> v = splitImage(image2, THREAD_NUMS, type);
	paramThread args[THREAD_NUMS];
	pthread_t pt[THREAD_NUMS];	//建立THREAD_NUMS個子執行緒
	for (size_t i = 0; i < THREAD_NUMS; i++)
	{
		args[i].h = v.at(i).rows;
		args[i].w = v.at(i).cols;
		args[i].data = v.at(i).data;
		pthread_create(&pt[i], NULL, &threadProcess, (void *)(&args[i]));
	}
	/*等待全部子執行緒處理完畢*/
	for (size_t i = 0; i < THREAD_NUMS; i++)
	{
		pthread_join(pt[i], NULL);
	}
	cv::Mat dest = catImage(v, type);
	double T2 = static_cast<double>(cv::getTickCount());
	printf("       run times = %3.3fms\n", (T1 - T0)*1000 / cv::getTickFrequency());
	printf("Thread run times = %3.3fms\n,", (T2 - T1)*1000 / cv::getTickFrequency());

	cv::imshow("dest", dest); cv::waitKey(30);
	cv::imshow("image2", image2); cv::waitKey(30);


	cv::waitKey(0);
	return 0;
}

     可以看到，對於一張3000*1877的大圖片，使用3個執行緒並行處理會比單執行緒處理快了將近4倍的速度。但比較尷尬的是，由於使用了影象分塊處理，進行影象blur模糊時，邊界會出現不規則的畫素，這時拼接在一起，會導致影象拼接的邊緣出現橫條的現象，見下面的模糊圖。

     一種決解的方法就是，可以在影象分割時，根據kernel size的大小的適當padding畫素，處理完再cutting這些padding的畫素，這部分我還沒有實現，有興趣的可以搞搞哈。

    這種使用pthread實現多執行緒影象處理加速方法，比較適合演算法過程跟邊界處理無關的情況，如RGB轉BGR，Gamma變換這些影象處理操作。

2.自己封裝的多執行緒cvThread類

    為了方面以後呼叫，這裡封裝了一個cvThread類：

    cvThread.h：

#pragma once
#include <stdio.h>
#include <pthread.h>
#include <assert.h>
#include <string>
#include <opencv2/opencv.hpp>
using namespace std;

class cvThread
{
public:
	cvThread();
	~cvThread();
	/*paramThread用於傳遞執行緒需要的引數值*/
	struct paramThread
	{
		int w;
		int h;
		uchar * data;
	};

	/********************************************************
	*	@brief       : 多執行緒要處理的影象操作
	*	@param  args : 多執行緒傳入的引數
	*	@return      : void
	********************************************************/
	static void * cvThreadBlur(void* args);

	/********************************************************
	*	@brief        : 多執行緒處理函式
	*	@param  image : 輸入/輸出Mat影象
	*	@param  type  : 分割型別0：垂直分割(推薦)，1：水平分割（不推薦）
	*	@param  thread_num : 多執行緒個數
	*	@return      : void
	********************************************************/
	void  cvThreadProcess(cv::Mat &image, const int type, const int thread_num);
	void  cvThreadProcess(cv::Mat &image);
	/********************************************************
	*	@brief       : 實現影象分割，
	*	@param  num  :  分割個數
	*	@param  type : 0：垂直分割(推薦)，1：水平分割（不推薦）
	*	@return      : vector<cv::Mat>
	*   PS：使用水平分割時（type=1），處理完後必須呼叫catImage進行拼接，
	*   使用垂直分割時（type=0），可以不進行catImage，因為是對原圖進行操作的
	********************************************************/
	vector<cv::Mat> splitImage(cv::Mat image, int num, int type);


	/********************************************************
	*	@brief       : 實現影象拼接，
	*	@param  v    :
	*	@param  type : 0：垂直拼接，1：水平拼接
	*	@return      : Mat
	********************************************************/
	cv::Mat catImage(vector<cv::Mat> v, int type);
};

    cvThread.cpp：

#include "cvThread.h"



cvThread::cvThread()
{
}


cvThread::~cvThread()
{
}
/********************************************************
*	@brief       : 多執行緒處理函式
*	@param  args : 多執行緒傳入的引數
*	@return      : void
********************************************************/
void * cvThread::cvThreadBlur(void* args) {
	pthread_t myid = pthread_self();
	paramThread *para = (paramThread *)args;
	int w = para->w;
	int h = para->h;
	cv::Mat image(h, w, CV_8UC3, (uchar *)para->data);
	/***************************************************/
	/*這裡實現多執行緒要處理的影象操作*/
	cv::blur(image, image, cv::Size(7, 7), cv::Point(-1, -1), cv::BORDER_REPLICATE);

	/***************************************************/
	pthread_exit(NULL);
	return NULL;
}



#define THREAD_NUMS 4
void  cvThread::cvThreadProcess(cv::Mat &image) {

	/*使用多執行緒影象處理*/
	int type = 0;
	vector<cv::Mat> v = splitImage(image, THREAD_NUMS, type);
	paramThread args[THREAD_NUMS];
	pthread_t pt[THREAD_NUMS];	//建立thread_num個子執行緒
	for (size_t i = 0; i < THREAD_NUMS; i++)
	{
		args[i].h = v.at(i).rows;
		args[i].w = v.at(i).cols;
		args[i].data = v.at(i).data;
		pthread_create(&pt[i], NULL, &cvThreadBlur, (void *)(&args[i]));
	}
	/*等待全部子執行緒處理完畢*/
	for (size_t i = 0; i < THREAD_NUMS; i++)
	{
		pthread_join(pt[i], NULL);
	}
	cv::Mat dest = catImage(v, type);
}

void  cvThread::cvThreadProcess(cv::Mat &image,const int type=0,const int thread_num=4) {
	/*使用多執行緒影象處理*/
	vector<cv::Mat> v = splitImage(image, thread_num, type);
	paramThread *args = new paramThread[thread_num];
	pthread_t *pt = new pthread_t[thread_num];	//建立thread_num個子執行緒
	for (size_t i = 0; i < thread_num; i++)
	{
		args[i].h = v.at(i).rows;
		args[i].w = v.at(i).cols;
		args[i].data = v.at(i).data;
		pthread_create(&pt[i], NULL, &cvThreadBlur, (void *)(&args[i]));
	}
	/*等待全部子執行緒處理完畢*/
	for (size_t i = 0; i < thread_num; i++)
	{
		pthread_join(pt[i], NULL);
	}
	/*PS：使用水平分割時（type = 1），處理完後必須呼叫catImage進行拼接，
	使用垂直分割時（type = 0），可以不進行catImage，因為是對原圖進行操作的*/
	if (type==1)
	{
		image = catImage(v, type);
	}
	delete []args;
	delete []pt;
}
/********************************************************
*	@brief       : 實現影象分割，
*	@param  num  :  分割個數
*	@param  type : 0：垂直分割(推薦)，1：水平分割（不推薦）
*	@return      : vector<cv::Mat>
*   PS：使用水平分割時（type=1），處理完後必須呼叫catImage進行拼接，
*   使用垂直分割時（type=0），可以不進行catImage，因為是對原圖進行操作的
********************************************************/
vector<cv::Mat> cvThread::splitImage(cv::Mat image, int num, int type) {
	int rows = image.rows;
	int cols = image.cols;
	vector<cv::Mat> v;
	if (type == 0) {//垂直分割
		for (size_t i = 0; i < num; i++) {
			int star = rows / num*i;
			int end = rows / num*(i + 1);
			if (i == num - 1) {
				end = rows;
			}
			//cv::Mat b = image.rowRange(star, end);
			v.push_back(image.rowRange(star, end));
		}
	}
	else if (type == 1) {//水平分割
		for (size_t i = 0; i < num; i++) {
			int star = cols / num*i;
			int end = cols / num*(i + 1);
			if (i == num - 1) {
				end = cols;
			}
			//cv::Mat b = image.colRange(star, end);
			/*解決水平分割的Bug:必須clone()*/
			v.push_back(image.colRange(star, end).clone());
		}
	}
	return  v;
}

/********************************************************
*	@brief       : 實現影象拼接，
*	@param  v    :
*	@param  type : 0：垂直拼接，1：水平拼接
*	@return      : Mat
********************************************************/
cv::Mat cvThread::catImage(vector<cv::Mat> v, int type) {
	cv::Mat dest = v.at(0);
	for (size_t i = 1; i < v.size(); i++)
	{
		if (type == 0)//垂直拼接
		{
			cv::vconcat(dest, v.at(i), dest);
		}
		else if (type == 1)//水平拼接
		{
			cv::hconcat(dest, v.at(i), dest);
		}
	}
	return dest;
}

    測試方法main.cpp:

#include <stdio.h>
#include <pthread.h>
#include <assert.h>
#include <string>
#include <opencv2/opencv.hpp>
#include "cvThread.h"
using namespace std;
int main() {
	string path = "D:\\imageEnhance\\images\\8-1.jpg";
	cv::Mat src = cv::imread(path);
	printf("image size =  w=%d, h=%d\n", src.cols, src.rows);

	cv::Mat image1 = src.clone();
	cv::Mat image2 = src.clone();
	cv::imshow("src", src); cv::waitKey(30);
	double T0 = static_cast<double>(cv::getTickCount());
	/*不使用多執行緒影象處理*/
	cv::blur(image1, image1, cv::Size(7, 7));
	double T1 = static_cast<double>(cv::getTickCount());
	/*使用多執行緒影象處理*/
	cvThread cvth;
	cvth.cvThreadProcess(image2,0,4);
	double T2 = static_cast<double>(cv::getTickCount());
	printf("       run times = %3.3fms\n", (T1 - T0)*1000 / cv::getTickFrequency());
	printf("Thread run times = %3.3fms\n,", (T2 - T1)*1000 / cv::getTickFrequency());
	cv::imshow("image1", image1); cv::waitKey(30);
	cv::imshow("image2", image2); cv::waitKey(30);

	cv::waitKey(0);
	return 0;
}

相關推薦

OpenCV使用pthread實現多執行緒加速處理影象（C++）

OpenCV使用pthread實現多執行緒加速處理影象 目錄     POSIX執行緒（POSIX threads），簡稱Pthreads，是執行緒的POSIX標準。Pthread是由POSIX提出的一套通用的執行緒庫，在linux平臺下，它被廣泛的支援，

使用nanomsg庫實現多執行緒之間的通訊（二）

概述：       這次是nanomsg庫實現的一個類似於MQTT通訊的一種方式，廣播訂閱的一個一對多的通訊方式。一個主的廣播訊息，其他可以訂閱自己想要的主題資訊，然後就會只接收訂閱的主題的資訊。 PubSub一對多主題訂閱通訊Demo #include <std

使用nanomsg庫實現多執行緒之間的通訊（三）

概述：    這次使用nanomsg庫實現多執行緒一對多的雙向通訊，其實類似一個伺服器，其他均為客戶端，且它們之間是長連線，所以伺服器可以主動和客戶端通訊，客戶端也可以和伺服器通訊，這樣的一個方式。 多執行緒一對多雙向通訊Demo #include <stdio.

Qt實現多執行緒的簡單例子（VS2015Professional+Qt5.7.1）

這個例子是在參考教材略微改了一下。      主要實現的是單擊開始按鈕啟動數個工作執行緒，工作執行緒數目由一個巨集定義的常數決定，各個執行緒迴圈列印數字0~9,直到按下停止按鈕，終止所有執行緒。

PYTHON——多執行緒：訊號量（Semaphore）

　　訊號量也是一把鎖，用來控制執行緒併發數的。 　　BoundedSemaphore或Semaphore管理一個內建的計數 器，每當呼叫acquire()時-1，呼叫release()時+1。       計數器不能小於0，當計數器為 0時，acquire()將阻塞執行緒至同

PYTHON——多執行緒：條件變數（Condition）

　　條件變數（Condition）也是一把鎖，除了同步鎖的作用外，還具有線上程間通訊的功能。 　　有一類執行緒需要滿足條件之後才能夠繼續執行，Python提供了threading.Condition 物件用於條件變數執行緒的支援，它除了能提供RLock()或Lock()的方法外，還提供了 wait()、no

Windows遍歷全盤所搜檔案，並通過多執行緒顯示搜尋進度（C++/C）

程式設計軟體，系統 軟體：VS2017 工程屬性：MFC對話方塊（其他工程屬性稍作修改也適用） 系統：windows10家庭版 主要思想 1、利用CFileFind實現查詢檔案 2、利用遞迴實現全盤搜尋 3、多執行緒實現父對話方塊搜尋檔案時，子對話方塊顯示搜尋進度 軟體執行效

C++多執行緒中的future（期望）

Providers std::promise 和std::future配合使用，給std::future傳遞期望值，下面是最簡單的一個用法： #include <iostream> #include <functional> #include <

多執行緒斷點續傳（二）

一、 學習內容 1、 多檔案下載列表的顯示 2、 啟動多個執行緒分段下載 二、 多執行緒下載原理簡介 假設要分3個執行緒下載一個100位元組的檔案：從頭到尾，每個執行緒下載一段 三、 學習點 1、 Adapter的getCount() 2、 A

多執行緒斷點續傳（一）

一、 學習內容 1、 基本UI定義 2、 資料庫的操作 3、 Service的啟動 4、 Activity給service傳遞引數 5、 使用廣播回傳資料到Activity 6、 執行緒和Handler 7、 網路操作：檔案的寫入，網路往本地磁碟寫入 二、 網路下

Java多執行緒之基礎篇（二）

上一篇介紹了Java多執行緒的基礎概念和synchronized關鍵字，這篇繼續介紹Java多執行緒的其他關鍵字和重要的方法。 一、volatile關鍵字 1.1 Java記憶體模型

Java多執行緒之基礎篇（一）

一、併發和並行 1.1 概念 1.2 比較 1.3 程序和執行緒 二、基礎概念 2.1 執

Java多執行緒程式設計學習總結（二）

  （尊重勞動成果，轉載請註明出處：https://blog.csdn.net/qq_25827845/article/details/84894463冷血之心的部落格） 系列文章： Java多執行緒程式設計學習總結（一） Java多執行緒程式設計學習總結（二） 前

Android多執行緒-----併發和同步（volatile）

volatile是Java提供的一種輕量級的同步機制，在併發程式設計中，它也扮演著比較重要的角色。同synchronized相比（synchronized通常稱為重量級鎖），volatile更輕量級，相比使用synchronized所帶來的龐大開銷，倘若能恰當的合理的使用volatile，自然是好事

Android多執行緒-----併發和同步（Lock）

一、為什麼需要Lock 如果一個程式碼塊被synchronized修飾了，當一個執行緒獲取了對應的鎖，並執行該程式碼塊時，其他執行緒便只能一直等待，等待獲取鎖的執行緒釋放鎖，而這裡獲取鎖的執行緒釋放鎖只會有兩種情況： 1）獲取鎖的執行緒執行完了該程式碼塊，然後執行緒釋放對鎖的佔有； 2）執行緒執

Android多執行緒-----併發和同步（synchronized）

一、鎖 物件的內建鎖和物件的狀態之間是沒有內在的關聯的，雖然大多數類都將內建鎖用做一種有效的加鎖機制，但物件的域並不一定通過內建鎖來保護。當獲取到與物件關聯的內建鎖時，並不能阻止其他執行緒訪問該物件，當某個執行緒獲得物件的鎖之後，只能阻止其他執行緒獲得同一個鎖。之所以每個物件都有一個內建鎖，是為

Android多執行緒-----併發和同步（ThreadLocal）

一.對ThreadLocal的理解        很多地方叫做執行緒本地變數，也有些地方叫做執行緒本地儲存，其實意思差不多。可能很多朋友都知道ThreadLocal為變數在每個執行緒中都建立了一個副本，那麼每個執行緒可以訪問自己內部的副本變數，也就是進行資

Java 多執行緒程式設計學習總結（一）

定義篇 程序(Process)和執行緒(Thread) 怎樣實現多工處理（Multitasking）？ 多工處理是同時執行多個任務的過程。我們使用多工處理來利用 CPU。可通過兩種方式實現多工處理: · 基於程序的多工 (多重處理) · 基於執行緒的多工處理

java多執行緒之併發集合（CopyOnWriteArrayList）

CopyOnWriteArrayList:CopyOnWriteArrayList這是一個ArrayList的執行緒安全的變體，其原理大概可以通俗的理解為:初始化的時候只有一個容器，很常一段時間，這個容器資料、數量等沒有發生變化的時候，大家(多個執行緒)，都是讀取(假設這段時

多執行緒的那些事兒（2）－－　程序與執行緒的區別與聯絡

　　在進行多執行緒程式設計之前我們先解決一個基本問題：什麼是執行緒、什麼是程序，他們之間有什麼區別與聯絡。 （1）程序：執行環境                   執行緒：執行單位         用書面一點的知說，程序是一個計算機中程式執行的一個實體，執行緒是作業系