使用某些系数将图像转换为灰度的最快方法
Fastest way of converting image to grayscale using certain coefficients
我需要使用自定义公式将cv::Mat转换为灰度。输入矩阵的每个通道必须乘以某个系数。
这是操作的伪代码：
Y = 0.2126*R + 0.7152*G + 0.0722*B
输入矩阵是CV_32FC3，输出必须为CV_32FC1.
使用2用于循环的简单循环并顺序计算每个像素似乎还不够快。
int rows = src.rows, cols = src.cols;
for (int row = 0; row < rows; row++){
const float* src_ptr = src.ptr<float>(row);
float* dst_ptr = dst.ptr<float>(row);
for (int col = 0; col < cols; col++){
dst_ptr[col] = ( 0.0722 * src_ptr[0] ) + ( 0.7152 * src_ptr[1] ) + ( 0.2126 * src_ptr[2]);
src_ptr += 3;
}
}
是否有更有效的方法可以做到这一点？我希望使用parallel_for_周期，但我无法自己弄清楚。
这是我一直在研究的无法正常工作的解决方案：
void MyOperator::getIntensity(const cv::Mat& src, cv::Mat& dst){
int nElements = src.cols * src.rows;
parallel_for_(cv::Range(0,nElements) , BGR2rec709Parallel((float*)src.data, (float*)dst.data));
}
class BGR2rec709Parallel : public cv::ParallelLoopBody
{
private:
float *src;
float *dst;
public:
BGR2rec709Parallel(float* src_ptr, float* dst_ptr) : src(src_ptr), dst(dst_ptr) {}
virtual void operator()( const cv::Range &r ) const
{
for (int i = r.start; i != r.end; ++i)
{
dst[i] = ( 0.0722 * src[i] ) + ( 0.7152 * src[i+1] ) + ( 0.2126 * src[i+2]);
}
}
virtual ~BGR2rec709Parallel();
};
主要问题是您不正确索引源数据。
for (int i = r.start; i != r.end; ++i)
{
dst[i] = ( 0.0722 * src[i] )
+ ( 0.7152 * src[i+1] )
+ ( 0.2126 * src[i+2]);
}
让我们想象r.start == 0和r.end == 2。然后，此代码等同于：
dst[0] = ( 0.0722 * src[0] ) + ( 0.7152 * src[1] ) + ( 0.2126 * src[2]);
dst[1] = ( 0.0722 * src[1] ) + ( 0.7152 * src[2] ) + ( 0.2126 * src[3]);
请注意，src的值最终被重复使用 - 这无疑是不可取的。问题在于src包含3倍的值与dst一样多，因此其索引的增长速度应快3倍。
for (int i = r.start; i != r.end; ++i)
{
dst[i] = ( 0.0722 * src[i * 3] )
+ ( 0.7152 * src[i * 3 + 1] )
+ ( 0.2126 * src[i * 3 + 2]);
}
这应该使并行版本正常工作，但是还有更多的改进。
可以通过制作系数float而不是double（例如0.0722f而不是0.0722）来制作明显的改进（单线版本中〜30％，并行版本约为10％）。这是一定精确的，但避免了不必要的转换（并且可以更好地矢量化）。
不要使用C风格的演员。在BGR2rec709Parallel((float*)src.data, (float*)dst.data)中，您应该使用reinterpret_cast<float>。甚至更好，就像您在第一个版本中使用的那样，可以利用cv::Mat::ptr（即src.ptr<float>()，dst.ptr<float>()）。
使用parallel_for_的方式不是理想的：
int nElements = src.cols * src.rows;
parallel_for_(cv::Range(0, nElements), /* ... */);
您没有指定第三个参数（nstripes）。根据我的观察结果（OPENCV 3.1.0/MSVS2013和3.4.3/MSVC2015），结果是operator()的范围为1。单像素。
通过将nstripes设置为cv::getNumThreads()可以看到显着改进。这将导致工作每个工作线程最多分为1个范围，范围相似。
并行版本无法再处理不连续的Mat s（例如拍摄更大图像的ROI的结果），第一个版本是这样做的。
要解决此问题，parallel_for_应该用行而不是像素来工作，并且其上下文应参考输入和输出Mat S而不是数据指针。
将工作分为等于线程数量的条纹数量并不重要，因为处理一行已经包含大量工作，但是我们仍然可以做到。
哦，再提一下。for (int i = r.start; i != r.end; ++i)- !=在这里要求麻烦，以防您将i增加超过1。更喜欢在此处使用<。
最终版本看起来像这样：
class BGR2rec709ParallelC
: public cv::ParallelLoopBody
{
public:
BGR2rec709ParallelC(cv::Mat const& src, cv::Mat& dst)
: src(src), dst(dst)
{
CV_Assert(src.type() == CV_32FC3);
CV_Assert(dst.type() == CV_32FC1);
CV_Assert(src.size() == dst.size());
}
virtual void operator()(const cv::Range &r) const
{
for (int row(r.start); row < r.end; ++row) {
convert_row(src.ptr<float>(row), dst.ptr<float>(row));
}
}
private:
void convert_row(float const* src_ptr, float * dst_ptr) const
{
for (int i(0); i != src.cols; ++i) {
dst_ptr[i] = (0.0722f * src_ptr[i * 3])
+ (0.7152f * src_ptr[i * 3 + 1])
+ (0.2126f * src_ptr[i * 3 + 2]);
}
}
private:
cv::Mat const& src;
cv::Mat& dst;
};
void get_intensity_v4(cv::Mat const& src, cv::Mat& dst)
{
parallel_for_(cv::Range(0, src.rows)
, BGR2rec709ParallelC(src, dst)
, cv::getNumThreads());
}
完整的测试程序比较各种实现的性能：
#include <opencv2/opencv.hpp>
void get_intensity_base(cv::Mat const& src, cv::Mat& dst)
{
cv::cvtColor(src, dst, cv::COLOR_BGR2GRAY);
}
void get_intensity_v1a(cv::Mat const& src, cv::Mat& dst)
{
int rows = src.rows, cols = src.cols;
for (int row(0); row < rows; ++row) {
float const* src_ptr = src.ptr<float>(row);
float* dst_ptr = dst.ptr<float>(row);
for (int col(0); col < cols; ++col, src_ptr += 3) {
dst_ptr[col] = static_cast<float>((0.0722 * src_ptr[0])
+ (0.7152 * src_ptr[1])
+ (0.2126 * src_ptr[2]));
}
}
}
void get_intensity_v1b(cv::Mat const& src, cv::Mat& dst)
{
int rows = src.rows, cols = src.cols;
for (int row(0); row < rows; ++row) {
float const* src_ptr = src.ptr<float>(row);
float* dst_ptr = dst.ptr<float>(row);
for (int col(0); col < cols; ++col, src_ptr += 3) {
dst_ptr[col] = (0.0722f * src_ptr[0])
+ (0.7152f * src_ptr[1])
+ (0.2126f * src_ptr[2]);
}
}
}
class BGR2rec709ParallelA
: public cv::ParallelLoopBody
{
public:
BGR2rec709ParallelA(float const* src, float* dst) : src(src), dst(dst) {}
virtual void operator()(cv::Range const& r) const
{
for (int i(r.start); i < r.end; ++i) {
dst[i] = static_cast<float>((0.0722 * src[i * 3])
+ (0.7152 * src[i * 3 + 1])
+ (0.2126 * src[i * 3 + 2]));
}
}
private:
float const* src;
float* dst;
};
class BGR2rec709ParallelB
: public cv::ParallelLoopBody
{
public:
BGR2rec709ParallelB(float const* src, float* dst) : src(src), dst(dst) {}
virtual void operator()(cv::Range const& r) const
{
for (int i(r.start); i < r.end; ++i) {
dst[i] = (0.0722f * src[i * 3])
+ (0.7152f * src[i * 3 + 1])
+ (0.2126f * src[i * 3 + 2]);
}
}
private:
float const* src;
float* dst;
};
template <typename LoopBody>
void get_intensity_v2(cv::Mat const& src, cv::Mat& dst)
{
int nElements = src.cols * src.rows;
parallel_for_(cv::Range(0, nElements)
, LoopBody(src.ptr<float>(), dst.ptr<float>()));
}
template <typename LoopBody>
void get_intensity_v3(cv::Mat const& src, cv::Mat& dst)
{
int nElements = src.cols * src.rows;
parallel_for_(cv::Range(0, nElements)
, LoopBody(src.ptr<float>(), dst.ptr<float>())
, cv::getNumThreads());
}
class BGR2rec709ParallelC
: public cv::ParallelLoopBody
{
public:
BGR2rec709ParallelC(cv::Mat const& src, cv::Mat& dst)
: src(src), dst(dst)
{
CV_Assert(src.type() == CV_32FC3);
CV_Assert(dst.type() == CV_32FC1);
CV_Assert(src.size() == dst.size());
}
virtual void operator()(const cv::Range &r) const
{
for (int row(r.start); row < r.end; ++row) {
convert_row(src.ptr<float>(row), dst.ptr<float>(row));
}
}
private:
void convert_row(float const* src_ptr, float * dst_ptr) const
{
for (int i(0); i != src.cols; ++i) {
dst_ptr[i] = (0.0722f * src_ptr[i * 3])
+ (0.7152f * src_ptr[i * 3 + 1])
+ (0.2126f * src_ptr[i * 3 + 2]);
}
}
private:
cv::Mat const& src;
cv::Mat& dst;
};
void get_intensity_v4(cv::Mat const& src, cv::Mat& dst)
{
parallel_for_(cv::Range(0, src.rows)
, BGR2rec709ParallelC(src, dst)
, cv::getNumThreads());
}
cv::Mat test(std::string const& name
, cv::Mat const& input
, void(*fn)(cv::Mat const&, cv::Mat&))
{
cv::Mat output(input.size(), CV_32FC1); // pre-allocate
std::cout << name << "n";
int64 min_ticks(0x7FFFFFFFFFFFFFFF);
for (int i(0); i < 32; ++i) {
int64 t_start(cv::getTickCount());
fn(input, output);
int64 t_stop(cv::getTickCount());
min_ticks = std::min(min_ticks, t_stop - t_start);
}
std::cout << " >= " << min_ticks << " ticksn";
return output;
}
cv::Mat3f make_test_data(int rows, int cols)
{
cv::Mat m(rows, cols, CV_16UC3);
cv::randu(m, 0, 0x10000);
cv::Mat3f result;
m.convertTo(result, CV_32FC3, 1.0 / 0xFFFF);
return result;
}
int main()
{
cv::Mat input(make_test_data(4096, 4096));
test("Base", input, get_intensity_base);
cv::Mat out_v1a = test("V1A", input, get_intensity_v1a);
cv::Mat out_v1b = test("V1B", input, get_intensity_v1b);
cv::Mat out_v2a = test("V2A", input, get_intensity_v2<BGR2rec709ParallelA>);
cv::Mat out_v2b = test("V2B", input, get_intensity_v2<BGR2rec709ParallelB>);
cv::Mat out_v3a = test("V3A", input, get_intensity_v3<BGR2rec709ParallelA>);
cv::Mat out_v3b = test("V3B", input, get_intensity_v3<BGR2rec709ParallelB>);
cv::Mat out_v4 = test("V4", input, get_intensity_v4);
std::cout << "Differences V1A vs V2A: " << cv::countNonZero(out_v1a != out_v2a) << "n";
std::cout << "Differences V1B vs V2B: " << cv::countNonZero(out_v1b != out_v2b) << "n";
std::cout << "Differences V1B vs V3B: " << cv::countNonZero(out_v1b != out_v3b) << "n";
std::cout << "Differences V1B vs V4: " << cv::countNonZero(out_v1b != out_v4) << "n";
return 0;
}
控制台输出（OPENCV 3.1.0/MSVC2013/x64/i7-4930k）：
Base
>= 126365 ticks
V1A
>= 500890 ticks
V1B
>= 331197 ticks
V2A
>= 746851 ticks
V2B
>= 704011 ticks
V3A
>= 148181 ticks
V3B
>= 134176 ticks
V4
>= 133750 ticks
Differences V1A vs V2A: 0
Differences V1B vs V2B: 0
Differences V1B vs V3B: 0
Differences V1B vs V4: 0
控制台输出（OPENCV 3.4.3/MSVC2015/x64/i7-4930k）：
Base
>= 123620 ticks
V1A
>= 503707 ticks
V1B
>= 331801 ticks
V2A
>= 1768515 ticks
V2B
>= 1710579 ticks
V3A
>= 145451 ticks
V3B
>= 135767 ticks
V4
>= 131438 ticks
Differences V1A vs V2A: 0
Differences V1B vs V2B: 0
Differences V1B vs V3B: 0
Differences V1B vs V4: 0
注意：请注意，精细粒度parallel_for_版本在这里！
更新：
正如Nuzhny所建议的那样，这是使用cv::Mat::forEach和lambda的实现。
void get_intensity_v5(cv::Mat const& src, cv::Mat& dst)
{
CV_Assert(src.type() == CV_32FC3);
CV_Assert(dst.type() == CV_32FC1);
CV_Assert(src.size() == dst.size());
dst.forEach<float>(
[&](float& pixel, int const* po) -> void
{
cv::Vec3f const& in_pixel(src.at<cv::Vec3f>(po));
pixel = (0.0722f * in_pixel[0])
+ (0.7152f * in_pixel[1])
+ (0.2126f * in_pixel[2]);
}
);
}
其他控制台输出：
V5
>= 123071 ticks
Differences V1B vs V5: 0
，在这一点上，老实说，我无法解释为什么这样做得更好-forEach实现parallel_for_由行块...
相关文章：
- 在 C++ 中将 RGB 更改为灰度
- OpenCV - 如何在灰度图像上应用 Kmeans?
- OpenCV - 如何将灰度转换为彩色(CV_8UC3）?
- C++灰度图像处理
- 如何显示具有 opengl 纹理的灰度图像
- C++ Gdi+将图像转换为灰度
- 将 BMP 图像转换为灰度
- 如何使用Canny到32位灰度
- 颜色到灰度转换
- (C++）(Visual Studio） 将高斯模糊滤镜应用于 RGB 中的灰度图像
- 使用 SSE 以最快的速度缩小 8 位灰度图像
- 使用 OpenCV 和 C++将 16 位灰度图像更改为彩色图像
- 有没有办法使用 glDrawPixel 渲染单通道灰度图像?
- goodFeaturesToTrack(） 只适用于灰度?
- 如何在OpenCV中减去两个不同尺寸的图像和灰度图像
- 使用 ImageMagick 从像素强度数组创建灰度图像时遇到问题
- 如何将图像转换为灰度 opengl c++
- 使用某些系数将图像转换为灰度的最快方法
- 在不使用OpenCV的情况下对帧进行灰度处理的有效方法
- 有没有一种方法可以在同一张图像上同时拥有灰度和rgb像素opencv C++
