add parallel_for_ to elementWise

Author: AleksandrPanov

modules/mcc/perf/perf_mcc.cpp

@@ -36,7 +36,8 @@ PERF_TEST(CV_mcc_perf, infer) {
     ColorCorrectionModel model(chartsRGB.col(1).clone().reshape(3, chartsRGB.rows/3) / 255., COLORCHECKER_Macbeth);
     model.run();
 
-    Mat img = randomMat(Size(4000, 1000), CV_8UC3);
+    Mat img(1000, 4000, CV_8UC3);
+    randu(img, 0, 255);
     img.convertTo(img, CV_64F, 1. / 255.);
 
     TEST_CYCLE() {

modules/mcc/perf/perf_precomp.hpp

@@ -6,14 +6,13 @@
 #define __OPENCV_PERF_PRECOMP_HPP__
 
 #include "opencv2/ts.hpp"
-#include "opencv2/ts/cuda_test.hpp"
 #include "opencv2/mcc.hpp"
-#include "opencv2/mcc/ccm.hpp"
 
 namespace opencv_test
 {
 using namespace cv::mcc;
 using namespace cv::ccm;
+using namespace perf;
 }
 
 #endif

modules/mcc/src/ccm.cpp

@@ -289,14 +289,13 @@ Mat ColorCorrectionModel::infer(const Mat& img, bool islinear)
         CV_Error(Error::StsBadArg, "No CCM values!" );
     }
     Mat img_lin = (p->linear)->linearize(img);
-    Mat img_ccm(img_lin.size(), img_lin.type());
-    Mat ccm_ = p->ccm.reshape(0, p->shape / 3);
-    img_ccm = multiple(p->prepare(img_lin), ccm_);
+    Mat ccm = p->ccm.reshape(0, p->shape / 3);
+    Mat img_ccm = multiple(p->prepare(img_lin), ccm);
     if (islinear == true)
     {
         return img_ccm;
     }
-    return p->cs.fromLFunc(img_ccm);
+    return p->cs.fromLFunc(img_ccm, img_lin);
 }
 
 void ColorCorrectionModel::Impl::getColor(CONST_COLOR constcolor)

modules/mcc/src/colorspace.cpp

@@ -150,7 +150,7 @@ void RGBBase_::calOperations()
 
 Mat RGBBase_::toLFunc(Mat& /*rgb*/) const { return Mat(); }
 
-Mat RGBBase_::fromLFunc(Mat& /*rgbl*/, Mat dst) const { return Mat(); }
+Mat RGBBase_::fromLFunc(Mat& /*rgbl*/, Mat dst) const { return dst; }
 
 /* @brief Base of Adobe RGB color space;
  */
@@ -159,7 +159,7 @@ Mat AdobeRGBBase_::toLFunc(Mat& rgb) const { return gammaCorrection(rgb, gamma);
 
 Mat AdobeRGBBase_::fromLFunc(Mat& rgbl, Mat dst) const
 {
-    return gammaCorrection(rgbl, 1. / gamma);
+    return gammaCorrection(rgbl, 1. / gamma, dst);
 }
 
 /* @brief Base of sRGB color space;
@@ -203,7 +203,7 @@ Mat sRGBBase_::toLFunc(Mat& rgb) const
 
 /* @brief Used by fromLFunc.
  */
-double sRGBBase_::fromLFuncEW(double& x) const
+double sRGBBase_::fromLFuncEW(const double& x) const
 {
     if (x > beta)
     {
@@ -225,8 +225,7 @@ double sRGBBase_::fromLFuncEW(double& x) const
  */
 Mat sRGBBase_::fromLFunc(Mat& rgbl, Mat dst) const
 {
-    return elementWise(rgbl,
-            [this](double a_) -> double { return fromLFuncEW(a_); });
+    return elementWise(rgbl, [this](double a_) -> double { return fromLFuncEW(a_); }, dst);
 }
 
 /* @brief sRGB color space.

modules/mcc/src/colorspace.hpp

@@ -167,7 +167,7 @@ class sRGBBase_ : public RGBBase_
 
     /** @brief Used by fromLFunc.
     */
-    double fromLFuncEW(double& x) const;
+    double fromLFuncEW(const double& x) const;
 
     /** @brief Delinearization.
         @param rgbl the input array, type of cv::Mat.

modules/mcc/src/utils.cpp

@@ -30,14 +30,14 @@
 namespace cv {
 namespace ccm {
 
-double gammaCorrection_(const double& element, const double& gamma)
+inline double gammaCorrection_(const double& element, const double& gamma)
 {
     return (element >= 0 ? pow(element, gamma) : -pow((-element), gamma));
 }
 
-Mat gammaCorrection(const Mat& src, const double& gamma)
+Mat gammaCorrection(const Mat& src, const double& gamma, Mat dst)
 {
-    return elementWise(src, [gamma](double element) -> double { return gammaCorrection_(element, gamma); });
+    return elementWise(src, [gamma](double element) -> double { return gammaCorrection_(element, gamma); }, dst);
 }
 
 Mat maskCopyTo(const Mat& src, const Mat& mask)

modules/mcc/src/utils.hpp

@@ -42,8 +42,9 @@ double gammaCorrection_(const double& element, const double& gamma);
             \f]
     @param src the input array,type of Mat.
     @param gamma a constant for gamma correction.
+    @param dst the output array, type of Mat.
  */
-Mat gammaCorrection(const Mat& src, const double& gamma);
+Mat gammaCorrection(const Mat& src, const double& gamma, Mat dst=Mat());
 
 /** @brief maskCopyTo a function to delete unsatisfied elementwise.
     @param src the input array, type of Mat.
@@ -77,10 +78,26 @@ Mat rgb2gray(const Mat& rgb);
     @param lambda a for operation
  */
 template <typename F>
-Mat elementWise(const Mat& src, F&& lambda)
+Mat elementWise(const Mat& src, F&& lambda, Mat dst=Mat())
 {
-    Mat dst = src.clone();
+    if (dst.empty() || !dst.isContinuous() || dst.total() != src.total() || dst.type() != src.type())
+        dst = Mat(src.rows, src.cols, src.type());
     const int channel = src.channels();
+    if (src.isContinuous()) {
+        const int num_elements = (int)src.total()*channel;
+        const double *psrc = (double*)src.data;
+        double *pdst = (double*)dst.data;
+        const int batch = getNumThreads() > 1 ? 128 : num_elements;
+        const int N = (num_elements / batch) + ((num_elements % batch) > 0);
+        parallel_for_(Range(0, N),[&](const Range& range) {
+            const int start = range.start * batch;
+            const int end = std::min(range.end*batch, num_elements);
+            for (int i = start; i < end; i++) {
+                pdst[i] = lambda(psrc[i]);
+            }
+        });
+        return dst;
+    }
     switch (channel)
     {
     case 1: