cv-image-deblurring: codestyle fix

Signed-off-by: Andrey Parfenov <a1994ndrey@gmail.com>

5 files changed, 40 insertions, 71 deletions

diff --git a/modules/ocl/cv_image_process_helper.cpp b/modules/ocl/cv_image_process_helper.cpp
index 9698acc..0d08289 100644
--- a/modules/ocl/cv_image_process_helper.cpp
+++ b/modules/ocl/cv_image_process_helper.cpp
@@ -25,7 +25,7 @@ namespace XCam {
 
 
 CVImageProcessHelper::CVImageProcessHelper ()
-    : CVBaseClass()
+    : CVBaseClass ()
 {
 
 }
@@ -34,11 +34,11 @@ cv::Mat
 CVImageProcessHelper::erosion (const cv::Mat &image, int erosion_size, int erosion_type)
 {
     cv::Mat element = cv::getStructuringElement (erosion_type,
-                      cv::Size(2 * erosion_size + 1, 2 * erosion_size + 1 ),
-                      cv::Point(erosion_size, erosion_size));
+                      cv::Size (2 * erosion_size + 1, 2 * erosion_size + 1),
+                      cv::Point (erosion_size, erosion_size));
     cv::Mat eroded;
     cv::erode (image, eroded, element);
-    return eroded.clone();
+    return eroded.clone ();
 }
 
 float
@@ -55,17 +55,6 @@ CVImageProcessHelper::get_snr (const cv::Mat &noisy, const cv::Mat &noiseless)
     return res;
 }
 
-cv::Mat
-CVImageProcessHelper::get_auto_correlation (const cv::Mat &image)
-{
-    cv::Mat dst;
-    cv::Laplacian (image, dst, -1, 3, 1, 0, cv::BORDER_CONSTANT);
-    dst.convertTo (dst, CV_32FC1);
-    cv::Mat correlation;
-    cv::filter2D (dst, correlation, -1, dst, cv::Point(-1, -1), 0, cv::BORDER_CONSTANT);
-    return correlation.clone ();
-}
-
 void
 CVImageProcessHelper::compute_dft (const cv::Mat &image, cv::Mat &result)
 {
@@ -73,7 +62,7 @@ CVImageProcessHelper::compute_dft (const cv::Mat &image, cv::Mat &result)
     int m = cv::getOptimalDFTSize (image.rows);
     int n = cv::getOptimalDFTSize (image.cols);
     cv::copyMakeBorder (image, padded, 0, m - image.rows, 0, n - image.cols, cv::BORDER_CONSTANT, cv::Scalar::all(0));
-    cv::Mat planes[] = {cv::Mat_<float>(padded), cv::Mat::zeros(padded.size(), CV_32FC1)};
+    cv::Mat planes[] = {cv::Mat_<float> (padded), cv::Mat::zeros (padded.size (), CV_32FC1)};
     cv::merge (planes, 2, result);
     cv::dft (result, result);
 }
@@ -103,24 +92,11 @@ CVImageProcessHelper::apply_constraints (cv::Mat &image, float threshold_min_val
     }
 }
 
-// weights will be symmetric and sum(weights elements) == 1
 void
 CVImageProcessHelper::normalize_weights (cv::Mat &weights)
 {
     weights.convertTo (weights, CV_32FC1);
-    float sum = 0;
-    for (int i = 0; i < weights.rows; i++)
-    {
-        for (int j = 0; j <= i; j++)
-        {
-            weights.at<float>(i, j) = (weights.at<float>(i, j) + weights.at<float>(j, i)) / 2;
-            weights.at<float>(j, i) = weights.at<float>(i, j);
-            if (j == i)
-                sum += weights.at<float>(i, j);
-            else
-                sum += (2 * weights.at<float>(i, j));
-        }
-    }
+    float sum = cv::sum (weights)[0];
     weights /= sum;
 }
 
diff --git a/modules/ocl/cv_image_process_helper.h b/modules/ocl/cv_image_process_helper.h
index d1dbb72..137ff6b 100644
--- a/modules/ocl/cv_image_process_helper.h
+++ b/modules/ocl/cv_image_process_helper.h
@@ -37,12 +37,10 @@ public:
 
     void compute_dft (const cv::Mat &image, cv::Mat &result);
     void compute_idft (cv::Mat *input, cv::Mat &result);
-    void apply_constraints (cv::Mat &image, float threshold_min_value, float threshold_max_value = 255.0f, float min_value = 0.0f, float max_value = 255.0f);
+    void apply_constraints (cv::Mat &image, float threshold_min_value = 0.0f, float threshold_max_value = 255.0f, float min_value = 0.0f, float max_value = 255.0f);
     float get_snr (const cv::Mat &noisy, const cv::Mat &noiseless);
     cv::Mat erosion (const cv::Mat &image, int erosion_size, int erosion_type);
-    // weights will be symmetric and sum(weights elements) == 1
     void normalize_weights (cv::Mat &weights);
-    cv::Mat get_auto_correlation (const cv::Mat &image);
 
     XCAM_DEAD_COPY (CVImageProcessHelper);
 };
diff --git a/modules/ocl/cv_image_sharp.cpp b/modules/ocl/cv_image_sharp.cpp
index 7ca087b..0a309af 100644
--- a/modules/ocl/cv_image_sharp.cpp
+++ b/modules/ocl/cv_image_sharp.cpp
@@ -25,7 +25,7 @@ namespace XCam {
 
 
 CVImageSharp::CVImageSharp ()
-    : CVBaseClass()
+    : CVBaseClass ()
 {
 
 }
@@ -36,34 +36,24 @@ CVImageSharp::sharp_image_gray (const cv::Mat &image, float sigmar)
     cv::Mat temp_image;
     image.convertTo (temp_image, CV_32FC1);
     cv::Mat bilateral_image;
-    cv::bilateralFilter (image, bilateral_image, 5, sigmar, 2);
+    cv::bilateralFilter (temp_image, bilateral_image, 5, sigmar, 2);
 
     cv::Mat sharp_filter = (cv::Mat_<float>(3, 3) << -1, -1, -1, -1, 8, -1, -1, -1, -1);
     cv::Mat filtered_image;
     cv::filter2D (bilateral_image, filtered_image, -1, sharp_filter);
-    filtered_image.convertTo (filtered_image, CV_32FC1);
     cv::normalize (filtered_image, filtered_image, 0, 255.0f, cv::NORM_MINMAX);
-
     cv::Mat sharpened = temp_image + filtered_image;
     cv::normalize (sharpened, sharpened, 0, 255.0f, cv::NORM_MINMAX);
     return sharpened.clone ();
 }
 
-
 float
 CVImageSharp::measure_sharp (const cv::Mat &image)
 {
     cv::Mat dst;
     cv::Laplacian (image, dst, -1, 3, 1, 0, cv::BORDER_CONSTANT);
     dst.convertTo (dst, CV_8UC1);
-    float sum = 0;
-    for (int i = 0; i < image.rows; i++)
-    {
-        for (int j = 0; j < image.cols; j++)
-        {
-            sum += dst.at<unsigned char>(i, j);
-        }
-    }
+    float sum = cv::sum (dst)[0];
     sum /= (image.rows * image.cols);
     return sum;
 }
diff --git a/modules/ocl/cv_wiener_filter.cpp b/modules/ocl/cv_wiener_filter.cpp
index fb3401e..ff96e5c 100644
--- a/modules/ocl/cv_wiener_filter.cpp
+++ b/modules/ocl/cv_wiener_filter.cpp
@@ -25,20 +25,20 @@ namespace XCam {
 
 
 CVWienerFilter::CVWienerFilter ()
-    : CVBaseClass()
+    : CVBaseClass ()
 {
-    _helpers = new CVImageProcessHelper();
+    _helpers = new CVImageProcessHelper ();
 }
 
 void
 CVWienerFilter::wiener_filter (const cv::Mat &blurred_image, const cv::Mat &known, cv::Mat &unknown, float noise_power)
 {
-    int image_w = blurred_image.size().width;
-    int image_h = blurred_image.size().height;
+    int image_w = blurred_image.size ().width;
+    int image_h = blurred_image.size ().height;
     cv::Mat y_ft;
     _helpers->compute_dft (blurred_image, y_ft);
 
-    cv::Mat padded = cv::Mat::zeros(image_h, image_w, CV_32FC1);
+    cv::Mat padded = cv::Mat::zeros (image_h, image_w, CV_32FC1);
     int padx = padded.cols - known.cols;
     int pady = padded.rows - known.rows;
     cv::copyMakeBorder (known, padded, 0, pady, 0, padx, cv::BORDER_CONSTANT, cv::Scalar::all(0));
@@ -47,22 +47,22 @@ CVWienerFilter::wiener_filter (const cv::Mat &blurred_image, const cv::Mat &know
 
     cv::Mat temp_unknown;
     cv::Mat unknown_ft[2];
-    unknown_ft[0] = cv::Mat::zeros(image_h, image_w, CV_32FC1);
-    unknown_ft[1] = cv::Mat::zeros(image_h, image_w, CV_32FC1);
+    unknown_ft[0] = cv::Mat::zeros (image_h, image_w, CV_32FC1);
+    unknown_ft[1] = cv::Mat::zeros (image_h, image_w, CV_32FC1);
 
     cv::Mat denominator;
-    cv::Mat denominator_splitted[] = {cv::Mat::zeros(blurred_image.size(), CV_32FC1), cv::Mat::zeros(blurred_image.size(), CV_32FC1)};
+    cv::Mat denominator_splitted[] = {cv::Mat::zeros (blurred_image.size (), CV_32FC1), cv::Mat::zeros (blurred_image.size (), CV_32FC1)};
     cv::mulSpectrums (padded_ft, padded_ft, denominator, 0, true);
     cv::split (denominator, denominator_splitted);
-    denominator_splitted[0] = denominator_splitted[0](cv::Rect (0, 0, blurred_image.cols, blurred_image.rows));
+    denominator_splitted[0] = denominator_splitted[0] (cv::Rect (0, 0, blurred_image.cols, blurred_image.rows));
     denominator_splitted[0] += cv::Scalar (noise_power);
 
     cv::Mat numerator;
-    cv::Mat numerator_splitted[] = {cv::Mat::zeros(blurred_image.size(), CV_32FC1), cv::Mat::zeros(blurred_image.size(), CV_32FC1)};
+    cv::Mat numerator_splitted[] = {cv::Mat::zeros (blurred_image.size (), CV_32FC1), cv::Mat::zeros (blurred_image.size (), CV_32FC1)};
     cv::mulSpectrums (y_ft, padded_ft, numerator, 0, true);
     cv::split (numerator, numerator_splitted);
-    numerator_splitted[0] = numerator_splitted[0](cv::Rect (0, 0, blurred_image.cols, blurred_image.rows));
-    numerator_splitted[1] = numerator_splitted[1](cv::Rect (0, 0, blurred_image.cols, blurred_image.rows));
+    numerator_splitted[0] = numerator_splitted[0] (cv::Rect (0, 0, blurred_image.cols, blurred_image.rows));
+    numerator_splitted[1] = numerator_splitted[1] (cv::Rect (0, 0, blurred_image.cols, blurred_image.rows));
     cv::divide (numerator_splitted[0], denominator_splitted[0], unknown_ft[0]);
     cv::divide (numerator_splitted[1], denominator_splitted[0], unknown_ft[1]);
     _helpers->compute_idft (unknown_ft, temp_unknown);
diff --git a/tests/test-image-deblurring.cpp b/tests/test-image-deblurring.cpp
index d71a448..91f019f 100644
--- a/tests/test-image-deblurring.cpp
+++ b/tests/test-image-deblurring.cpp
@@ -34,7 +34,7 @@
 using namespace XCam;
 
 static void
-usage(const char* arg0)
+usage (const char* arg0)
 {
     printf ("Usage: %s --input file --output file\n"
             "\t--input,    input image(RGB)\n"
@@ -60,7 +60,8 @@ int main (int argc, char *argv[])
     };
 
     int opt = -1;
-    while ((opt = getopt_long(argc, argv, "", long_opts, NULL)) != -1) {
+    while ((opt = getopt_long (argc, argv, "", long_opts, NULL)) != -1)
+    {
         switch (opt) {
         case 'i':
             file_in_name = optarg;
@@ -81,13 +82,15 @@ int main (int argc, char *argv[])
         }
     }
 
-    if (optind < argc || argc < 2) {
-        printf("unknown option %s\n", argv[optind]);
+    if (optind < argc || argc < 2)
+    {
+        printf ("unknown option %s\n", argv[optind]);
         usage (argv[0]);
         return -1;
     }
 
-    if (!file_in_name || !file_out_name) {
+    if (!file_in_name || !file_out_name)
+    {
         XCAM_LOG_ERROR ("input/output path is NULL");
         return -1;
     }
@@ -98,21 +101,23 @@ int main (int argc, char *argv[])
     printf ("need save file:%s\n", need_save_output ? "true" : "false");
     printf ("----------------------\n");
 
-    SmartPtr<CVImageDeblurring> imageDeblurring = new CVImageDeblurring();
-    SmartPtr<CVImageSharp> sharp = new CVImageSharp();
-    cv::Mat blurred = cv::imread(file_in_name, CV_LOAD_IMAGE_COLOR);
-    if (blurred.empty()) {
+    SmartPtr<CVImageDeblurring> imageDeblurring = new CVImageDeblurring ();
+    SmartPtr<CVImageSharp> sharp = new CVImageSharp ();
+    cv::Mat blurred = cv::imread (file_in_name, CV_LOAD_IMAGE_COLOR);
+    if (blurred.empty ())
+    {
         XCAM_LOG_ERROR ("input file read error");
         return 0;
     }
     cv::Mat deblurred;
     cv::Mat kernel;
-    imageDeblurring->blind_deblurring (blurred, deblurred, kernel);
+    imageDeblurring->blind_deblurring (blurred, deblurred, kernel, -1, -1, true);
     float input_sharp = sharp->measure_sharp (blurred);
     float output_sharp = sharp->measure_sharp (deblurred);
-    if (need_save_output) {
-        cv::imwrite(file_out_name, deblurred);
+    if (need_save_output)
+    {
+        cv::imwrite (file_out_name, deblurred);
     }
-    assert(output_sharp > input_sharp);
+    XCAM_ASSERT (output_sharp > input_sharp);
 }