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