From 366e9e2bc0c3850e7efcad9318cada4f2a090a29 Mon Sep 17 00:00:00 2001
From: ser1zw <azariahsawtikes@gmail.com>
Date: Wed, 6 Jul 2011 23:21:38 +0900
Subject: [PATCH] fixed CvMat#integral

---
 ext/opencv/cvmat.cpp               | 31 ++++++++-------
 test/test_cvmat_imageprocessing.rb | 61 ++++++++++++++++++++++++++----
 2 files changed, 71 insertions(+), 21 deletions(-)

diff --git a/ext/opencv/cvmat.cpp b/ext/opencv/cvmat.cpp
index 708ae02..719a195 100644
--- a/ext/opencv/cvmat.cpp
+++ b/ext/opencv/cvmat.cpp
@@ -3960,21 +3960,26 @@ rb_copy_make_border_replicate(int argc, VALUE *argv, VALUE self)
 VALUE
 rb_integral(int argc, VALUE *argv, VALUE self)
 {
-  VALUE sum, sqsum, tilted_sum, dest;
-  rb_scan_args(argc, argv, "02", &sqsum, &tilted_sum);
+  VALUE need_sqsum = Qfalse, need_tiled_sum = Qfalse;
+  rb_scan_args(argc, argv, "02", &need_sqsum, &need_tiled_sum);
   CvSize size = cvSize(cvGetSize(CVARR(self)).width + 1, cvGetSize(CVARR(self)).height + 1);
   int cn = CV_MAT_CN(cvGetElemType(CVARR(self)));
-  sum = cCvMat::new_object(size, CV_MAKETYPE(CV_64F, cn));
-  sqsum = (sqsum == Qtrue ?  cCvMat::new_object(size, CV_MAKETYPE(CV_64F, cn)) : Qnil);
-  tilted_sum = (tilted_sum == Qtrue ?  cCvMat::new_object(size, CV_MAKETYPE(CV_64F, cn)) : Qnil);
-  cvIntegral(CVARR(self), CVARR(sum), NIL_P(sqsum) ? NULL : CVARR(sqsum),
-	     NIL_P(tilted_sum) ? NULL : CVARR(tilted_sum));
-  dest = rb_ary_new3(1, sum);
-  if(sqsum)
-    rb_ary_push(dest, sqsum);
-  if(tilted_sum)
-    rb_ary_push(dest, tilted_sum);
-  return dest;
+  VALUE sum = cCvMat::new_object(size, CV_MAKETYPE(CV_64F, cn));
+  VALUE sqsum = (need_sqsum == Qtrue ? cCvMat::new_object(size, CV_MAKETYPE(CV_64F, cn)) : Qnil);
+  VALUE tiled_sum = (need_tiled_sum == Qtrue ? cCvMat::new_object(size, CV_MAKETYPE(CV_64F, cn)) : Qnil);
+  cvIntegral(CVARR(self), CVARR(sum), (need_sqsum == Qtrue) ? CVARR(sqsum) : NULL,
+	     (need_tiled_sum == Qtrue) ? CVARR(tiled_sum) : NULL);
+  
+  if ((need_sqsum != Qtrue) && (need_tiled_sum != Qtrue))
+    return sum;
+  else {
+    VALUE dest = rb_ary_new3(1, sum);
+    if (need_sqsum == Qtrue)
+      rb_ary_push(dest, sqsum);
+    if (need_tiled_sum == Qtrue)
+      rb_ary_push(dest, tiled_sum);
+    return dest;
+  }
 }
 
 VALUE
diff --git a/test/test_cvmat_imageprocessing.rb b/test/test_cvmat_imageprocessing.rb
index b9a0f1c..9888dc2 100755
--- a/test/test_cvmat_imageprocessing.rb
+++ b/test/test_cvmat_imageprocessing.rb
@@ -1056,8 +1056,44 @@ class TestCvMat_imageprocessing < OpenCVTestCase
   def test_integral
     mat0 = create_cvmat(3, 3, :cv8u, 1) { |j, i, n| CvScalar.new(n) }
 
-    sum, sqsum, tilted_sum = mat0.integral(true, true)
-    [sum, sqsum, tilted_sum].each { |s|
+    result_sum = []
+    result_sqsum = []
+    result_tiled_sum = []
+
+    result1 = mat0.integral
+    assert_equal(CvMat, result1.class)
+    result_sum << result1
+
+    result2 = mat0.integral(true)
+    assert_equal(Array, result2.class)
+    assert_equal(2, result2.size)
+    assert(result2.all? {|a| a.class == CvMat})
+    result_sum << result2[0]
+    result_sqsum << result2[1]
+
+    result3 = mat0.integral(true, true)
+    assert_equal(Array, result3.class)
+    assert_equal(3, result3.size)
+    assert(result3.all? {|a| a.class == CvMat})
+    result_sum << result3[0]
+    result_sqsum << result3[1]
+    result_tiled_sum << result3[2]
+
+    result4 = mat0.integral(true, false)
+    assert_equal(Array, result4.class)
+    assert_equal(2, result4.size)
+    assert(result4.all? {|a| a.class == CvMat})
+    result_sum << result4[0]
+    result_sqsum << result4[1]
+
+    result5 = mat0.integral(false, true)
+    assert_equal(Array, result5.class)
+    assert_equal(2, result5.size)
+    assert(result5.all? {|a| a.class == CvMat})
+    result_sum << result5[0]
+    result_tiled_sum << result5[1]
+    
+    (result_sum + result_sqsum + result_tiled_sum).each { |s|
       assert_equal(mat0.height + 1, s.height)
       assert_equal(mat0.width + 1, s.width)
       assert_equal(:cv64f, s.depth)
@@ -1068,24 +1104,33 @@ class TestCvMat_imageprocessing < OpenCVTestCase
                     0, 0, 1, 3,
                     0, 3, 8, 15,
                     0, 9, 21, 36]
-    expected_sum.each_with_index { |x, i|
-      assert_in_delta(x, sum[i][0], 0.001)
+    result_sum.each { |sum|
+      expected_sum.each_with_index { |x, i|
+        assert_in_delta(x, sum[i][0], 0.001)
+      }
     }
+    
     expected_sqsum = [0, 0, 0, 0,
                       0, 0, 1, 5,
                       0, 9, 26, 55,
                       0, 45, 111, 204]
-    expected_sqsum.each_with_index { |x, i|
-      assert_in_delta(x, sqsum[i][0], 0.001)
+    result_sqsum.each { |sqsum|
+      expected_sqsum.each_with_index { |x, i|
+        assert_in_delta(x, sqsum[i][0], 0.001)
+      }
     }
 
     expected_tilted_sum = [0, 0, 0, 0,
                            0, 0, 1, 2,
                            0, 4, 7, 8,
                            4, 16, 22, 20]
-    expected_tilted_sum.each_with_index { |x, i|
-      assert_in_delta(x, tilted_sum[i][0], 0.001)
+    result_tiled_sum.each { |tiled_sum|
+      expected_tilted_sum.each_with_index { |x, i|
+        assert_in_delta(x, tiled_sum[i][0], 0.001)
+      }
     }
+
+    mat0.integral(DUMMY_OBJ, DUMMY_OBJ)
   end
 
   def test_threshold