使用某些系数将图像转换为灰度的最快方法

时间：2019-03-09 21:23:05

标签： c++ opencv c++11 parallel-processing parallel-for

我需要使用自定义公式将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();
};

1 个答案:

答案 0 :(得分：2)

主要问题是您没有正确索引源数据。

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包含的值是dst的3倍，因此其索引的增长速度应快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，可以显着改善（在单线程版本中约为30％，在并行版本中约为10％）。 0.0722）。这是以一定的精度为代价的，但是避免了不必要的转换（并且可以更好地向量化）。

不要使用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。这会导致一些相当讨厌的开销，尤其是当使用大小范围时1对应一个像素。

将nstripes设置为cv::getNumThreads()可以看到明显的改进。这将导致工作在每个工作线程中被划分为1个范围，且范围类似。

并行版本不再能够处理不连续的Mat（例如，获得较大图像的ROI的结果），

要解决此问题，parallel_for_应该使用行而不是像素，并且其上下文应该是对输入和输出Mat的引用，而不是数据指针。

在这里将工作分成与线程数相等的条带数量并不重要，因为处理一行已经包含了大量的工作，但是我们仍然可以做到这一点。

哦，还有一个要提。 for (int i = r.start; i != r.end; ++i)-如果您将!=增加1以上，这里的i会带来麻烦。在这里最好使用<。

最终版本如下：

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 << " ticks\n";

    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_并按行分块...

相关问题
最新问题