re-implement blockIntegral calculation

Author: ninh-huynh

modules/wechat_qrcode/src/zxing/common/binarizer/hybrid_binarizer.cpp

@@ -55,43 +55,45 @@ Ref<Binarizer> HybridBinarizer::createBinarizer(Ref<LuminanceSource> source) {
 }
 
 int HybridBinarizer::initBlockIntegral() {
-    blockIntegral_ = new Array<int>(width * height);
+    blockIntegralWidth = subWidth_ + 1;
+    blockIntegralHeight = subHeight_ + 1;
+    blockIntegral_ = new Array<int>(blockIntegralWidth * blockIntegralHeight);
 
     int* integral = blockIntegral_->data();
 
     // unsigned char* therow = grayByte_->getByteRow(0);
 
     // first row only
-    int rs = 0;
 
-    for (int j = 0; j < width; j++) {
+    for (int j = 0; j < blockIntegralWidth; j++) {
         integral[j] = 0;
     }
 
-    for (int i = 0; i < height; i++) {
-        integral[i * width] = 0;
+    for (int i = 0; i < blockIntegralHeight; i++) {
+        integral[i * blockIntegralWidth] = 0;
     }
 
-    for (int j = 0; j < subWidth_; j++) {
-        rs += blocks_[j].threshold;
-        integral[width + j + 1] = rs;
-    }
-
-    // remaining cells are sum above and to the left
-    int offset = width;
-    int offsetBlock = 0;
-
-    for (int i = 1; i < subHeight_; ++i) {
-        // therow = grayByte_->getByteRow(i);
-        offsetBlock = i * subWidth_;
-
-        rs = 0;
-
-        offset += width;
-
-        for (int j = 0; j < subWidth_; ++j) {
-            rs += blocks_[offsetBlock + j].threshold;
-            integral[offset + j + 1] = rs + integral[offset - width + j + 1];
+    // compute block integral
+    // O - - - - - - -
+    // |      |   |
+    // | - - -A - B
+    // |      |   |
+    // | - -  C - D
+    // |
+    // |
+    
+    int D, D1, B, C, A;
+    for (int row = 1; row < blockIntegralHeight; row++) {
+        for (int col = 1; col < blockIntegralWidth; col++ ) {
+            
+            D = row * blockIntegralWidth + col;
+            B = (row -  1) * blockIntegralWidth + col;
+            C = row * blockIntegralWidth + (col - 1);
+            A = (row - 1) * blockIntegralWidth + (col - 1);
+
+            D1 = (row - 1) * subWidth_ + (col - 1);
+
+            integral[D] = blocks_[D1].threshold + integral[B] + integral[C] - integral[A];
         }
     }
 
@@ -201,13 +203,25 @@ void HybridBinarizer::calculateThresholdForBlock(Ref<ByteMatrix>& _luminances, i
             int sum = 0;
             // int sum2 = 0;
 
-            int offset1 = (top - THRES_BLOCKSIZE) * (subWidth + 1) + left - THRES_BLOCKSIZE;
-            int offset2 = (top + THRES_BLOCKSIZE + 1) * (subWidth + 1) + left - THRES_BLOCKSIZE;
-
             int blocksize = THRES_BLOCKSIZE * 2 + 1;
 
-            sum = blockIntegral[offset1] - blockIntegral[offset1 + blocksize] -
-                  blockIntegral[offset2] + blockIntegral[offset2 + blocksize];
+            // calculate sum from Rect ABCD
+            // O - - - - - - -
+            // |      |   |
+            // | - - -A - B
+            // |      |   |
+            // | - -  C - D
+            // |
+            // |
+            int bottom = top + blocksize;
+            int right = left + blocksize;
+
+            // coordinate in blockIntegral are translated by (1, 1)
+            int D = (bottom + 1) * blockIntegralWidth + (right + 1);
+            int C = (bottom + 1) * blockIntegralWidth + (left + 1 - 1);
+            int B = (top + 1 - 1) * blockIntegralWidth + (right + 1);
+            int A = (top + 1 - 1) * blockIntegralWidth + (left + 1 - 1);
+            sum = blockIntegral[D] - blockIntegral[B] - blockIntegral[C] + blockIntegral[A];
 
             int average = sum / blockArea;
             thresholdBlock(_luminances, xoffset, yoffset, average, matrix, err_handler);

modules/wechat_qrcode/src/zxing/common/binarizer/hybrid_binarizer.hpp

@@ -35,6 +35,8 @@ class HybridBinarizer : public GlobalHistogramBinarizer {
 
     int subWidth_;
     int subHeight_;
+    int blockIntegralWidth;
+    int blockIntegralHeight;
 
 public:
     explicit HybridBinarizer(Ref<LuminanceSource> source);