1. 介绍
图像处理的算法复杂度通常都比较高，计算也相应比较耗时。利用CPU多线程处理能力可以大幅度加快计算速度。但是，为了保证多线程处理的结果和单线程处理的结果完全相同，图像的多线程计算有一些需要特别考虑的地方。
基本思路：为了能让多个线程同时并行处理，那么各自处理的数据不能有交集，这很好理解。那么基本思路是将一副图像分成多个子块，每个子块数据肯定是没有交集的，每个线程对一个子块数据进行处理，完成后将所有子块处理结果合成最终图像。
首先，每个子块的大小当然是必须考虑的问题。通常当应用进行一个较长时间的操作，应该用合适的方式告知用户。既然我们把图像分子块处理，如果单个子块处理时间很短，那么每当有一个子块的数据处理完成，我们就可以立即把它相应的处理结果展示给用户。用户就会看到这个图像各个部分的处理结果不断展示出来，直至整个图像完成。这样某种程度上用这种方式就是在告知用户正在处理进行中，避免为了把整个图像处理完成，用户需要等待太长时间。从这个角度来说，如果子块尺寸取的太大，每个子块计算时间肯定相应地加长，对于快速显示部分处理结果给用户是不利的。但是如果子块太小，子块总数就会增加，肯定会增加线程开销和其他一些开销（分割图像，分配子块数据等等），对于总的计算时间是不利的。这是一个权衡问题，可以根据具体情况确定。
另外，很多图像处理都要考虑像素领域范围的信息，因此对于每个子块的处理不能仅仅使用这个子块的内容。具体地，对于靠近子块边缘的像素，还要把子块外的部分像素信息考虑进来，加入计算，才能保证相应像素的处理结果是正确的。准确来说，如果领域半径为r（对方形或圆形领域来说，其他领域可做相应调整），那么子块处理所需要的所有数据是子块四周向外扩展r像素的范围。
2. 实现代码
#include "stdafx.h"
#include <cv.h>
#include <highgui.h>
#include "pthread.h"
#include <time.h>
using namespace cv;
using namespace std;
#ifndef uchar
#define uchar unsigned char
#endif
#ifndef MAX
#define MAX(x, y) (((x) >= (y)) ? (x) : (y))
#endif
#ifndef MIN
#define MIN(x, y) (((x) >= (y)) ? (y) : (x))
#endif
#define CLAMP_XY(x, y) (((x) < 0) ? 0 : ((x) > (y) ? (y) : (x)))
#define AXJ_BLUE 0
#define AXJ_GREEN 1
#define AXJ_RED 2
#define BMPFORMAT_RGB32_R8G8B8A8 4
typedef struct __tag_bmpinfo
{
unsigned int dwPixelFormat;
int lWidth;
int lHeight;
int lPitch[3];
unsigned char* pPlane[3];
}BMPINFO, *LPBMPINFO;
typedef struct __filter_info
{
BMPINFO *pSrcBitmap;
float intensity;
int param0;
int param1;
} FilterInfo, *PFilterInfo;
// 转黑白图像
void ConvertToBlackWhite(BMPINFO *pSrcBitmap)
{
uchar lightness = 0, max_val = 0, min_val = 0;
uchar * pSrcData = pSrcBitmap-> pPlane[0];
int size = pSrcBitmap->lWidth * pSrcBitmap->lHeight;
for (int i = 0; i < size; i++, pSrcData += 4)
{
max_val = MAX(MAX(pSrcData[AXJ_BLUE], pSrcData[AXJ_GREEN]), pSrcData[AXJ_RED]);
min_val = MIN(MIN(pSrcData[AXJ_BLUE], pSrcData[AXJ_GREEN]), pSrcData[AXJ_RED]);
lightness = (max_val + min_val + 1) / 2;
pSrcData[AXJ_BLUE] = pSrcData[AXJ_GREEN] = pSrcData[AXJ_RED] = lightness;
}
}
// 计算线程
void* ImageFilterThread(void *arg)
{
FilterInfo *filter_info = (FilterInfo *)arg;
BMPINFO *pSrcBitmap = filter_info->pSrcBitmap;
int intensity = (int)CLAMP_XY(filter_info->intensity * 256, 256);
uchar *dataCopy = (uchar *)malloc(pSrcBitmap->lPitch[0] * pSrcBitmap->lHeight);
memcpy(dataCopy, pSrcBitmap->pPlane[0], pSrcBitmap->lPitch[0] * pSrcBitmap->lHeight);
// 以彩色图像转黑白图像为例(印象里ps3就是这个算法)
ConvertToBlackWhite(pSrcBitmap);
// 输出结果
uchar *src_data = dataCopy;
uchar *dst_data = pSrcBitmap->pPlane[0];
int size = pSrcBitmap->lWidth * pSrcBitmap->lHeight;
for (int i = 0; i < size; i++, src_data += 4, dst_data += 4)
{
dst_data[0] = (src_data[0] * (256 - intensity) + dst_data[0] * intensity) >> 8;
dst_data[1] = (src_data[1] * (256 - intensity) + dst_data[1] * intensity) >> 8;
dst_data[2] = (src_data[2] * (256 - intensity) + dst_data[2] * intensity) >> 8;
}
free(dataCopy);
dataCopy = NULL;
return NULL;
}
// 分块计算
void ImageFilterCommon(BMPINFO *pSrcBitmap, int block_count)
{
// 计算分块参数
int block_src_height = pSrcBitmap->lHeight / block_count;
int block_src_size = pSrcBitmap->lPitch[0] * block_src_height;
pthread_t *block_thread = (pthread_t *)malloc(block_count * sizeof(pthread_t));
BMPINFO *block_src_bmp = (BMPINFO *)malloc(block_count * sizeof(BMPINFO));
FilterInfo *filter_info_array = (FilterInfo *)malloc(block_count * sizeof(FilterInfo));
// 前n-1块
int i = 0;
for (i = 0; i < block_count - 1; i++)
{
memset(&block_src_bmp[i], 0, sizeof(BMPINFO));
memset(&filter_info_array[i], 0, sizeof(FilterInfo));
block_src_bmp[i].dwPixelFormat = BMPFORMAT_RGB32_R8G8B8A8;
block_src_bmp[i].lWidth = pSrcBitmap->lWidth;
block_src_bmp[i].lHeight = block_src_height;
block_src_bmp[i].lPitch[0] = pSrcBitmap->lPitch[0];
block_src_bmp[i].pPlane[0] = pSrcBitmap->pPlane[0] + block_src_size * i;
filter_info_array[i].pSrcBitmap = &block_src_bmp[i];
filter_info_array[i].intensity = 0.8f;
pthread_create(&block_thread[i], NULL, ImageFilterThread, &filter_info_array[i]);
}
// 最后一块
i = block_count - 1;
memset(&block_src_bmp[i], 0, sizeof(BMPINFO));
memset(&filter_info_array[i], 0, sizeof(FilterInfo));
block_src_bmp[i].dwPixelFormat = BMPFORMAT_RGB32_R8G8B8A8;
block_src_bmp[i].lWidth = pSrcBitmap->lWidth;
block_src_bmp[i].lHeight = pSrcBitmap->lHeight - block_src_height * i;
block_src_bmp[i].lPitch[0] = pSrcBitmap->lPitch[0];
block_src_bmp[i].pPlane[0] = pSrcBitmap->pPlane[0] + block_src_size * i;
filter_info_array[i].pSrcBitmap = &block_src_bmp[i];
filter_info_array[i].intensity = 0.8f;
pthread_create(&block_thread[i], NULL, ImageFilterThread, &filter_info_array[i]);
// 阻塞主线程, 等待分块计算完成
for (i = 0; i < block_count; i++)
{
pthread_join(block_thread[i], NULL);
}
// todo 结果合成
// 类似于调色这样的计算, 不需要将各个块合成整幅图像
// 但如果涉及空间计算, 每个块间需要有重叠部分, 此时需要针对算法特点, 编写合成方法
// 释放资源
free(block_src_bmp);
block_src_bmp = NULL;
free(filter_info_array);
filter_info_array = NULL;
free(block_thread);
block_thread = NULL;
}
int main()
{
const char* fileName = "test.png";
Mat src = imread(fileName);
imshow("src", src);
BMPINFO srcbmp = {
0 }, texbmp = {
0 }, texbmp2 = {
0 }, lutbmp = {
0 };
srcbmp.dwPixelFormat = BMPFORMAT_RGB32_R8G8B8A8;
srcbmp.lWidth = src.cols;
srcbmp.lHeight = src.rows;
srcbmp.lPitch[0] = srcbmp.lWidth * 4;
srcbmp.pPlane[0] = (unsigned char*)malloc(srcbmp.lPitch[0] * srcbmp.lHeight);
uchar *pTempData = src.data;
uchar *pdata = srcbmp.pPlane[0];
for (int i = 0; i < src.rows * src.cols; i++, pdata += 4, pTempData += 3)
{
pdata[0] = pTempData[0];
pdata[1] = pTempData[1];
pdata[2] = pTempData[2];
pdata[3] = 255;
}
///
clock_t startTime = clock();
ImageFilterCommon(&srcbmp, 4);
printf("the time is.... %d ms\n", clock() - startTime);
///
Mat dst(cv::Size(srcbmp.lWidth, srcbmp.lHeight), src.type());
pTempData = dst.data;
pdata = srcbmp.pPlane[0];
for (int i = 0; i < dst.rows * dst.cols; i++, pdata += 4, pTempData += 3)
{
pTempData[0] = pdata[0];
pTempData[1] = pdata[1];
pTempData[2] = pdata[2];
}
imshow("dst", dst);
cv::waitKey();
return 0;
}