core/test/src/com/google/zxing/qrcode/encoder/MaskUtilTestCase.java

   1 /*
   2  * Copyright 2008 ZXing authors
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.google.zxing.qrcode.encoder;
  18
  19 import com.google.zxing.common.ByteMatrix;
  20 import com.google.zxing.qrcode.encoder.MaskUtil;
  21 import junit.framework.TestCase;
  22
  23 /**
  24  * @author satorux@google.com (Satoru Takabayashi) - creator
  25  * @author mysen@google.com (Chris Mysen) - ported from C++
  26  */
  27
  28 public final class MaskUtilTestCase extends TestCase {
  29   public void testApplyMaskPenaltyRule1() {
  30     {
  31       ByteMatrix matrix = new ByteMatrix(1, 4);
  32       matrix.set(0, 0, 0);
  33       matrix.set(0, 1, 0);
  34       matrix.set(0, 2, 0);
  35       matrix.set(0, 3, 0);
  36       assertEquals(0, MaskUtil.ApplyMaskPenaltyRule1(matrix));
  37     }
  38     {  // Horizontal.
  39       ByteMatrix matrix = new ByteMatrix(1, 6);
  40       matrix.set(0, 0, 0);
  41       matrix.set(0, 1, 0);
  42       matrix.set(0, 2, 0);
  43       matrix.set(0, 3, 0);
  44       matrix.set(0, 4, 0);
  45       matrix.set(0, 5, 1);
  46       assertEquals(3, MaskUtil.ApplyMaskPenaltyRule1(matrix));
  47       matrix.set(0, 5, 0);
  48       assertEquals(4, MaskUtil.ApplyMaskPenaltyRule1(matrix));
  49     }
  50     {  // Vertical.
  51       ByteMatrix matrix = new ByteMatrix(6, 1);
  52       matrix.set(0, 0, 0);
  53       matrix.set(1, 0, 0);
  54       matrix.set(2, 0, 0);
  55       matrix.set(3, 0, 0);
  56       matrix.set(4, 0, 0);
  57       matrix.set(5, 0, 1);
  58       assertEquals(3, MaskUtil.ApplyMaskPenaltyRule1(matrix));
  59       matrix.set(5, 0, 0);
  60       assertEquals(4, MaskUtil.ApplyMaskPenaltyRule1(matrix));
  61     }
  62   }
  63
  64   public void testApplyMaskPenaltyRule2() {
  65     {
  66       ByteMatrix matrix = new ByteMatrix(1, 1);
  67       matrix.set(0, 0, 0);
  68       assertEquals(0, MaskUtil.ApplyMaskPenaltyRule2(matrix));
  69     }
  70     {
  71       ByteMatrix matrix = new ByteMatrix(2, 2);
  72       matrix.set(0, 0, 0);
  73       matrix.set(0, 1, 0);
  74       matrix.set(1, 0, 0);
  75       matrix.set(1, 1, 1);
  76       assertEquals(0, MaskUtil.ApplyMaskPenaltyRule2(matrix));
  77     }
  78     {
  79       ByteMatrix matrix = new ByteMatrix(2, 2);
  80       matrix.set(0, 0, 0);
  81       matrix.set(0, 1, 0);
  82       matrix.set(1, 0, 0);
  83       matrix.set(1, 1, 0);
  84       assertEquals(3, MaskUtil.ApplyMaskPenaltyRule2(matrix));
  85     }
  86     {
  87       ByteMatrix matrix = new ByteMatrix(3, 3);
  88       matrix.set(0, 0, 0);
  89       matrix.set(0, 1, 0);
  90       matrix.set(0, 2, 0);
  91       matrix.set(1, 0, 0);
  92       matrix.set(1, 1, 0);
  93       matrix.set(1, 2, 0);
  94       matrix.set(2, 0, 0);
  95       matrix.set(2, 1, 0);
  96       matrix.set(2, 2, 0);
  97       // Four instances of 2x2 blocks.
  98       assertEquals(3 * 4, MaskUtil.ApplyMaskPenaltyRule2(matrix));
  99     }
 100   }
 101
 102   public void testApplyMaskPenaltyRule3() {
 103     {
 104       // Horizontal 00001011101.
 105       ByteMatrix matrix = new ByteMatrix(1, 11);
 106       matrix.set(0, 0, 0);
 107       matrix.set(0, 1, 0);
 108       matrix.set(0, 2, 0);
 109       matrix.set(0, 3, 0);
 110       matrix.set(0, 4, 1);
 111       matrix.set(0, 5, 0);
 112       matrix.set(0, 6, 1);
 113       matrix.set(0, 7, 1);
 114       matrix.set(0, 8, 1);
 115       matrix.set(0, 9, 0);
 116       matrix.set(0, 10, 1);
 117       assertEquals(40, MaskUtil.ApplyMaskPenaltyRule3(matrix));
 118     }
 119     {
 120       // Horizontal 10111010000.
 121       ByteMatrix matrix = new ByteMatrix(1, 11);
 122       matrix.set(0, 0, 1);
 123       matrix.set(0, 1, 0);
 124       matrix.set(0, 2, 1);
 125       matrix.set(0, 3, 1);
 126       matrix.set(0, 4, 1);
 127       matrix.set(0, 5, 0);
 128       matrix.set(0, 6, 1);
 129       matrix.set(0, 7, 0);
 130       matrix.set(0, 8, 0);
 131       matrix.set(0, 9, 0);
 132       matrix.set(0, 10, 0);
 133       assertEquals(40, MaskUtil.ApplyMaskPenaltyRule3(matrix));
 134     }
 135     {
 136       // Vertical 00001011101.
 137       ByteMatrix matrix = new ByteMatrix(11, 1);
 138       matrix.set(0, 0, 0);
 139       matrix.set(1, 0, 0);
 140       matrix.set(2, 0, 0);
 141       matrix.set(3, 0, 0);
 142       matrix.set(4, 0, 1);
 143       matrix.set(5, 0, 0);
 144       matrix.set(6, 0, 1);
 145       matrix.set(7, 0, 1);
 146       matrix.set(8, 0, 1);
 147       matrix.set(9, 0, 0);
 148       matrix.set(10, 0, 1);
 149       assertEquals(40, MaskUtil.ApplyMaskPenaltyRule3(matrix));
 150     }
 151     {
 152       // Vertical 10111010000.
 153       ByteMatrix matrix = new ByteMatrix(11, 1);
 154       matrix.set(0, 0, 1);
 155       matrix.set(1, 0, 0);
 156       matrix.set(2, 0, 1);
 157       matrix.set(3, 0, 1);
 158       matrix.set(4, 0, 1);
 159       matrix.set(5, 0, 0);
 160       matrix.set(6, 0, 1);
 161       matrix.set(7, 0, 0);
 162       matrix.set(8, 0, 0);
 163       matrix.set(9, 0, 0);
 164       matrix.set(10, 0, 0);
 165       assertEquals(40, MaskUtil.ApplyMaskPenaltyRule3(matrix));
 166     }
 167   }
 168
 169   public void testApplyMaskPenaltyRule4() {
 170     {
 171       // Dark cell ratio = 0%
 172       ByteMatrix matrix = new ByteMatrix(1, 1);
 173       matrix.set(0, 0, 0);
 174       assertEquals(100, MaskUtil.ApplyMaskPenaltyRule4(matrix));
 175     }
 176     {
 177       // Dark cell ratio = 5%
 178       ByteMatrix matrix = new ByteMatrix(1, 2);
 179       matrix.set(0, 0, 0);
 180       matrix.set(0, 0, 1);
 181       assertEquals(0, MaskUtil.ApplyMaskPenaltyRule4(matrix));
 182     }
 183     {
 184       // Dark cell ratio = 66.67%
 185       ByteMatrix matrix = new ByteMatrix(1, 6);
 186       matrix.set(0, 0, 0);
 187       matrix.set(0, 1, 1);
 188       matrix.set(0, 2, 1);
 189       matrix.set(0, 3, 1);
 190       matrix.set(0, 4, 1);
 191       matrix.set(0, 5, 0);
 192       assertEquals(30, MaskUtil.ApplyMaskPenaltyRule4(matrix));
 193     }
 194   }
 195
 196   private static boolean TestGetDataMaskBitInternal(int mask_pattern,
 197                                          int[][] expected) {
 198     for (int x = 0; x < 6; ++x) {
 199       for (int y = 0; y < 6; ++y) {
 200         if (expected[y][x] !=
 201             MaskUtil.GetDataMaskBit(mask_pattern, x, y)) {
 202           return false;
 203         }
 204       }
 205     }
 206     return true;
 207   }
 208
 209   // See mask patterns on the page 43 of JISX0510:2004.
 210   public void testGetDataMaskBit() {
 211     int[][] mask0 = {
 212       {1, 0, 1, 0, 1, 0},
 213       {0, 1, 0, 1, 0, 1},
 214       {1, 0, 1, 0, 1, 0},
 215       {0, 1, 0, 1, 0, 1},
 216       {1, 0, 1, 0, 1, 0},
 217       {0, 1, 0, 1, 0, 1},
 218     };
 219     assertTrue(TestGetDataMaskBitInternal(0,  mask0));
 220     int[][] mask1 = {
 221       {1, 1, 1, 1, 1, 1},
 222       {0, 0, 0, 0, 0, 0},
 223       {1, 1, 1, 1, 1, 1},
 224       {0, 0, 0, 0, 0, 0},
 225       {1, 1, 1, 1, 1, 1},
 226       {0, 0, 0, 0, 0, 0},
 227     };
 228     assertTrue(TestGetDataMaskBitInternal(1,  mask1));
 229     int[][] mask2 = {
 230       {1, 0, 0, 1, 0, 0},
 231       {1, 0, 0, 1, 0, 0},
 232       {1, 0, 0, 1, 0, 0},
 233       {1, 0, 0, 1, 0, 0},
 234       {1, 0, 0, 1, 0, 0},
 235       {1, 0, 0, 1, 0, 0},
 236     };
 237     assertTrue(TestGetDataMaskBitInternal(2, mask2));
 238     int[][] mask3 = {
 239       {1, 0, 0, 1, 0, 0},
 240       {0, 0, 1, 0, 0, 1},
 241       {0, 1, 0, 0, 1, 0},
 242       {1, 0, 0, 1, 0, 0},
 243       {0, 0, 1, 0, 0, 1},
 244       {0, 1, 0, 0, 1, 0},
 245     };
 246     assertTrue(TestGetDataMaskBitInternal(3, mask3));
 247     int[][] mask4 = {
 248       {1, 1, 1, 0, 0, 0},
 249       {1, 1, 1, 0, 0, 0},
 250       {0, 0, 0, 1, 1, 1},
 251       {0, 0, 0, 1, 1, 1},
 252       {1, 1, 1, 0, 0, 0},
 253       {1, 1, 1, 0, 0, 0},
 254     };
 255     assertTrue(TestGetDataMaskBitInternal(4, mask4));
 256     int[][] mask5 = {
 257       {1, 1, 1, 1, 1, 1},
 258       {1, 0, 0, 0, 0, 0},
 259       {1, 0, 0, 1, 0, 0},
 260       {1, 0, 1, 0, 1, 0},
 261       {1, 0, 0, 1, 0, 0},
 262       {1, 0, 0, 0, 0, 0},
 263     };
 264     assertTrue(TestGetDataMaskBitInternal(5, mask5));
 265     int[][] mask6 = {
 266       {1, 1, 1, 1, 1, 1},
 267       {1, 1, 1, 0, 0, 0},
 268       {1, 1, 0, 1, 1, 0},
 269       {1, 0, 1, 0, 1, 0},
 270       {1, 0, 1, 1, 0, 1},
 271       {1, 0, 0, 0, 1, 1},
 272     };
 273     assertTrue(TestGetDataMaskBitInternal(6, mask6));
 274     int[][] mask7 = {
 275       {1, 0, 1, 0, 1, 0},
 276       {0, 0, 0, 1, 1, 1},
 277       {1, 0, 0, 0, 1, 1},
 278       {0, 1, 0, 1, 0, 1},
 279       {1, 1, 1, 0, 0, 0},
 280       {0, 1, 1, 1, 0, 0},
 281     };
 282     assertTrue(TestGetDataMaskBitInternal(7, mask7));
 283   }
 284 }