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 junit.framework.TestCase;
  21
  22 /**
  23  * @author satorux@google.com (Satoru Takabayashi) - creator
  24  * @author mysen@google.com (Chris Mysen) - ported from C++
  25  */
  26
  27 public final class MaskUtilTestCase extends TestCase {
  28   public void testApplyMaskPenaltyRule1() {
  29     {
  30       ByteMatrix matrix = new ByteMatrix(1, 4);
  31       matrix.set(0, 0, 0);
  32       matrix.set(0, 1, 0);
  33       matrix.set(0, 2, 0);
  34       matrix.set(0, 3, 0);
  35       assertEquals(0, MaskUtil.applyMaskPenaltyRule1(matrix));
  36     }
  37     {  // Horizontal.
  38       ByteMatrix matrix = new ByteMatrix(1, 6);
  39       matrix.set(0, 0, 0);
  40       matrix.set(0, 1, 0);
  41       matrix.set(0, 2, 0);
  42       matrix.set(0, 3, 0);
  43       matrix.set(0, 4, 0);
  44       matrix.set(0, 5, 1);
  45       assertEquals(3, MaskUtil.applyMaskPenaltyRule1(matrix));
  46       matrix.set(0, 5, 0);
  47       assertEquals(4, MaskUtil.applyMaskPenaltyRule1(matrix));
  48     }
  49     {  // Vertical.
  50       ByteMatrix matrix = new ByteMatrix(6, 1);
  51       matrix.set(0, 0, 0);
  52       matrix.set(1, 0, 0);
  53       matrix.set(2, 0, 0);
  54       matrix.set(3, 0, 0);
  55       matrix.set(4, 0, 0);
  56       matrix.set(5, 0, 1);
  57       assertEquals(3, MaskUtil.applyMaskPenaltyRule1(matrix));
  58       matrix.set(5, 0, 0);
  59       assertEquals(4, MaskUtil.applyMaskPenaltyRule1(matrix));
  60     }
  61   }
  62
  63   public void testApplyMaskPenaltyRule2() {
  64     {
  65       ByteMatrix matrix = new ByteMatrix(1, 1);
  66       matrix.set(0, 0, 0);
  67       assertEquals(0, MaskUtil.applyMaskPenaltyRule2(matrix));
  68     }
  69     {
  70       ByteMatrix matrix = new ByteMatrix(2, 2);
  71       matrix.set(0, 0, 0);
  72       matrix.set(0, 1, 0);
  73       matrix.set(1, 0, 0);
  74       matrix.set(1, 1, 1);
  75       assertEquals(0, MaskUtil.applyMaskPenaltyRule2(matrix));
  76     }
  77     {
  78       ByteMatrix matrix = new ByteMatrix(2, 2);
  79       matrix.set(0, 0, 0);
  80       matrix.set(0, 1, 0);
  81       matrix.set(1, 0, 0);
  82       matrix.set(1, 1, 0);
  83       assertEquals(3, MaskUtil.applyMaskPenaltyRule2(matrix));
  84     }
  85     {
  86       ByteMatrix matrix = new ByteMatrix(3, 3);
  87       matrix.set(0, 0, 0);
  88       matrix.set(0, 1, 0);
  89       matrix.set(0, 2, 0);
  90       matrix.set(1, 0, 0);
  91       matrix.set(1, 1, 0);
  92       matrix.set(1, 2, 0);
  93       matrix.set(2, 0, 0);
  94       matrix.set(2, 1, 0);
  95       matrix.set(2, 2, 0);
  96       // Four instances of 2x2 blocks.
  97       assertEquals(3 * 4, MaskUtil.applyMaskPenaltyRule2(matrix));
  98     }
  99   }
 100
 101   public void testApplyMaskPenaltyRule3() {
 102     {
 103       // Horizontal 00001011101.
 104       ByteMatrix matrix = new ByteMatrix(1, 11);
 105       matrix.set(0, 0, 0);
 106       matrix.set(0, 1, 0);
 107       matrix.set(0, 2, 0);
 108       matrix.set(0, 3, 0);
 109       matrix.set(0, 4, 1);
 110       matrix.set(0, 5, 0);
 111       matrix.set(0, 6, 1);
 112       matrix.set(0, 7, 1);
 113       matrix.set(0, 8, 1);
 114       matrix.set(0, 9, 0);
 115       matrix.set(0, 10, 1);
 116       assertEquals(40, MaskUtil.applyMaskPenaltyRule3(matrix));
 117     }
 118     {
 119       // Horizontal 10111010000.
 120       ByteMatrix matrix = new ByteMatrix(1, 11);
 121       matrix.set(0, 0, 1);
 122       matrix.set(0, 1, 0);
 123       matrix.set(0, 2, 1);
 124       matrix.set(0, 3, 1);
 125       matrix.set(0, 4, 1);
 126       matrix.set(0, 5, 0);
 127       matrix.set(0, 6, 1);
 128       matrix.set(0, 7, 0);
 129       matrix.set(0, 8, 0);
 130       matrix.set(0, 9, 0);
 131       matrix.set(0, 10, 0);
 132       assertEquals(40, MaskUtil.applyMaskPenaltyRule3(matrix));
 133     }
 134     {
 135       // Vertical 00001011101.
 136       ByteMatrix matrix = new ByteMatrix(11, 1);
 137       matrix.set(0, 0, 0);
 138       matrix.set(1, 0, 0);
 139       matrix.set(2, 0, 0);
 140       matrix.set(3, 0, 0);
 141       matrix.set(4, 0, 1);
 142       matrix.set(5, 0, 0);
 143       matrix.set(6, 0, 1);
 144       matrix.set(7, 0, 1);
 145       matrix.set(8, 0, 1);
 146       matrix.set(9, 0, 0);
 147       matrix.set(10, 0, 1);
 148       assertEquals(40, MaskUtil.applyMaskPenaltyRule3(matrix));
 149     }
 150     {
 151       // Vertical 10111010000.
 152       ByteMatrix matrix = new ByteMatrix(11, 1);
 153       matrix.set(0, 0, 1);
 154       matrix.set(1, 0, 0);
 155       matrix.set(2, 0, 1);
 156       matrix.set(3, 0, 1);
 157       matrix.set(4, 0, 1);
 158       matrix.set(5, 0, 0);
 159       matrix.set(6, 0, 1);
 160       matrix.set(7, 0, 0);
 161       matrix.set(8, 0, 0);
 162       matrix.set(9, 0, 0);
 163       matrix.set(10, 0, 0);
 164       assertEquals(40, MaskUtil.applyMaskPenaltyRule3(matrix));
 165     }
 166   }
 167
 168   public void testApplyMaskPenaltyRule4() {
 169     {
 170       // Dark cell ratio = 0%
 171       ByteMatrix matrix = new ByteMatrix(1, 1);
 172       matrix.set(0, 0, 0);
 173       assertEquals(100, MaskUtil.applyMaskPenaltyRule4(matrix));
 174     }
 175     {
 176       // Dark cell ratio = 5%
 177       ByteMatrix matrix = new ByteMatrix(1, 2);
 178       matrix.set(0, 0, 0);
 179       matrix.set(0, 0, 1);
 180       assertEquals(0, MaskUtil.applyMaskPenaltyRule4(matrix));
 181     }
 182     {
 183       // Dark cell ratio = 66.67%
 184       ByteMatrix matrix = new ByteMatrix(1, 6);
 185       matrix.set(0, 0, 0);
 186       matrix.set(0, 1, 1);
 187       matrix.set(0, 2, 1);
 188       matrix.set(0, 3, 1);
 189       matrix.set(0, 4, 1);
 190       matrix.set(0, 5, 0);
 191       assertEquals(30, MaskUtil.applyMaskPenaltyRule4(matrix));
 192     }
 193   }
 194
 195   private static boolean TestGetDataMaskBitInternal(int maskPattern,
 196                                          int[][] expected) {
 197     for (int x = 0; x < 6; ++x) {
 198       for (int y = 0; y < 6; ++y) {
 199         if (expected[y][x] !=
 200             MaskUtil.getDataMaskBit(maskPattern, x, y)) {
 201           return false;
 202         }
 203       }
 204     }
 205     return true;
 206   }
 207
 208   // See mask patterns on the page 43 of JISX0510:2004.
 209   public void testGetDataMaskBit() {
 210     int[][] mask0 = {
 211       {1, 0, 1, 0, 1, 0},
 212       {0, 1, 0, 1, 0, 1},
 213       {1, 0, 1, 0, 1, 0},
 214       {0, 1, 0, 1, 0, 1},
 215       {1, 0, 1, 0, 1, 0},
 216       {0, 1, 0, 1, 0, 1},
 217     };
 218     assertTrue(TestGetDataMaskBitInternal(0,  mask0));
 219     int[][] mask1 = {
 220       {1, 1, 1, 1, 1, 1},
 221       {0, 0, 0, 0, 0, 0},
 222       {1, 1, 1, 1, 1, 1},
 223       {0, 0, 0, 0, 0, 0},
 224       {1, 1, 1, 1, 1, 1},
 225       {0, 0, 0, 0, 0, 0},
 226     };
 227     assertTrue(TestGetDataMaskBitInternal(1,  mask1));
 228     int[][] mask2 = {
 229       {1, 0, 0, 1, 0, 0},
 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     };
 236     assertTrue(TestGetDataMaskBitInternal(2, mask2));
 237     int[][] mask3 = {
 238       {1, 0, 0, 1, 0, 0},
 239       {0, 0, 1, 0, 0, 1},
 240       {0, 1, 0, 0, 1, 0},
 241       {1, 0, 0, 1, 0, 0},
 242       {0, 0, 1, 0, 0, 1},
 243       {0, 1, 0, 0, 1, 0},
 244     };
 245     assertTrue(TestGetDataMaskBitInternal(3, mask3));
 246     int[][] mask4 = {
 247       {1, 1, 1, 0, 0, 0},
 248       {1, 1, 1, 0, 0, 0},
 249       {0, 0, 0, 1, 1, 1},
 250       {0, 0, 0, 1, 1, 1},
 251       {1, 1, 1, 0, 0, 0},
 252       {1, 1, 1, 0, 0, 0},
 253     };
 254     assertTrue(TestGetDataMaskBitInternal(4, mask4));
 255     int[][] mask5 = {
 256       {1, 1, 1, 1, 1, 1},
 257       {1, 0, 0, 0, 0, 0},
 258       {1, 0, 0, 1, 0, 0},
 259       {1, 0, 1, 0, 1, 0},
 260       {1, 0, 0, 1, 0, 0},
 261       {1, 0, 0, 0, 0, 0},
 262     };
 263     assertTrue(TestGetDataMaskBitInternal(5, mask5));
 264     int[][] mask6 = {
 265       {1, 1, 1, 1, 1, 1},
 266       {1, 1, 1, 0, 0, 0},
 267       {1, 1, 0, 1, 1, 0},
 268       {1, 0, 1, 0, 1, 0},
 269       {1, 0, 1, 1, 0, 1},
 270       {1, 0, 0, 0, 1, 1},
 271     };
 272     assertTrue(TestGetDataMaskBitInternal(6, mask6));
 273     int[][] mask7 = {
 274       {1, 0, 1, 0, 1, 0},
 275       {0, 0, 0, 1, 1, 1},
 276       {1, 0, 0, 0, 1, 1},
 277       {0, 1, 0, 1, 0, 1},
 278       {1, 1, 1, 0, 0, 0},
 279       {0, 1, 1, 1, 0, 0},
 280     };
 281     assertTrue(TestGetDataMaskBitInternal(7, mask7));
 282   }
 283 }