OpenCV:如何对带有图像的文件夹进行批量处理
OpenCV: how to perform batch processing of folder with images?
我有一个图像文件夹，我对它们执行一些基本操作：
- 加载源映像
- 对图像执行一些图像处理
- 保存结果图像
所以我想在单独的线程中处理每个图像以加快处理速度。
这是我的示例代码：
ThreadExample.h
#include <thread>
class ThreadProcessing
{
static unsigned int concurentThreadsSupported;
static void ImageProcessingFunction(const std::string &input_dir, const std::string &filename);
public:
void PrintNumberOfCPU();
void MultithreadingProcessing(const std::string &dir, int N);
void SingleThreadProcessing(const std::string &dir);
};
ThreadExample.cpp
#include "ThreadExample.h"
unsigned int ThreadProcessing::concurentThreadsSupported = std::thread::hardware_concurrency();
using namespace std;
void ThreadProcessing::PrintNumberOfCPU()
{
cout << "Number of CPU : " << concurentThreadsSupported << endl;
}
void ThreadProcessing::ImageProcessingFunction(const string &input_dir, const string &filename)
{
Mat src= imread(input_dir+"/"+filename);
Mat dst;
for(int i=0; i<10; ++i)
{
medianBlur(src, dst, 71);
}
boost::filesystem::path name= path(filename).stem();
string output_filename= (input_dir/name).string()+"_output.png";
imwrite(output_filename, dst);
}
void ThreadProcessing::SingleThreadProcessing(const string &dir)
{
time_t SingleThreadProcessingTime = clock();
vector<string> imageNames= GetAllFilenamesInDir(dir, ".jpg");
for(int i=0; i<(int)imageNames.size(); ++i)
{
ImageProcessingFunction(dir, imageNames[i]);
}
SingleThreadProcessingTime = clock() - SingleThreadProcessingTime;
cout << "SingleThreadProcessingTime : " << (float(SingleThreadProcessingTime) / CLOCKS_PER_SEC) << endl;
}
void ThreadProcessing::MultithreadingProcessing(const string &dir, int N)
{
time_t MultithreadingProcessingTime = clock();
std::thread threads[N];
bool isAllImageProcessed= false;
vector<string> imageNames= GetAllFilenamesInDir(dir, ".jpg");
for(int i=0; i<(int)imageNames.size();)
{
//Launch a group of threads
for(int k= 0; k< N; ++k)
{
threads[k] = std::thread(ImageProcessingFunction, dir, imageNames[i]);
i++;
if(i>=(int)imageNames.size())
{
N= k+1;
isAllImageProcessed= true;
break;
}
}
//Join the threads with the main thread
for(int k= 0; k< N; ++k)
{
threads[k].join();
}
if(isAllImageProcessed)
break;
}
MultithreadingProcessingTime = clock() - MultithreadingProcessingTime;
cout << "MultithreadingProcessingTime : " << (float(MultithreadingProcessingTime) / CLOCKS_PER_SEC) << endl;
}
main.cpp
int main(int argc, char** argv)
{
ThreadProcessing threadProcessing;
threadProcessing.PrintNumberOfCPU();
threadProcessing.SingleThreadProcessing("/home/user/Images");
threadProcessing.MultithreadingProcessing("/home/user/Images", 1);
cout << "Done." << endl;
return 0;
}
但速度似乎没有提高：
当我使用1个线程时，输出为：
Number of CPU : 8
SingleThreadProcessingTime : 6.54173
MultithreadingProcessingTime : 6.73393
Done.
当我使用4个线程时，输出为：
Number of CPU : 8
SingleThreadProcessingTime : 6.39089
MultithreadingProcessingTime : 8.3365
Done.
我的代码有什么问题还是概念上有什么问题？
更新：
我还尝试了两种变体：
- 每个映像1个线程-似乎这种方法可以达到OS限制的最大线程数？而且效率低下
代码：
void ThreadProcessing::SingleThreadForEachImage(const string &dir)
{
time_t SingleThreadForEachImageTime = clock();
vector<string> imageNames= GetAllFilenamesInDir(dir, ".jpg");
int N= imageNames.size();
std::thread threads[imageNames.size()];
for(int i=0; i<N; ++i)
{
threads[i] = std::thread(ImageProcessingFunction, dir, imageNames[i]);
}
for(int i=0; i<N; ++i)
{
threads[i].join();
}
SingleThreadForEachImageTime = clock() - SingleThreadForEachImageTime;
cout << "SingleThreadForEachImageTime : " << (float(SingleThreadForEachImageTime) / CLOCKS_PER_SEC) << endl;
}
- 将图像分割为N个块，并在单独的线程中处理每个块
代码：
vector<vector<string>> ThreadProcessing::SplitNamesVector(const vector<string> &imageNames, int N)
{
vector<vector<string>> imageNameChunks;
int K=0; //Number images in chunk
if(imageNames.size()%N==0)
K= imageNames.size()/N;
else
K= imageNames.size()/N+1;
vector<string> chunk;
for(int i=0; i<(int)imageNames.size(); ++i)
{
chunk.push_back(imageNames[i]);
if(i%K==0 && i!=0)
{
imageNameChunks.push_back(chunk);
chunk.clear();
}
}
if(chunk.size()!=0)
imageNameChunks.push_back(chunk);
assert((int)imageNameChunks.size()==N);
return imageNameChunks;
}
void ThreadProcessing::EachThreadProcessChunkOfImages(const std::string &dir, int N)
{
time_t EachThreadProcessChunkOfImagesTime = clock();
N= std::min(N, (int)concurentThreadsSupported);
std::thread threads[N];
vector<string> imageNames= GetAllFilenamesInDir(dir, ".jpg");
vector<vector<string>> imageNameChunks= SplitNamesVector(imageNames, N);
//Launch a group of threads
for(int k= 0; k< N; ++k)
{
threads[k] = std::thread(ImageProcessingFunctionChunk, dir, imageNameChunks[k]);
}
for(int k= 0; k< N; ++k)
{
threads[k].join();
}
EachThreadProcessChunkOfImagesTime = clock() - EachThreadProcessChunkOfImagesTime;
cout << "EachThreadProcessChunkOfImagesTime : " << (float(EachThreadProcessChunkOfImagesTime) / CLOCKS_PER_SEC) << endl;
}
以下是结果(MultithreadingProcessing和EachThreadProcessChunkOfImages使用4个线程)：
SingleThreadProcessingTime : 13.552
MultithreadingProcessingTime : 15.581
SingleThreadForEachImageTime : 26.7727
EachThreadProcessChunkOfImagesTime : 15.9078
更新2:
我也做了一个没有IO操作的测试，只有图像处理。
代码：
void ThreadProcessing::ImageProcessingFunction(const cv::Mat &img)
{
Mat dst;
for(int i=0; i<10; ++i)
{
medianBlur(img, dst, 71);
}
}
vector<Mat> ThreadProcessing::LoadBatchOfImages(const std::string &dir, int batchSize)
{
vector<string> imageNames= GetAllFilenamesInDir(dir, ".jpg");
vector<Mat> imageVec;
for(int i=0; i<N; ++i)
{
string filename= dir+"/"+imageNames[i];
Mat img= imread(filename);
imageVec.push_back(img);
}
return imageVec;
}
void ThreadProcessing::OnlyProcessingTimeSequential(const std::string &dir, int batchSize)
{
//Load batch of images
vector<Mat> imageVec= LoadBatchOfImages(dir, batchSize);
assert((int)imageVec.size() == batchSize);
cout << "imageVec.size() : " << imageVec.size() << endl;
time_t OnlyProcessingTimeSequentialTime = clock();
for(int i=0; i<batchSize; ++i)
{
ImageProcessingFunction(imageVec[i]);
}
OnlyProcessingTimeSequentialTime = clock() - OnlyProcessingTimeSequentialTime;
cout << "OnlyProcessingTimeSequentialTime : " << (float(OnlyProcessingTimeSequentialTime) / CLOCKS_PER_SEC) << endl;
}
void ThreadProcessing::OnlyProcessingTimeMultithread(const std::string &dir, int batchSize)
{
//Load batch of images
vector<Mat> imageVec= LoadBatchOfImages(dir, batchSize);
assert((int)imageVec.size() == batchSize);
cout << "imageVec.size() : " << imageVec.size() << endl;
time_t OnlyProcessingTimeMultithread = clock();
std::thread threads[batchSize];
for(int i=0; i<batchSize; ++i)
{
threads[i] = std::thread(ImageProcessingFunction, imageVec[i]);
}
for(int i=0; i<batchSize; ++i)
{
threads[i].join();
}
OnlyProcessingTimeMultithread = clock() - OnlyProcessingTimeMultithread;
cout << "OnlyProcessingTimeMultithread : " << (float(OnlyProcessingTimeMultithread) / CLOCKS_PER_SEC) << endl;
}
我发现当使用多线程代码时，clock()会给出错误的结果，所以我使用time ./MyBinary
结果如下：
imageVec.size() : 8
OnlyProcessingTimeSequentialTime : 2.34174
Done.
real 0m2.551s
user 0m2.640s
sys 0m0.316s
imageVec.size() : 8
OnlyProcessingTimeMultithread : 4.36681
Done.
real 0m0.861s
user 0m4.564s
sys 0m0.404s
正如我们所看到的，real时间较小。
所以之前的结果应该是：
SingleThreadProcessingTime : 13.6235
real 0m13.845s
user 0m13.932s
sys 0m0.280s
MultithreadingProcessingTime : 21.0902
real 0m3.584s
user 0m20.356s
sys 0m1.316s
SingleThreadForEachImageTime : 23.961
real 0m3.370s
user 0m22.584s
sys 0m1.976s
EachThreadProcessChunkOfImagesTime : 20.7885
real 0m3.433s
user 0m20.292s
sys 0m1.116s
那么，应该如何衡量多线程代码的执行时间呢？
更新：在此处找到答案
我需要使用wallclock time而不是cpu time
以下是正确的结果：
SingleThreadProcessing : WALLCLOCK TIME: 13.8245 seconds
MultithreadingProcessing : WALLCLOCK TIME: 4.1977 seconds
SingleThreadForEachImage : WALLCLOCK TIME: 3.25084 seconds
EachThreadProcessChunkOfImages : WALLCLOCK TIME: 3.36626 seconds
OnlyProcessingTimeSequential : WALLCLOCK TIME: 2.36041 seconds
OnlyProcessingTimeMultithread : WALLCLOCK TIME: 0.706921 seconds
正如这个问题中明确指出的那样，当涉及到单个磁盘上的I/O操作时，多线程实际上并不高效。您的线程所做的大部分工作都是I/O操作。
您可能受到磁盘速度的限制，并且由于创建线程和join()操作而产生的开销会降低函数的多线程版本。
编辑：
正如@Dan Mašek在评论中所说，大部分时间实际上都花在了压缩上。改进进程的一种方法是创建一个线程，从磁盘中读取映像并将其提供给其他工作线程(可能通过queue，请参阅线程池)。这样，你可以按顺序阅读，但繁重的工作是由很多工人完成的。
相关文章：
- 如何将更多文件夹添加到c++include路径
- GetShortPathName在网络驱动器上使用中文文件夹时失败
- VS2017，C++包含目录与附加包含目录，子文件夹包含失败-但为什么
- 在 Windows 上，是否可以让 dll 在不使用 PATH 环境变量的情况下在另一个文件夹中查找依赖项？
- 如何在文档文件夹中创建目录
- "assimp/config.h"找不到，但它在文件夹中
- C++入门 5 版:类消息和文件夹
- 我可以在 Arduino 的库文件夹之外安装库吗?
- 如何按文件扩展名引用文件夹中的文件
- 在QTreeView中仅显示共享驱动器和文件夹
- 加载与引用 .NET DLL 位于同一文件夹中的引用的 .NET DLL 时"Not found"异常
- 介子复制/安装头文件到输出目录并保持文件夹结构
- vcruntime.h 从 Windows 包含文件夹中丢失?
- 在文件夹迭代上实现 RAII
- 对桌面进行了更改.ini使用批处理文件，但文件夹图标不会更改
- OpenCV:如何对带有图像的文件夹进行批量处理
- 将队列处理为包含文件的文件夹.可能存在的问题
- 如何在删除或处理文件夹树时处理符号链接和连接
- 如何为 Ctags 无法处理的 MSVC 文件夹的所有头文件生成C++标签文件？
- 如何处理 opencv 算法文件夹中的图像
