![\"Android神技侧漏交流群\"](\"http://pub.idqqimg.com/wpa/images/group.png\" "\\"Android神技侧漏交流群\\"")
( 点击图标即可加入 )Encapsulates the result of decoding a barcode within an image.
\n *\n * @author Sean Owen\n */\npublic final class Result {\n\n private final String text;\n private final byte[] rawBytes;\n private final int numBits;\n private ResultPoint[] resultPoints;\n private final BarcodeFormat format;\n private Map2D barcode formats typically encode text, but allow for a sort of 'byte mode'\n * which is sometimes used to encode binary data. While {@link Result} makes available\n * the complete raw bytes in the barcode for these formats, it does not offer the bytes\n * from the byte segments alone.
\n *\n *This maps to a {@link java.util.List} of byte arrays corresponding to the\n * raw bytes in the byte segments in the barcode, in order.
\n */\n BYTE_SEGMENTS,\n\n /**\n * Error correction level used, if applicable. The value type depends on the\n * format, but is typically a String.\n */\n ERROR_CORRECTION_LEVEL,\n\n /**\n * For some periodicals, indicates the issue number as an {@link Integer}.\n */\n ISSUE_NUMBER,\n\n /**\n * For some products, indicates the suggested retail price in the barcode as a\n * formatted {@link String}.\n */\n SUGGESTED_PRICE,\n\n /**\n * For some products, the possible country of manufacture as a {@link String} denoting the\n * ISO country code. Some map to multiple possible countries, like \"US/CA\".\n */\n POSSIBLE_COUNTRY,\n\n /**\n * For some products, the extension text\n */\n UPC_EAN_EXTENSION,\n\n /**\n * PDF417-specific metadata\n */\n PDF417_EXTRA_METADATA,\n\n /**\n * If the code format supports structured append and the current scanned code is part of one then the\n * sequence number is given with it.\n */\n STRUCTURED_APPEND_SEQUENCE,\n\n /**\n * If the code format supports structured append and the current scanned code is part of one then the\n * parity is given with it.\n */\n STRUCTURED_APPEND_PARITY,\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/ResultPoint.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing;\n\nimport com.google.zxing.common.detector.MathUtils;\n\n/**\n *Encapsulates a point of interest in an image containing a barcode. Typically, this\n * would be the location of a finder pattern or the corner of the barcode, for example.
\n *\n * @author Sean Owen\n */\npublic class ResultPoint {\n\n private final float x;\n private final float y;\n\n public ResultPoint(float x, float y) {\n this.x = x;\n this.y = y;\n }\n\n public final float getX() {\n return x;\n }\n\n public final float getY() {\n return y;\n }\n\n @Override\n public final boolean equals(Object other) {\n if (other instanceof ResultPoint) {\n ResultPoint otherPoint = (ResultPoint) other;\n return x == otherPoint.x && y == otherPoint.y;\n }\n return false;\n }\n\n @Override\n public final int hashCode() {\n return 31 * Float.floatToIntBits(x) + Float.floatToIntBits(y);\n }\n\n @Override\n public final String toString() {\n return \"(\" + x + ',' + y + ')';\n }\n\n /**\n * Orders an array of three ResultPoints in an order [A,B,C] such that AB is less than AC\n * and BC is less than AC, and the angle between BC and BA is less than 180 degrees.\n *\n * @param patterns array of three {@code ResultPoint} to order\n */\n public static void orderBestPatterns(ResultPoint[] patterns) {\n\n // Find distances between pattern centers\n float zeroOneDistance = distance(patterns[0], patterns[1]);\n float oneTwoDistance = distance(patterns[1], patterns[2]);\n float zeroTwoDistance = distance(patterns[0], patterns[2]);\n\n ResultPoint pointA;\n ResultPoint pointB;\n ResultPoint pointC;\n // Assume one closest to other two is B; A and C will just be guesses at first\n if (oneTwoDistance >= zeroOneDistance && oneTwoDistance >= zeroTwoDistance) {\n pointB = patterns[0];\n pointA = patterns[1];\n pointC = patterns[2];\n } else if (zeroTwoDistance >= oneTwoDistance && zeroTwoDistance >= zeroOneDistance) {\n pointB = patterns[1];\n pointA = patterns[0];\n pointC = patterns[2];\n } else {\n pointB = patterns[2];\n pointA = patterns[0];\n pointC = patterns[1];\n }\n\n // Use cross product to figure out whether A and C are correct or flipped.\n // This asks whether BC x BA has a positive z component, which is the arrangement\n // we want for A, B, C. If it's negative, then we've got it flipped around and\n // should swap A and C.\n if (crossProductZ(pointA, pointB, pointC) < 0.0f) {\n ResultPoint temp = pointA;\n pointA = pointC;\n pointC = temp;\n }\n\n patterns[0] = pointA;\n patterns[1] = pointB;\n patterns[2] = pointC;\n }\n\n /**\n * @param pattern1 first pattern\n * @param pattern2 second pattern\n * @return distance between two points\n */\n public static float distance(ResultPoint pattern1, ResultPoint pattern2) {\n return MathUtils.distance(pattern1.x, pattern1.y, pattern2.x, pattern2.y);\n }\n\n /**\n * Returns the z component of the cross product between vectors BC and BA.\n */\n private static float crossProductZ(ResultPoint pointA,\n ResultPoint pointB,\n ResultPoint pointC) {\n float bX = pointB.x;\n float bY = pointB.y;\n return ((pointC.x - bX) * (pointA.y - bY)) - ((pointC.y - bY) * (pointA.x - bX));\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/ResultPointCallback.java", "content": "/*\n * Copyright 2009 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing;\n\n/**\n * Callback which is invoked when a possible result point (significant\n * point in the barcode image such as a corner) is found.\n *\n * @see DecodeHintType#NEED_RESULT_POINT_CALLBACK\n */\npublic interface ResultPointCallback {\n\n void foundPossibleResultPoint(ResultPoint point);\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/Writer.java", "content": "/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing;\n\nimport com.google.zxing.common.BitMatrix;\n\nimport java.util.Map;\n\n/**\n * The base class for all objects which encode/generate a barcode image.\n *\n * @author dswitkin@google.com (Daniel Switkin)\n */\npublic interface Writer {\n\n /**\n * Encode a barcode using the default settings.\n *\n * @param contents The contents to encode in the barcode\n * @param format The barcode format to generate\n * @param width The preferred width in pixels\n * @param height The preferred height in pixels\n * @return {@link BitMatrix} representing encoded barcode image\n * @throws WriterException if contents cannot be encoded legally in a format\n */\n BitMatrix encode(String contents, BarcodeFormat format, int width, int height)\n throws WriterException;\n\n /**\n * @param contents The contents to encode in the barcode\n * @param format The barcode format to generate\n * @param width The preferred width in pixels\n * @param height The preferred height in pixels\n * @param hints Additional parameters to supply to the encoder\n * @return {@link BitMatrix} representing encoded barcode image\n * @throws WriterException if contents cannot be encoded legally in a format\n */\n BitMatrix encode(String contents,\n BarcodeFormat format,\n int width,\n int height,\n MapExtends {@link DetectorResult} with more information specific to the Aztec format,\n * like the number of layers and whether it's compact.
\n *\n * @author Sean Owen\n */\npublic final class AztecDetectorResult extends DetectorResult {\n\n private final boolean compact;\n private final int nbDatablocks;\n private final int nbLayers;\n\n public AztecDetectorResult(BitMatrix bits,\n ResultPoint[] points,\n boolean compact,\n int nbDatablocks,\n int nbLayers) {\n super(bits, points);\n this.compact = compact;\n this.nbDatablocks = nbDatablocks;\n this.nbLayers = nbLayers;\n }\n\n public int getNbLayers() {\n return nbLayers;\n }\n\n public int getNbDatablocks() {\n return nbDatablocks;\n }\n\n public boolean isCompact() {\n return compact;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/aztec/AztecReader.java", "content": "/*\n * Copyright 2010 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.aztec;\n\nimport com.google.zxing.BarcodeFormat;\nimport com.google.zxing.BinaryBitmap;\nimport com.google.zxing.DecodeHintType;\nimport com.google.zxing.FormatException;\nimport com.google.zxing.NotFoundException;\nimport com.google.zxing.Reader;\nimport com.google.zxing.Result;\nimport com.google.zxing.ResultMetadataType;\nimport com.google.zxing.ResultPoint;\nimport com.google.zxing.ResultPointCallback;\nimport com.google.zxing.aztec.decoder.Decoder;\nimport com.google.zxing.aztec.detector.Detector;\nimport com.google.zxing.common.DecoderResult;\n\nimport java.util.List;\nimport java.util.Map;\n\n/**\n * This implementation can detect and decode Aztec codes in an image.\n *\n * @author David Olivier\n */\npublic final class AztecReader implements Reader {\n\n /**\n * Locates and decodes a Data Matrix code in an image.\n *\n * @return a String representing the content encoded by the Data Matrix code\n * @throws NotFoundException if a Data Matrix code cannot be found\n * @throws FormatException if a Data Matrix code cannot be decoded\n */\n @Override\n public Result decode(BinaryBitmap image) throws NotFoundException, FormatException {\n return decode(image, null);\n }\n\n @Override\n public Result decode(BinaryBitmap image, MapThe main class which implements Aztec Code decoding -- as opposed to locating and extracting\n * the Aztec Code from an image.
\n *\n * @author David Olivier\n */\npublic final class Decoder {\n\n private enum Table {\n UPPER,\n LOWER,\n MIXED,\n DIGIT,\n PUNCT,\n BINARY\n }\n\n private static final String[] UPPER_TABLE = {\n \"CTRL_PS\", \" \", \"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\", \"K\", \"L\", \"M\", \"N\", \"O\", \"P\",\n \"Q\", \"R\", \"S\", \"T\", \"U\", \"V\", \"W\", \"X\", \"Y\", \"Z\", \"CTRL_LL\", \"CTRL_ML\", \"CTRL_DL\", \"CTRL_BS\"\n };\n\n private static final String[] LOWER_TABLE = {\n \"CTRL_PS\", \" \", \"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\", \"k\", \"l\", \"m\", \"n\", \"o\", \"p\",\n \"q\", \"r\", \"s\", \"t\", \"u\", \"v\", \"w\", \"x\", \"y\", \"z\", \"CTRL_US\", \"CTRL_ML\", \"CTRL_DL\", \"CTRL_BS\"\n };\n\n private static final String[] MIXED_TABLE = {\n \"CTRL_PS\", \" \", \"\\1\", \"\\2\", \"\\3\", \"\\4\", \"\\5\", \"\\6\", \"\\7\", \"\\b\", \"\\t\", \"\\n\",\n \"\\13\", \"\\f\", \"\\r\", \"\\33\", \"\\34\", \"\\35\", \"\\36\", \"\\37\", \"@\", \"\\\\\", \"^\", \"_\",\n \"`\", \"|\", \"~\", \"\\177\", \"CTRL_LL\", \"CTRL_UL\", \"CTRL_PL\", \"CTRL_BS\"\n };\n\n private static final String[] PUNCT_TABLE = {\n \"\", \"\\r\", \"\\r\\n\", \". \", \", \", \": \", \"!\", \"\\\"\", \"#\", \"$\", \"%\", \"&\", \"'\", \"(\", \")\",\n \"*\", \"+\", \",\", \"-\", \".\", \"/\", \":\", \";\", \"<\", \"=\", \">\", \"?\", \"[\", \"]\", \"{\", \"}\", \"CTRL_UL\"\n };\n\n private static final String[] DIGIT_TABLE = {\n \"CTRL_PS\", \" \", \"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \",\", \".\", \"CTRL_UL\", \"CTRL_US\"\n };\n\n private AztecDetectorResult ddata;\n\n public DecoderResult decode(AztecDetectorResult detectorResult) throws FormatException {\n ddata = detectorResult;\n BitMatrix matrix = detectorResult.getBits();\n boolean[] rawbits = extractBits(matrix);\n boolean[] correctedBits = correctBits(rawbits);\n byte[] rawBytes = convertBoolArrayToByteArray(correctedBits);\n String result = getEncodedData(correctedBits);\n DecoderResult decoderResult = new DecoderResult(rawBytes, result, null, null);\n decoderResult.setNumBits(correctedBits.length);\n return decoderResult;\n }\n\n // This method is used for testing the high-level encoder\n public static String highLevelDecode(boolean[] correctedBits) {\n return getEncodedData(correctedBits);\n }\n\n /**\n * Gets the string encoded in the aztec code bits\n *\n * @return the decoded string\n */\n private static String getEncodedData(boolean[] correctedBits) {\n int endIndex = correctedBits.length;\n Table latchTable = Table.UPPER; // table most recently latched to\n Table shiftTable = Table.UPPER; // table to use for the next read\n StringBuilder result = new StringBuilder(20);\n int index = 0;\n while (index < endIndex) {\n if (shiftTable == Table.BINARY) {\n if (endIndex - index < 5) {\n break;\n }\n int length = readCode(correctedBits, index, 5);\n index += 5;\n if (length == 0) {\n if (endIndex - index < 11) {\n break;\n }\n length = readCode(correctedBits, index, 11) + 31;\n index += 11;\n }\n for (int charCount = 0; charCount < length; charCount++) {\n if (endIndex - index < 8) {\n index = endIndex; // Force outer loop to exit\n break;\n }\n int code = readCode(correctedBits, index, 8);\n result.append((char) code);\n index += 8;\n }\n // Go back to whatever mode we had been in\n shiftTable = latchTable;\n } else {\n int size = shiftTable == Table.DIGIT ? 4 : 5;\n if (endIndex - index < size) {\n break;\n }\n int code = readCode(correctedBits, index, size);\n index += size;\n String str = getCharacter(shiftTable, code);\n if (str.startsWith(\"CTRL_\")) {\n // Table changes\n // ISO/IEC 24778:2008 prescribes ending a shift sequence in the mode from which it was invoked.\n // That's including when that mode is a shift.\n // Our test case dlusbs.png for issue #642 exercises that.\n latchTable = shiftTable; // Latch the current mode, so as to return to Upper after U/S B/S\n shiftTable = getTable(str.charAt(5));\n if (str.charAt(6) == 'L') {\n latchTable = shiftTable;\n }\n } else {\n result.append(str);\n // Go back to whatever mode we had been in\n shiftTable = latchTable;\n }\n }\n }\n return result.toString();\n }\n\n /**\n * gets the table corresponding to the char passed\n */\n private static Table getTable(char t) {\n switch (t) {\n case 'L':\n return Table.LOWER;\n case 'P':\n return Table.PUNCT;\n case 'M':\n return Table.MIXED;\n case 'D':\n return Table.DIGIT;\n case 'B':\n return Table.BINARY;\n case 'U':\n default:\n return Table.UPPER;\n }\n }\n\n /**\n * Gets the character (or string) corresponding to the passed code in the given table\n *\n * @param table the table used\n * @param code the code of the character\n */\n private static String getCharacter(Table table, int code) {\n switch (table) {\n case UPPER:\n return UPPER_TABLE[code];\n case LOWER:\n return LOWER_TABLE[code];\n case MIXED:\n return MIXED_TABLE[code];\n case PUNCT:\n return PUNCT_TABLE[code];\n case DIGIT:\n return DIGIT_TABLE[code];\n default:\n // Should not reach here.\n throw new IllegalStateException(\"Bad table\");\n }\n }\n\n /**\n *Performs RS error correction on an array of bits.
\n *\n * @return the corrected array\n * @throws FormatException if the input contains too many errors\n */\n private boolean[] correctBits(boolean[] rawbits) throws FormatException {\n GenericGF gf;\n int codewordSize;\n\n if (ddata.getNbLayers() <= 2) {\n codewordSize = 6;\n gf = GenericGF.AZTEC_DATA_6;\n } else if (ddata.getNbLayers() <= 8) {\n codewordSize = 8;\n gf = GenericGF.AZTEC_DATA_8;\n } else if (ddata.getNbLayers() <= 22) {\n codewordSize = 10;\n gf = GenericGF.AZTEC_DATA_10;\n } else {\n codewordSize = 12;\n gf = GenericGF.AZTEC_DATA_12;\n }\n\n int numDataCodewords = ddata.getNbDatablocks();\n int numCodewords = rawbits.length / codewordSize;\n if (numCodewords < numDataCodewords) {\n throw FormatException.getFormatInstance();\n }\n int offset = rawbits.length % codewordSize;\n\n int[] dataWords = new int[numCodewords];\n for (int i = 0; i < numCodewords; i++, offset += codewordSize) {\n dataWords[i] = readCode(rawbits, offset, codewordSize);\n }\n\n try {\n ReedSolomonDecoder rsDecoder = new ReedSolomonDecoder(gf);\n rsDecoder.decode(dataWords, numCodewords - numDataCodewords);\n } catch (ReedSolomonException ex) {\n throw FormatException.getFormatInstance(ex);\n }\n\n // Now perform the unstuffing operation.\n // First, count how many bits are going to be thrown out as stuffing\n int mask = (1 << codewordSize) - 1;\n int stuffedBits = 0;\n for (int i = 0; i < numDataCodewords; i++) {\n int dataWord = dataWords[i];\n if (dataWord == 0 || dataWord == mask) {\n throw FormatException.getFormatInstance();\n } else if (dataWord == 1 || dataWord == mask - 1) {\n stuffedBits++;\n }\n }\n // Now, actually unpack the bits and remove the stuffing\n boolean[] correctedBits = new boolean[numDataCodewords * codewordSize - stuffedBits];\n int index = 0;\n for (int i = 0; i < numDataCodewords; i++) {\n int dataWord = dataWords[i];\n if (dataWord == 1 || dataWord == mask - 1) {\n // next codewordSize-1 bits are all zeros or all ones\n Arrays.fill(correctedBits, index, index + codewordSize - 1, dataWord > 1);\n index += codewordSize - 1;\n } else {\n for (int bit = codewordSize - 1; bit >= 0; --bit) {\n correctedBits[index++] = (dataWord & (1 << bit)) != 0;\n }\n }\n }\n return correctedBits;\n }\n\n /**\n * Gets the array of bits from an Aztec Code matrix\n *\n * @return the array of bits\n */\n private boolean[] extractBits(BitMatrix matrix) {\n boolean compact = ddata.isCompact();\n int layers = ddata.getNbLayers();\n int baseMatrixSize = (compact ? 11 : 14) + layers * 4; // not including alignment lines\n int[] alignmentMap = new int[baseMatrixSize];\n boolean[] rawbits = new boolean[totalBitsInLayer(layers, compact)];\n\n if (compact) {\n for (int i = 0; i < alignmentMap.length; i++) {\n alignmentMap[i] = i;\n }\n } else {\n int matrixSize = baseMatrixSize + 1 + 2 * ((baseMatrixSize / 2 - 1) / 15);\n int origCenter = baseMatrixSize / 2;\n int center = matrixSize / 2;\n for (int i = 0; i < origCenter; i++) {\n int newOffset = i + i / 15;\n alignmentMap[origCenter - i - 1] = center - newOffset - 1;\n alignmentMap[origCenter + i] = center + newOffset + 1;\n }\n }\n for (int i = 0, rowOffset = 0; i < layers; i++) {\n int rowSize = (layers - i) * 4 + (compact ? 9 : 12);\n // The top-left most point of this layer isSee\n * \n * DoCoMo's documentation about the result types represented by subclasses of this class.
\n *\n *Thanks to Jeff Griffin for proposing rewrite of these classes that relies less\n * on exception-based mechanisms during parsing.
\n *\n * @author Sean Owen\n */\nabstract class AbstractDoCoMoResultParser extends ResultParser {\n\n static String[] matchDoCoMoPrefixedField(String prefix, String rawText, boolean trim) {\n return matchPrefixedField(prefix, rawText, ';', trim);\n }\n\n static String matchSingleDoCoMoPrefixedField(String prefix, String rawText, boolean trim) {\n return matchSinglePrefixedField(prefix, rawText, ';', trim);\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/AddressBookAUResultParser.java", "content": "/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\nimport com.google.zxing.Result;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\n/**\n * Implements KDDI AU's address book format. See\n * \n * http://www.au.kddi.com/ezfactory/tec/two_dimensions/index.html.\n * (Thanks to Yuzo for translating!)\n *\n * @author Sean Owen\n */\npublic final class AddressBookAUResultParser extends ResultParser {\n\n @Override\n public AddressBookParsedResult parse(Result result) {\n String rawText = getMassagedText(result);\n // MEMORY is mandatory; seems like a decent indicator, as does end-of-record separator CR/LF\n if (!rawText.contains(\"MEMORY\") || !rawText.contains(\"\\r\\n\")) {\n return null;\n }\n\n // NAME1 and NAME2 have specific uses, namely written name and pronunciation, respectively.\n // Therefore we treat them specially instead of as an array of names.\n String name = matchSinglePrefixedField(\"NAME1:\", rawText, '\\r', true);\n String pronunciation = matchSinglePrefixedField(\"NAME2:\", rawText, '\\r', true);\n\n String[] phoneNumbers = matchMultipleValuePrefix(\"TEL\", 3, rawText, true);\n String[] emails = matchMultipleValuePrefix(\"MAIL\", 3, rawText, true);\n String note = matchSinglePrefixedField(\"MEMORY:\", rawText, '\\r', false);\n String address = matchSinglePrefixedField(\"ADD:\", rawText, '\\r', true);\n String[] addresses = address == null ? null : new String[] {address};\n return new AddressBookParsedResult(maybeWrap(name),\n null,\n pronunciation,\n phoneNumbers,\n null,\n emails,\n null,\n null,\n note,\n addresses,\n null,\n null,\n null,\n null,\n null,\n null);\n }\n\n private static String[] matchMultipleValuePrefix(String prefix,\n int max,\n String rawText,\n boolean trim) {\n ListAbstract class representing the result of decoding a barcode, as more than\n * a String -- as some type of structured data. This might be a subclass which represents\n * a URL, or an e-mail address. {@link ResultParser#parseResult(com.google.zxing.Result)} will turn a raw\n * decoded string into the most appropriate type of structured representation.
\n *\n *Thanks to Jeff Griffin for proposing rewrite of these classes that relies less\n * on exception-based mechanisms during parsing.
\n *\n * @author Sean Owen\n */\npublic abstract class ParsedResult {\n\n private final ParsedResultType type;\n\n protected ParsedResult(ParsedResultType type) {\n this.type = type;\n }\n\n public final ParsedResultType getType() {\n return type;\n }\n\n public abstract String getDisplayResult();\n\n @Override\n public final String toString() {\n return getDisplayResult();\n }\n\n public static void maybeAppend(String value, StringBuilder result) {\n if (value != null && !value.isEmpty()) {\n // Don't add a newline before the first value\n if (result.length() > 0) {\n result.append('\\n');\n }\n result.append(value);\n }\n }\n\n public static void maybeAppend(String[] values, StringBuilder result) {\n if (values != null) {\n for (String value : values) {\n maybeAppend(value, result);\n }\n }\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/ParsedResultType.java", "content": "/*\n * Copyright 2010 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\n/**\n * Represents the type of data encoded by a barcode -- from plain text, to a\n * URI, to an e-mail address, etc.\n *\n * @author Sean Owen\n */\npublic enum ParsedResultType {\n\n ADDRESSBOOK,\n EMAIL_ADDRESS,\n PRODUCT,\n URI,\n TEXT,\n GEO,\n TEL,\n SMS,\n CALENDAR,\n WIFI,\n ISBN,\n VIN,\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/ProductParsedResult.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\n/**\n * Represents a parsed result that encodes a product by an identifier of some kind.\n *\n * @author dswitkin@google.com (Daniel Switkin)\n */\npublic final class ProductParsedResult extends ParsedResult {\n\n private final String productID;\n private final String normalizedProductID;\n\n ProductParsedResult(String productID) {\n this(productID, productID);\n }\n\n ProductParsedResult(String productID, String normalizedProductID) {\n super(ParsedResultType.PRODUCT);\n this.productID = productID;\n this.normalizedProductID = normalizedProductID;\n }\n\n public String getProductID() {\n return productID;\n }\n\n public String getNormalizedProductID() {\n return normalizedProductID;\n }\n\n @Override\n public String getDisplayResult() {\n return productID;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/ProductResultParser.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\nimport com.google.zxing.BarcodeFormat;\nimport com.google.zxing.Result;\nimport com.google.zxing.oned.UPCEReader;\n\n/**\n * Parses strings of digits that represent a UPC code.\n * \n * @author dswitkin@google.com (Daniel Switkin)\n */\npublic final class ProductResultParser extends ResultParser {\n\n // Treat all UPC and EAN variants as UPCs, in the sense that they are all product barcodes.\n @Override\n public ProductParsedResult parse(Result result) {\n BarcodeFormat format = result.getBarcodeFormat();\n if (!(format == BarcodeFormat.UPC_A || format == BarcodeFormat.UPC_E ||\n format == BarcodeFormat.EAN_8 || format == BarcodeFormat.EAN_13)) {\n return null;\n }\n String rawText = getMassagedText(result);\n if (!isStringOfDigits(rawText, rawText.length())) {\n return null;\n }\n // Not actually checking the checksum again here \n\n String normalizedProductID;\n // Expand UPC-E for purposes of searching\n if (format == BarcodeFormat.UPC_E && rawText.length() == 8) {\n normalizedProductID = UPCEReader.convertUPCEtoUPCA(rawText);\n } else {\n normalizedProductID = rawText;\n }\n\n return new ProductParsedResult(rawText, normalizedProductID);\n }\n\n}" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/ResultParser.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\nimport com.google.zxing.Result;\n\nimport java.io.UnsupportedEncodingException;\nimport java.net.URLDecoder;\nimport java.util.ArrayList;\nimport java.util.HashMap;\nimport java.util.List;\nimport java.util.Map;\nimport java.util.regex.Pattern;\n\n/**\n *Abstract class representing the result of decoding a barcode, as more than\n * a String -- as some type of structured data. This might be a subclass which represents\n * a URL, or an e-mail address. {@link #parseResult(Result)} will turn a raw\n * decoded string into the most appropriate type of structured representation.
\n *\n *Thanks to Jeff Griffin for proposing rewrite of these classes that relies less\n * on exception-based mechanisms during parsing.
\n *\n * @author Sean Owen\n */\npublic abstract class ResultParser {\n\n private static final ResultParser[] PARSERS = {\n new BookmarkDoCoMoResultParser(),\n new AddressBookDoCoMoResultParser(),\n new EmailDoCoMoResultParser(),\n new AddressBookAUResultParser(),\n new VCardResultParser(),\n new BizcardResultParser(),\n new VEventResultParser(),\n new EmailAddressResultParser(),\n new SMTPResultParser(),\n new TelResultParser(),\n new SMSMMSResultParser(),\n new SMSTOMMSTOResultParser(),\n new GeoResultParser(),\n new WifiResultParser(),\n new URLTOResultParser(),\n new URIResultParser(),\n new ISBNResultParser(),\n new ProductResultParser(),\n new ExpandedProductResultParser(),\n new VINResultParser(),\n };\n\n private static final Pattern DIGITS = Pattern.compile(\"\\\\d+\");\n private static final Pattern AMPERSAND = Pattern.compile(\"&\");\n private static final Pattern EQUALS = Pattern.compile(\"=\");\n private static final String BYTE_ORDER_MARK = \"\\ufeff\";\n\n static final String[] EMPTY_STR_ARRAY = new String[0];\n\n /**\n * Attempts to parse the raw {@link Result}'s contents as a particular type\n * of information (email, URL, etc.) and return a {@link ParsedResult} encapsulating\n * the result of parsing.\n *\n * @param theResult the raw {@link Result} to parse\n * @return {@link ParsedResult} encapsulating the parsing result\n */\n public abstract ParsedResult parse(Result theResult);\n\n protected static String getMassagedText(Result result) {\n String text = result.getText();\n if (text.startsWith(BYTE_ORDER_MARK)) {\n text = text.substring(1);\n }\n return text;\n }\n\n public static ParsedResult parseResult(Result theResult) {\n for (ResultParser parser : PARSERS) {\n ParsedResult result = parser.parse(theResult);\n if (result != null) {\n return result;\n }\n }\n return new TextParsedResult(theResult.getText(), null);\n }\n\n protected static void maybeAppend(String value, StringBuilder result) {\n if (value != null) {\n result.append('\\n');\n result.append(value);\n }\n }\n\n protected static void maybeAppend(String[] value, StringBuilder result) {\n if (value != null) {\n for (String s : value) {\n result.append('\\n');\n result.append(s);\n }\n }\n }\n\n protected static String[] maybeWrap(String value) {\n return value == null ? null : new String[] { value };\n }\n\n protected static String unescapeBackslash(String escaped) {\n int backslash = escaped.indexOf('\\\\');\n if (backslash < 0) {\n return escaped;\n }\n int max = escaped.length();\n StringBuilder unescaped = new StringBuilder(max - 1);\n unescaped.append(escaped.toCharArray(), 0, backslash);\n boolean nextIsEscaped = false;\n for (int i = backslash; i < max; i++) {\n char c = escaped.charAt(i);\n if (nextIsEscaped || c != '\\\\') {\n unescaped.append(c);\n nextIsEscaped = false;\n } else {\n nextIsEscaped = true;\n }\n }\n return unescaped.toString();\n }\n\n protected static int parseHexDigit(char c) {\n if (c >= '0' && c <= '9') {\n return c - '0';\n }\n if (c >= 'a' && c <= 'f') {\n return 10 + (c - 'a');\n }\n if (c >= 'A' && c <= 'F') {\n return 10 + (c - 'A');\n }\n return -1;\n }\n\n protected static boolean isStringOfDigits(CharSequence value, int length) {\n return value != null && length > 0 && length == value.length() && DIGITS.matcher(value).matches();\n }\n\n protected static boolean isSubstringOfDigits(CharSequence value, int offset, int length) {\n if (value == null || length <= 0) {\n return false;\n }\n int max = offset + length;\n return value.length() >= max && DIGITS.matcher(value.subSequence(offset, max)).matches();\n }\n\n static MapParses an \"sms:\" URI result, which specifies a number to SMS.\n * See RFC 5724 on this.
\n *\n *This class supports \"via\" syntax for numbers, which is not part of the spec.\n * For example \"+12125551212;via=+12124440101\" may appear as a number.\n * It also supports a \"subject\" query parameter, which is not mentioned in the spec.\n * These are included since they were mentioned in earlier IETF drafts and might be\n * used.
\n *\n *This actually also parses URIs starting with \"mms:\" and treats them all the same way,\n * and effectively converts them to an \"sms:\" URI for purposes of forwarding to the platform.
\n *\n * @author Sean Owen\n */\npublic final class SMSMMSResultParser extends ResultParser {\n\n @Override\n public SMSParsedResult parse(Result result) {\n String rawText = getMassagedText(result);\n if (!(rawText.startsWith(\"sms:\") || rawText.startsWith(\"SMS:\") ||\n rawText.startsWith(\"mms:\") || rawText.startsWith(\"MMS:\"))) {\n return null;\n }\n\n // Check up front if this is a URI syntax string with query arguments\n MapParses an \"smsto:\" URI result, whose format is not standardized but appears to be like:\n * {@code smsto:number(:body)}.
\n *\n *This actually also parses URIs starting with \"smsto:\", \"mmsto:\", \"SMSTO:\", and\n * \"MMSTO:\", and treats them all the same way, and effectively converts them to an \"sms:\" URI\n * for purposes of forwarding to the platform.
\n *\n * @author Sean Owen\n */\npublic final class SMSTOMMSTOResultParser extends ResultParser {\n\n @Override\n public SMSParsedResult parse(Result result) {\n String rawText = getMassagedText(result);\n if (!(rawText.startsWith(\"smsto:\") || rawText.startsWith(\"SMSTO:\") ||\n rawText.startsWith(\"mmsto:\") || rawText.startsWith(\"MMSTO:\"))) {\n return null;\n }\n // Thanks to dominik.wild for suggesting this enhancement to support\n // smsto:number:body URIs\n String number = rawText.substring(6);\n String body = null;\n int bodyStart = number.indexOf(':');\n if (bodyStart >= 0) {\n body = number.substring(bodyStart + 1);\n number = number.substring(0, bodyStart);\n }\n return new SMSParsedResult(number, null, null, body);\n }\n\n}" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/SMTPResultParser.java", "content": "/*\n * Copyright 2010 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\nimport com.google.zxing.Result;\n\n/**\n *Parses an \"smtp:\" URI result, whose format is not standardized but appears to be like:\n * {@code smtp[:subject[:body]]}.
\n *\n * @author Sean Owen\n */\npublic final class SMTPResultParser extends ResultParser {\n\n @Override\n public EmailAddressParsedResult parse(Result result) {\n String rawText = getMassagedText(result);\n if (!(rawText.startsWith(\"smtp:\") || rawText.startsWith(\"SMTP:\"))) {\n return null;\n }\n String emailAddress = rawText.substring(5);\n String subject = null;\n String body = null;\n int colon = emailAddress.indexOf(':');\n if (colon >= 0) {\n subject = emailAddress.substring(colon + 1);\n emailAddress = emailAddress.substring(0, colon);\n colon = subject.indexOf(':');\n if (colon >= 0) {\n body = subject.substring(colon + 1);\n subject = subject.substring(0, colon);\n }\n }\n return new EmailAddressParsedResult(new String[] {emailAddress},\n null,\n null,\n subject,\n body);\n }\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/TelParsedResult.java", "content": "/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\n/**\n * Represents a parsed result that encodes a telephone number.\n *\n * @author Sean Owen\n */\npublic final class TelParsedResult extends ParsedResult {\n\n private final String number;\n private final String telURI;\n private final String title;\n\n public TelParsedResult(String number, String telURI, String title) {\n super(ParsedResultType.TEL);\n this.number = number;\n this.telURI = telURI;\n this.title = title;\n }\n\n public String getNumber() {\n return number;\n }\n\n public String getTelURI() {\n return telURI;\n }\n\n public String getTitle() {\n return title;\n }\n\n @Override\n public String getDisplayResult() {\n StringBuilder result = new StringBuilder(20);\n maybeAppend(number, result);\n maybeAppend(title, result);\n return result.toString();\n }\n\n}" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/TelResultParser.java", "content": "/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\nimport com.google.zxing.Result;\n\n/**\n * Parses a \"tel:\" URI result, which specifies a phone number.\n *\n * @author Sean Owen\n */\npublic final class TelResultParser extends ResultParser {\n\n @Override\n public TelParsedResult parse(Result result) {\n String rawText = getMassagedText(result);\n if (!rawText.startsWith(\"tel:\") && !rawText.startsWith(\"TEL:\")) {\n return null;\n }\n // Normalize \"TEL:\" to \"tel:\"\n String telURI = rawText.startsWith(\"TEL:\") ? \"tel:\" + rawText.substring(4) : rawText;\n // Drop tel, query portion\n int queryStart = rawText.indexOf('?', 4);\n String number = queryStart < 0 ? rawText.substring(4) : rawText.substring(4, queryStart);\n return new TelParsedResult(number, telURI, null);\n }\n\n}" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/TextParsedResult.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\n/**\n * A simple result type encapsulating a string that has no further\n * interpretation.\n * \n * @author Sean Owen\n */\npublic final class TextParsedResult extends ParsedResult {\n\n private final String text;\n private final String language;\n\n public TextParsedResult(String text, String language) {\n super(ParsedResultType.TEXT);\n this.text = text;\n this.language = language;\n }\n\n public String getText() {\n return text;\n }\n\n public String getLanguage() {\n return language;\n }\n\n @Override\n public String getDisplayResult() {\n return text;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/URIParsedResult.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\n/**\n * A simple result type encapsulating a URI that has no further interpretation.\n *\n * @author Sean Owen\n */\npublic final class URIParsedResult extends ParsedResult {\n\n private final String uri;\n private final String title;\n\n public URIParsedResult(String uri, String title) {\n super(ParsedResultType.URI);\n this.uri = massageURI(uri);\n this.title = title;\n }\n\n public String getURI() {\n return uri;\n }\n\n public String getTitle() {\n return title;\n }\n\n /**\n * @return true if the URI contains suspicious patterns that may suggest it intends to\n * mislead the user about its true nature\n * @deprecated see {@link URIResultParser#isPossiblyMaliciousURI(String)}\n */\n @Deprecated\n public boolean isPossiblyMaliciousURI() {\n return URIResultParser.isPossiblyMaliciousURI(uri);\n }\n\n @Override\n public String getDisplayResult() {\n StringBuilder result = new StringBuilder(30);\n maybeAppend(title, result);\n maybeAppend(uri, result);\n return result.toString();\n }\n\n /**\n * Transforms a string that represents a URI into something more proper, by adding or canonicalizing\n * the protocol.\n */\n private static String massageURI(String uri) {\n uri = uri.trim();\n int protocolEnd = uri.indexOf(':');\n if (protocolEnd < 0 || isColonFollowedByPortNumber(uri, protocolEnd)) {\n // No protocol, or found a colon, but it looks like it is after the host, so the protocol is still missing,\n // so assume http\n uri = \"http://\" + uri;\n }\n return uri;\n }\n\n private static boolean isColonFollowedByPortNumber(String uri, int protocolEnd) {\n int start = protocolEnd + 1;\n int nextSlash = uri.indexOf('/', start);\n if (nextSlash < 0) {\n nextSlash = uri.length();\n }\n return ResultParser.isSubstringOfDigits(uri, start, nextSlash - start);\n }\n\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/URIResultParser.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\nimport com.google.zxing.Result;\n\nimport java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\n/**\n * Tries to parse results that are a URI of some kind.\n * \n * @author Sean Owen\n */\npublic final class URIResultParser extends ResultParser {\n\n private static final Pattern ALLOWED_URI_CHARS_PATTERN =\n Pattern.compile(\"[-._~:/?#\\\\[\\\\]@!$&'()*+,;=%A-Za-z0-9]+\");\n private static final Pattern USER_IN_HOST = Pattern.compile(\":/*([^/@]+)@[^/]+\");\n // See http://www.ietf.org/rfc/rfc2396.txt\n private static final Pattern URL_WITH_PROTOCOL_PATTERN = Pattern.compile(\"[a-zA-Z][a-zA-Z0-9+-.]+:\");\n private static final Pattern URL_WITHOUT_PROTOCOL_PATTERN = Pattern.compile(\n \"([a-zA-Z0-9\\\\-]+\\\\.){1,6}[a-zA-Z]{2,}\" + // host name elements; allow up to say 6 domain elements\n \"(:\\\\d{1,5})?\" + // maybe port\n \"(/|\\\\?|$)\"); // query, path or nothing\n\n @Override\n public URIParsedResult parse(Result result) {\n String rawText = getMassagedText(result);\n // We specifically handle the odd \"URL\" scheme here for simplicity and add \"URI\" for fun\n // Assume anything starting this way really means to be a URI\n if (rawText.startsWith(\"URL:\") || rawText.startsWith(\"URI:\")) {\n return new URIParsedResult(rawText.substring(4).trim(), null);\n }\n rawText = rawText.trim();\n if (!isBasicallyValidURI(rawText) || isPossiblyMaliciousURI(rawText)) {\n return null;\n }\n return new URIParsedResult(rawText, null);\n }\n\n /**\n * @return true if the URI contains suspicious patterns that may suggest it intends to\n * mislead the user about its true nature. At the moment this looks for the presence\n * of user/password syntax in the host/authority portion of a URI which may be used\n * in attempts to make the URI's host appear to be other than it is. Example:\n * http://yourbank.com@phisher.com This URI connects to phisher.com but may appear\n * to connect to yourbank.com at first glance.\n */\n static boolean isPossiblyMaliciousURI(String uri) {\n return !ALLOWED_URI_CHARS_PATTERN.matcher(uri).matches() || USER_IN_HOST.matcher(uri).find();\n }\n\n static boolean isBasicallyValidURI(String uri) {\n if (uri.contains(\" \")) {\n // Quick hack check for a common case\n return false;\n }\n Matcher m = URL_WITH_PROTOCOL_PATTERN.matcher(uri);\n if (m.find() && m.start() == 0) { // match at start only\n return true;\n }\n m = URL_WITHOUT_PROTOCOL_PATTERN.matcher(uri);\n return m.find() && m.start() == 0;\n }\n\n}" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/URLTOResultParser.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\nimport com.google.zxing.Result;\n\n/**\n * Parses the \"URLTO\" result format, which is of the form \"URLTO:[title]:[url]\".\n * This seems to be used sometimes, but I am not able to find documentation\n * on its origin or official format?\n *\n * @author Sean Owen\n */\npublic final class URLTOResultParser extends ResultParser {\n\n @Override\n public URIParsedResult parse(Result result) {\n String rawText = getMassagedText(result);\n if (!rawText.startsWith(\"urlto:\") && !rawText.startsWith(\"URLTO:\")) {\n return null;\n }\n int titleEnd = rawText.indexOf(':', 6);\n if (titleEnd < 0) {\n return null;\n }\n String title = titleEnd <= 6 ? null : rawText.substring(6, titleEnd);\n String uri = rawText.substring(titleEnd + 1);\n return new URIParsedResult(uri, title);\n }\n\n}" }, { "path": "scanner/src/main/java/com/google/zxing/client/result/VCardResultParser.java", "content": "/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.client.result;\n\nimport com.google.zxing.Result;\n\nimport java.io.ByteArrayOutputStream;\nimport java.io.UnsupportedEncodingException;\nimport java.net.URI;\nimport java.nio.charset.StandardCharsets;\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.List;\nimport java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\n/**\n * Parses contact information formatted according to the VCard (2.1) format. This is not a complete\n * implementation but should parse information as commonly encoded in 2D barcodes.\n *\n * @author Sean Owen\n */\npublic final class VCardResultParser extends ResultParser {\n\n private static final Pattern BEGIN_VCARD = Pattern.compile(\"BEGIN:VCARD\", Pattern.CASE_INSENSITIVE);\n private static final Pattern VCARD_LIKE_DATE = Pattern.compile(\"\\\\d{4}-?\\\\d{2}-?\\\\d{2}\");\n private static final Pattern CR_LF_SPACE_TAB = Pattern.compile(\"\\r\\n[ \\t]\");\n private static final Pattern NEWLINE_ESCAPE = Pattern.compile(\"\\\\\\\\[nN]\");\n private static final Pattern VCARD_ESCAPES = Pattern.compile(\"\\\\\\\\([,;\\\\\\\\])\");\n private static final Pattern EQUALS = Pattern.compile(\"=\");\n private static final Pattern SEMICOLON = Pattern.compile(\";\");\n private static final Pattern UNESCAPED_SEMICOLONS = Pattern.compile(\"(?> names = matchVCardPrefixedField(\"FN\", rawText, true, false);\n if (names == null) {\n // If no display names found, look for regular name fields and format them\n names = matchVCardPrefixedField(\"N\", rawText, true, false);\n formatNames(names);\n }\n ListParses a WIFI configuration string. Strings will be of the form:
\n *\n *{@code WIFI:T:[network type];S:[network SSID];P:[network password];H:[hidden?];;}
\n *\n *For WPA2 enterprise (EAP), strings will be of the form:
\n *\n *{@code WIFI:T:WPA2-EAP;S:[network SSID];H:[hidden?];E:[EAP method];H:[Phase 2 method];A:[anonymous identity];I:[username];P:[password];;}
\n *\n *\"EAP method\" can e.g. be \"TTLS\" or \"PWD\" or one of the other fields in WifiEnterpriseConfig.Eap and \"Phase 2 method\" can e.g. be \"MSCHAPV2\" or any of the other fields in WifiEnterpriseConfig.Phase2
\n *\n *The fields can appear in any order. Only \"S:\" is required.
\n *\n * @author Vikram Aggarwal\n * @author Sean Owen\n * @author Steffen Kieß\n */\npublic final class WifiResultParser extends ResultParser {\n\n @Override\n public WifiParsedResult parse(Result result) {\n String rawText = getMassagedText(result);\n if (!rawText.startsWith(\"WIFI:\")) {\n return null;\n }\n rawText = rawText.substring(\"WIFI:\".length());\n String ssid = matchSinglePrefixedField(\"S:\", rawText, ';', false);\n if (ssid == null || ssid.isEmpty()) {\n return null;\n }\n String pass = matchSinglePrefixedField(\"P:\", rawText, ';', false);\n String type = matchSinglePrefixedField(\"T:\", rawText, ';', false);\n if (type == null) {\n type = \"nopass\";\n }\n boolean hidden = Boolean.parseBoolean(matchSinglePrefixedField(\"H:\", rawText, ';', false));\n String identity = matchSinglePrefixedField(\"I:\", rawText, ';', false);\n String anonymousIdentity = matchSinglePrefixedField(\"A:\", rawText, ';', false);\n String eapMethod = matchSinglePrefixedField(\"E:\", rawText, ';', false);\n String phase2Method = matchSinglePrefixedField(\"H:\", rawText, ';', false);\n return new WifiParsedResult(type, ssid, pass, hidden, identity, anonymousIdentity, eapMethod, phase2Method);\n }\n}" }, { "path": "scanner/src/main/java/com/google/zxing/common/BitArray.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common;\n\nimport java.util.Arrays;\n\n/**\n *A simple, fast array of bits, represented compactly by an array of ints internally.
\n *\n * @author Sean Owen\n */\npublic final class BitArray implements Cloneable {\n\n private int[] bits;\n private int size;\n\n public BitArray() {\n this.size = 0;\n this.bits = new int[1];\n }\n\n public BitArray(int size) {\n this.size = size;\n this.bits = makeArray(size);\n }\n\n // For testing only\n BitArray(int[] bits, int size) {\n this.bits = bits;\n this.size = size;\n }\n\n public int getSize() {\n return size;\n }\n\n public int getSizeInBytes() {\n return (size + 7) / 8;\n }\n\n private void ensureCapacity(int size) {\n if (size > bits.length * 32) {\n int[] newBits = makeArray(size);\n System.arraycopy(bits, 0, newBits, 0, bits.length);\n this.bits = newBits;\n }\n }\n\n /**\n * @param i bit to get\n * @return true iff bit i is set\n */\n public boolean get(int i) {\n return (bits[i / 32] & (1 << (i & 0x1F))) != 0;\n }\n\n /**\n * Sets bit i.\n *\n * @param i bit to set\n */\n public void set(int i) {\n bits[i / 32] |= 1 << (i & 0x1F);\n }\n\n /**\n * Flips bit i.\n *\n * @param i bit to set\n */\n public void flip(int i) {\n bits[i / 32] ^= 1 << (i & 0x1F);\n }\n\n /**\n * @param from first bit to check\n * @return index of first bit that is set, starting from the given index, or size if none are set\n * at or beyond this given index\n * @see #getNextUnset(int)\n */\n public int getNextSet(int from) {\n if (from >= size) {\n return size;\n }\n int bitsOffset = from / 32;\n int currentBits = bits[bitsOffset];\n // mask off lesser bits first\n currentBits &= -(1 << (from & 0x1F));\n while (currentBits == 0) {\n if (++bitsOffset == bits.length) {\n return size;\n }\n currentBits = bits[bitsOffset];\n }\n int result = (bitsOffset * 32) + Integer.numberOfTrailingZeros(currentBits);\n return result > size ? size : result;\n }\n\n /**\n * @param from index to start looking for unset bit\n * @return index of next unset bit, or {@code size} if none are unset until the end\n * @see #getNextSet(int)\n */\n public int getNextUnset(int from) {\n if (from >= size) {\n return size;\n }\n int bitsOffset = from / 32;\n int currentBits = ~bits[bitsOffset];\n // mask off lesser bits first\n currentBits &= -(1 << (from & 0x1F));\n while (currentBits == 0) {\n if (++bitsOffset == bits.length) {\n return size;\n }\n currentBits = ~bits[bitsOffset];\n }\n int result = (bitsOffset * 32) + Integer.numberOfTrailingZeros(currentBits);\n return result > size ? size : result;\n }\n\n /**\n * Sets a block of 32 bits, starting at bit i.\n *\n * @param i first bit to set\n * @param newBits the new value of the next 32 bits. Note again that the least-significant bit\n * corresponds to bit i, the next-least-significant to i+1, and so on.\n */\n public void setBulk(int i, int newBits) {\n bits[i / 32] = newBits;\n }\n\n /**\n * Sets a range of bits.\n *\n * @param start start of range, inclusive.\n * @param end end of range, exclusive\n */\n public void setRange(int start, int end) {\n if (end < start || start < 0 || end > size) {\n throw new IllegalArgumentException();\n }\n if (end == start) {\n return;\n }\n end--; // will be easier to treat this as the last actually set bit -- inclusive\n int firstInt = start / 32;\n int lastInt = end / 32;\n for (int i = firstInt; i <= lastInt; i++) {\n int firstBit = i > firstInt ? 0 : start & 0x1F;\n int lastBit = i < lastInt ? 31 : end & 0x1F;\n // Ones from firstBit to lastBit, inclusive\n int mask = (2 << lastBit) - (1 << firstBit);\n bits[i] |= mask;\n }\n }\n\n /**\n * Clears all bits (sets to false).\n */\n public void clear() {\n int max = bits.length;\n for (int i = 0; i < max; i++) {\n bits[i] = 0;\n }\n }\n\n /**\n * Efficient method to check if a range of bits is set, or not set.\n *\n * @param start start of range, inclusive.\n * @param end end of range, exclusive\n * @param value if true, checks that bits in range are set, otherwise checks that they are not set\n * @return true iff all bits are set or not set in range, according to value argument\n * @throws IllegalArgumentException if end is less than start or the range is not contained in the array\n */\n public boolean isRange(int start, int end, boolean value) {\n if (end < start || start < 0 || end > size) {\n throw new IllegalArgumentException();\n }\n if (end == start) {\n return true; // empty range matches\n }\n end--; // will be easier to treat this as the last actually set bit -- inclusive\n int firstInt = start / 32;\n int lastInt = end / 32;\n for (int i = firstInt; i <= lastInt; i++) {\n int firstBit = i > firstInt ? 0 : start & 0x1F;\n int lastBit = i < lastInt ? 31 : end & 0x1F;\n // Ones from firstBit to lastBit, inclusive\n int mask = (2 << lastBit) - (1 << firstBit);\n\n // Return false if we're looking for 1s and the masked bits[i] isn't all 1s (that is,\n // equals the mask, or we're looking for 0s and the masked portion is not all 0s\n if ((bits[i] & mask) != (value ? mask : 0)) {\n return false;\n }\n }\n return true;\n }\n\n public void appendBit(boolean bit) {\n ensureCapacity(size + 1);\n if (bit) {\n bits[size / 32] |= 1 << (size & 0x1F);\n }\n size++;\n }\n\n /**\n * Appends the least-significant bits, from value, in order from most-significant to\n * least-significant. For example, appending 6 bits from 0x000001E will append the bits\n * 0, 1, 1, 1, 1, 0 in that order.\n *\n * @param value {@code int} containing bits to append\n * @param numBits bits from value to append\n */\n public void appendBits(int value, int numBits) {\n if (numBits < 0 || numBits > 32) {\n throw new IllegalArgumentException(\"Num bits must be between 0 and 32\");\n }\n ensureCapacity(size + numBits);\n for (int numBitsLeft = numBits; numBitsLeft > 0; numBitsLeft--) {\n appendBit(((value >> (numBitsLeft - 1)) & 0x01) == 1);\n }\n }\n\n public void appendBitArray(BitArray other) {\n int otherSize = other.size;\n ensureCapacity(size + otherSize);\n for (int i = 0; i < otherSize; i++) {\n appendBit(other.get(i));\n }\n }\n\n public void xor(BitArray other) {\n if (size != other.size) {\n throw new IllegalArgumentException(\"Sizes don't match\");\n }\n for (int i = 0; i < bits.length; i++) {\n // The last int could be incomplete (i.e. not have 32 bits in\n // it) but there is no problem since 0 XOR 0 == 0.\n bits[i] ^= other.bits[i];\n }\n }\n\n /**\n *\n * @param bitOffset first bit to start writing\n * @param array array to write into. Bytes are written most-significant byte first. This is the opposite\n * of the internal representation, which is exposed by {@link #getBitArray()}\n * @param offset position in array to start writing\n * @param numBytes how many bytes to write\n */\n public void toBytes(int bitOffset, byte[] array, int offset, int numBytes) {\n for (int i = 0; i < numBytes; i++) {\n int theByte = 0;\n for (int j = 0; j < 8; j++) {\n if (get(bitOffset)) {\n theByte |= 1 << (7 - j);\n }\n bitOffset++;\n }\n array[offset + i] = (byte) theByte;\n }\n }\n\n /**\n * @return underlying array of ints. The first element holds the first 32 bits, and the least\n * significant bit is bit 0.\n */\n public int[] getBitArray() {\n return bits;\n }\n\n /**\n * Reverses all bits in the array.\n */\n public void reverse() {\n int[] newBits = new int[bits.length];\n // reverse all int's first\n int len = (size - 1) / 32;\n int oldBitsLen = len + 1;\n for (int i = 0; i < oldBitsLen; i++) {\n long x = bits[i];\n x = ((x >> 1) & 0x55555555L) | ((x & 0x55555555L) << 1);\n x = ((x >> 2) & 0x33333333L) | ((x & 0x33333333L) << 2);\n x = ((x >> 4) & 0x0f0f0f0fL) | ((x & 0x0f0f0f0fL) << 4);\n x = ((x >> 8) & 0x00ff00ffL) | ((x & 0x00ff00ffL) << 8);\n x = ((x >> 16) & 0x0000ffffL) | ((x & 0x0000ffffL) << 16);\n newBits[len - i] = (int) x;\n }\n // now correct the int's if the bit size isn't a multiple of 32\n if (size != oldBitsLen * 32) {\n int leftOffset = oldBitsLen * 32 - size;\n int currentInt = newBits[0] >>> leftOffset;\n for (int i = 1; i < oldBitsLen; i++) {\n int nextInt = newBits[i];\n currentInt |= nextInt << (32 - leftOffset);\n newBits[i - 1] = currentInt;\n currentInt = nextInt >>> leftOffset;\n }\n newBits[oldBitsLen - 1] = currentInt;\n }\n bits = newBits;\n }\n\n private static int[] makeArray(int size) {\n return new int[(size + 31) / 32];\n }\n\n @Override\n public boolean equals(Object o) {\n if (!(o instanceof BitArray)) {\n return false;\n }\n BitArray other = (BitArray) o;\n return size == other.size && Arrays.equals(bits, other.bits);\n }\n\n @Override\n public int hashCode() {\n return 31 * size + Arrays.hashCode(bits);\n }\n\n @Override\n public String toString() {\n StringBuilder result = new StringBuilder(size + (size / 8) + 1);\n for (int i = 0; i < size; i++) {\n if ((i & 0x07) == 0) {\n result.append(' ');\n }\n result.append(get(i) ? 'X' : '.');\n }\n return result.toString();\n }\n\n @Override\n public BitArray clone() {\n return new BitArray(bits.clone(), size);\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/common/BitMatrix.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common;\n\nimport java.util.Arrays;\n\n/**\n *Represents a 2D matrix of bits. In function arguments below, and throughout the common\n * module, x is the column position, and y is the row position. The ordering is always x, y.\n * The origin is at the top-left.
\n *\n *Internally the bits are represented in a 1-D array of 32-bit ints. However, each row begins\n * with a new int. This is done intentionally so that we can copy out a row into a BitArray very\n * efficiently.
\n *\n *The ordering of bits is row-major. Within each int, the least significant bits are used first,\n * meaning they represent lower x values. This is compatible with BitArray's implementation.
\n *\n * @author Sean Owen\n * @author dswitkin@google.com (Daniel Switkin)\n */\npublic final class BitMatrix implements Cloneable {\n\n private final int width;\n private final int height;\n private final int rowSize;\n private final int[] bits;\n\n /**\n * Creates an empty square {@code BitMatrix}.\n *\n * @param dimension height and width\n */\n public BitMatrix(int dimension) {\n this(dimension, dimension);\n }\n\n /**\n * Creates an empty {@code BitMatrix}.\n *\n * @param width bit matrix width\n * @param height bit matrix height\n */\n public BitMatrix(int width, int height) {\n if (width < 1 || height < 1) {\n throw new IllegalArgumentException(\"Both dimensions must be greater than 0\");\n }\n this.width = width;\n this.height = height;\n this.rowSize = (width + 31) / 32;\n bits = new int[rowSize * height];\n }\n\n private BitMatrix(int width, int height, int rowSize, int[] bits) {\n this.width = width;\n this.height = height;\n this.rowSize = rowSize;\n this.bits = bits;\n }\n\n /**\n * Interprets a 2D array of booleans as a {@code BitMatrix}, where \"true\" means an \"on\" bit.\n *\n * @param image bits of the image, as a row-major 2D array. Elements are arrays representing rows\n * @return {@code BitMatrix} representation of image\n */\n public static BitMatrix parse(boolean[][] image) {\n int height = image.length;\n int width = image[0].length;\n BitMatrix bits = new BitMatrix(width, height);\n for (int i = 0; i < height; i++) {\n boolean[] imageI = image[i];\n for (int j = 0; j < width; j++) {\n if (imageI[j]) {\n bits.set(j, i);\n }\n }\n }\n return bits;\n }\n\n public static BitMatrix parse(String stringRepresentation, String setString, String unsetString) {\n if (stringRepresentation == null) {\n throw new IllegalArgumentException();\n }\n\n boolean[] bits = new boolean[stringRepresentation.length()];\n int bitsPos = 0;\n int rowStartPos = 0;\n int rowLength = -1;\n int nRows = 0;\n int pos = 0;\n while (pos < stringRepresentation.length()) {\n if (stringRepresentation.charAt(pos) == '\\n' ||\n stringRepresentation.charAt(pos) == '\\r') {\n if (bitsPos > rowStartPos) {\n if (rowLength == -1) {\n rowLength = bitsPos - rowStartPos;\n } else if (bitsPos - rowStartPos != rowLength) {\n throw new IllegalArgumentException(\"row lengths do not match\");\n }\n rowStartPos = bitsPos;\n nRows++;\n }\n pos++;\n } else if (stringRepresentation.substring(pos, pos + setString.length()).equals(setString)) {\n pos += setString.length();\n bits[bitsPos] = true;\n bitsPos++;\n } else if (stringRepresentation.substring(pos, pos + unsetString.length()).equals(unsetString)) {\n pos += unsetString.length();\n bits[bitsPos] = false;\n bitsPos++;\n } else {\n throw new IllegalArgumentException(\n \"illegal character encountered: \" + stringRepresentation.substring(pos));\n }\n }\n\n // no EOL at end?\n if (bitsPos > rowStartPos) {\n if (rowLength == -1) {\n rowLength = bitsPos - rowStartPos;\n } else if (bitsPos - rowStartPos != rowLength) {\n throw new IllegalArgumentException(\"row lengths do not match\");\n }\n nRows++;\n }\n\n BitMatrix matrix = new BitMatrix(rowLength, nRows);\n for (int i = 0; i < bitsPos; i++) {\n if (bits[i]) {\n matrix.set(i % rowLength, i / rowLength);\n }\n }\n return matrix;\n }\n\n /**\n *Gets the requested bit, where true means black.
\n *\n * @param x The horizontal component (i.e. which column)\n * @param y The vertical component (i.e. which row)\n * @return value of given bit in matrix\n */\n public boolean get(int x, int y) {\n int offset = y * rowSize + (x / 32);\n return ((bits[offset] >>> (x & 0x1f)) & 1) != 0;\n }\n\n /**\n *Sets the given bit to true.
\n *\n * @param x The horizontal component (i.e. which column)\n * @param y The vertical component (i.e. which row)\n */\n public void set(int x, int y) {\n int offset = y * rowSize + (x / 32);\n bits[offset] |= 1 << (x & 0x1f);\n }\n\n public void unset(int x, int y) {\n int offset = y * rowSize + (x / 32);\n bits[offset] &= ~(1 << (x & 0x1f));\n }\n\n /**\n *Flips the given bit.
\n *\n * @param x The horizontal component (i.e. which column)\n * @param y The vertical component (i.e. which row)\n */\n public void flip(int x, int y) {\n int offset = y * rowSize + (x / 32);\n bits[offset] ^= 1 << (x & 0x1f);\n }\n\n /**\n * Exclusive-or (XOR): Flip the bit in this {@code BitMatrix} if the corresponding\n * mask bit is set.\n *\n * @param mask XOR mask\n */\n public void xor(BitMatrix mask) {\n if (width != mask.getWidth() || height != mask.getHeight()\n || rowSize != mask.getRowSize()) {\n throw new IllegalArgumentException(\"input matrix dimensions do not match\");\n }\n BitArray rowArray = new BitArray(width);\n for (int y = 0; y < height; y++) {\n int offset = y * rowSize;\n int[] row = mask.getRow(y, rowArray).getBitArray();\n for (int x = 0; x < rowSize; x++) {\n bits[offset + x] ^= row[x];\n }\n }\n }\n\n /**\n * Clears all bits (sets to false).\n */\n public void clear() {\n int max = bits.length;\n for (int i = 0; i < max; i++) {\n bits[i] = 0;\n }\n }\n\n /**\n *Sets a square region of the bit matrix to true.
\n *\n * @param left The horizontal position to begin at (inclusive)\n * @param top The vertical position to begin at (inclusive)\n * @param width The width of the region\n * @param height The height of the region\n */\n public void setRegion(int left, int top, int width, int height) {\n if (top < 0 || left < 0) {\n throw new IllegalArgumentException(\"Left and top must be nonnegative\");\n }\n if (height < 1 || width < 1) {\n throw new IllegalArgumentException(\"Height and width must be at least 1\");\n }\n int right = left + width;\n int bottom = top + height;\n if (bottom > this.height || right > this.width) {\n throw new IllegalArgumentException(\"The region must fit inside the matrix\");\n }\n for (int y = top; y < bottom; y++) {\n int offset = y * rowSize;\n for (int x = left; x < right; x++) {\n bits[offset + (x / 32)] |= 1 << (x & 0x1f);\n }\n }\n }\n\n /**\n * A fast method to retrieve one row of data from the matrix as a BitArray.\n *\n * @param y The row to retrieve\n * @param row An optional caller-allocated BitArray, will be allocated if null or too small\n * @return The resulting BitArray - this reference should always be used even when passing\n * your own row\n */\n public BitArray getRow(int y, BitArray row) {\n if (row == null || row.getSize() < width) {\n row = new BitArray(width);\n } else {\n row.clear();\n }\n int offset = y * rowSize;\n for (int x = 0; x < rowSize; x++) {\n row.setBulk(x * 32, bits[offset + x]);\n }\n return row;\n }\n\n /**\n * @param y row to set\n * @param row {@link BitArray} to copy from\n */\n public void setRow(int y, BitArray row) {\n System.arraycopy(row.getBitArray(), 0, bits, y * rowSize, rowSize);\n }\n\n /**\n * Modifies this {@code BitMatrix} to represent the same but rotated 180 degrees\n */\n public void rotate180() {\n int width = getWidth();\n int height = getHeight();\n BitArray topRow = new BitArray(width);\n BitArray bottomRow = new BitArray(width);\n for (int i = 0; i < (height + 1) / 2; i++) {\n topRow = getRow(i, topRow);\n bottomRow = getRow(height - 1 - i, bottomRow);\n topRow.reverse();\n bottomRow.reverse();\n setRow(i, bottomRow);\n setRow(height - 1 - i, topRow);\n }\n }\n\n /**\n * This is useful in detecting the enclosing rectangle of a 'pure' barcode.\n *\n * @return {@code left,top,width,height} enclosing rectangle of all 1 bits, or null if it is all white\n */\n public int[] getEnclosingRectangle() {\n int left = width;\n int top = height;\n int right = -1;\n int bottom = -1;\n\n for (int y = 0; y < height; y++) {\n for (int x32 = 0; x32 < rowSize; x32++) {\n int theBits = bits[y * rowSize + x32];\n if (theBits != 0) {\n if (y < top) {\n top = y;\n }\n if (y > bottom) {\n bottom = y;\n }\n if (x32 * 32 < left) {\n int bit = 0;\n while ((theBits << (31 - bit)) == 0) {\n bit++;\n }\n if ((x32 * 32 + bit) < left) {\n left = x32 * 32 + bit;\n }\n }\n if (x32 * 32 + 31 > right) {\n int bit = 31;\n while ((theBits >>> bit) == 0) {\n bit--;\n }\n if ((x32 * 32 + bit) > right) {\n right = x32 * 32 + bit;\n }\n }\n }\n }\n }\n\n if (right < left || bottom < top) {\n return null;\n }\n\n return new int[] {left, top, right - left + 1, bottom - top + 1};\n }\n\n /**\n * This is useful in detecting a corner of a 'pure' barcode.\n *\n * @return {@code x,y} coordinate of top-left-most 1 bit, or null if it is all white\n */\n public int[] getTopLeftOnBit() {\n int bitsOffset = 0;\n while (bitsOffset < bits.length && bits[bitsOffset] == 0) {\n bitsOffset++;\n }\n if (bitsOffset == bits.length) {\n return null;\n }\n int y = bitsOffset / rowSize;\n int x = (bitsOffset % rowSize) * 32;\n\n int theBits = bits[bitsOffset];\n int bit = 0;\n while ((theBits << (31 - bit)) == 0) {\n bit++;\n }\n x += bit;\n return new int[] {x, y};\n }\n\n public int[] getBottomRightOnBit() {\n int bitsOffset = bits.length - 1;\n while (bitsOffset >= 0 && bits[bitsOffset] == 0) {\n bitsOffset--;\n }\n if (bitsOffset < 0) {\n return null;\n }\n\n int y = bitsOffset / rowSize;\n int x = (bitsOffset % rowSize) * 32;\n\n int theBits = bits[bitsOffset];\n int bit = 31;\n while ((theBits >>> bit) == 0) {\n bit--;\n }\n x += bit;\n\n return new int[] {x, y};\n }\n\n /**\n * @return The width of the matrix\n */\n public int getWidth() {\n return width;\n }\n\n /**\n * @return The height of the matrix\n */\n public int getHeight() {\n return height;\n }\n\n /**\n * @return The row size of the matrix\n */\n public int getRowSize() {\n return rowSize;\n }\n\n @Override\n public boolean equals(Object o) {\n if (!(o instanceof BitMatrix)) {\n return false;\n }\n BitMatrix other = (BitMatrix) o;\n return width == other.width && height == other.height && rowSize == other.rowSize &&\n Arrays.equals(bits, other.bits);\n }\n\n @Override\n public int hashCode() {\n int hash = width;\n hash = 31 * hash + width;\n hash = 31 * hash + height;\n hash = 31 * hash + rowSize;\n hash = 31 * hash + Arrays.hashCode(bits);\n return hash;\n }\n\n /**\n * @return string representation using \"X\" for set and \" \" for unset bits\n */\n @Override\n public String toString() {\n return toString(\"X \", \" \");\n }\n\n /**\n * @param setString representation of a set bit\n * @param unsetString representation of an unset bit\n * @return string representation of entire matrix utilizing given strings\n */\n public String toString(String setString, String unsetString) {\n return buildToString(setString, unsetString, \"\\n\");\n }\n\n /**\n * @param setString representation of a set bit\n * @param unsetString representation of an unset bit\n * @param lineSeparator newline character in string representation\n * @return string representation of entire matrix utilizing given strings and line separator\n * @deprecated call {@link #toString(String,String)} only, which uses \\n line separator always\n */\n @Deprecated\n public String toString(String setString, String unsetString, String lineSeparator) {\n return buildToString(setString, unsetString, lineSeparator);\n }\n\n private String buildToString(String setString, String unsetString, String lineSeparator) {\n StringBuilder result = new StringBuilder(height * (width + 1));\n for (int y = 0; y < height; y++) {\n for (int x = 0; x < width; x++) {\n result.append(get(x, y) ? setString : unsetString);\n }\n result.append(lineSeparator);\n }\n return result.toString();\n }\n\n @Override\n public BitMatrix clone() {\n return new BitMatrix(width, height, rowSize, bits.clone());\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/common/BitSource.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common;\n\n/**\n *This provides an easy abstraction to read bits at a time from a sequence of bytes, where the\n * number of bits read is not often a multiple of 8.
\n *\n *This class is thread-safe but not reentrant -- unless the caller modifies the bytes array\n * it passed in, in which case all bets are off.
\n *\n * @author Sean Owen\n */\npublic final class BitSource {\n\n private final byte[] bytes;\n private int byteOffset;\n private int bitOffset;\n\n /**\n * @param bytes bytes from which this will read bits. Bits will be read from the first byte first.\n * Bits are read within a byte from most-significant to least-significant bit.\n */\n public BitSource(byte[] bytes) {\n this.bytes = bytes;\n }\n\n /**\n * @return index of next bit in current byte which would be read by the next call to {@link #readBits(int)}.\n */\n public int getBitOffset() {\n return bitOffset;\n }\n\n /**\n * @return index of next byte in input byte array which would be read by the next call to {@link #readBits(int)}.\n */\n public int getByteOffset() {\n return byteOffset;\n }\n\n /**\n * @param numBits number of bits to read\n * @return int representing the bits read. The bits will appear as the least-significant\n * bits of the int\n * @throws IllegalArgumentException if numBits isn't in [1,32] or more than is available\n */\n public int readBits(int numBits) {\n if (numBits < 1 || numBits > 32 || numBits > available()) {\n throw new IllegalArgumentException(String.valueOf(numBits));\n }\n\n int result = 0;\n\n // First, read remainder from current byte\n if (bitOffset > 0) {\n int bitsLeft = 8 - bitOffset;\n int toRead = numBits < bitsLeft ? numBits : bitsLeft;\n int bitsToNotRead = bitsLeft - toRead;\n int mask = (0xFF >> (8 - toRead)) << bitsToNotRead;\n result = (bytes[byteOffset] & mask) >> bitsToNotRead;\n numBits -= toRead;\n bitOffset += toRead;\n if (bitOffset == 8) {\n bitOffset = 0;\n byteOffset++;\n }\n }\n\n // Next read whole bytes\n if (numBits > 0) {\n while (numBits >= 8) {\n result = (result << 8) | (bytes[byteOffset] & 0xFF);\n byteOffset++;\n numBits -= 8;\n }\n\n // Finally read a partial byte\n if (numBits > 0) {\n int bitsToNotRead = 8 - numBits;\n int mask = (0xFF >> bitsToNotRead) << bitsToNotRead;\n result = (result << numBits) | ((bytes[byteOffset] & mask) >> bitsToNotRead);\n bitOffset += numBits;\n }\n }\n\n return result;\n }\n\n /**\n * @return number of bits that can be read successfully\n */\n public int available() {\n return 8 * (bytes.length - byteOffset) - bitOffset;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/common/CharacterSetECI.java", "content": "/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common;\n\nimport com.google.zxing.FormatException;\n\nimport java.util.HashMap;\nimport java.util.Map;\n\n/**\n * Encapsulates a Character Set ECI, according to \"Extended Channel Interpretations\" 5.3.1.1\n * of ISO 18004.\n *\n * @author Sean Owen\n */\npublic enum CharacterSetECI {\n\n // Enum name is a Java encoding valid for java.lang and java.io\n Cp437(new int[]{0,2}),\n ISO8859_1(new int[]{1,3}, \"ISO-8859-1\"),\n ISO8859_2(4, \"ISO-8859-2\"),\n ISO8859_3(5, \"ISO-8859-3\"),\n ISO8859_4(6, \"ISO-8859-4\"),\n ISO8859_5(7, \"ISO-8859-5\"),\n ISO8859_6(8, \"ISO-8859-6\"),\n ISO8859_7(9, \"ISO-8859-7\"),\n ISO8859_8(10, \"ISO-8859-8\"),\n ISO8859_9(11, \"ISO-8859-9\"),\n ISO8859_10(12, \"ISO-8859-10\"),\n ISO8859_11(13, \"ISO-8859-11\"),\n ISO8859_13(15, \"ISO-8859-13\"),\n ISO8859_14(16, \"ISO-8859-14\"),\n ISO8859_15(17, \"ISO-8859-15\"),\n ISO8859_16(18, \"ISO-8859-16\"),\n SJIS(20, \"Shift_JIS\"),\n Cp1250(21, \"windows-1250\"),\n Cp1251(22, \"windows-1251\"),\n Cp1252(23, \"windows-1252\"),\n Cp1256(24, \"windows-1256\"),\n UnicodeBigUnmarked(25, \"UTF-16BE\", \"UnicodeBig\"),\n UTF8(26, \"UTF-8\"),\n ASCII(new int[] {27, 170}, \"US-ASCII\"),\n Big5(28),\n GB18030(29, \"GB2312\", \"EUC_CN\", \"GBK\"),\n EUC_KR(30, \"EUC-KR\");\n\n private static final MapEncapsulates the result of decoding a matrix of bits. This typically\n * applies to 2D barcode formats. For now it contains the raw bytes obtained,\n * as well as a String interpretation of those bytes, if applicable.
\n *\n * @author Sean Owen\n */\npublic final class DecoderResult {\n\n private final byte[] rawBytes;\n private int numBits;\n private final String text;\n private final ListEncapsulates the result of detecting a barcode in an image. This includes the raw\n * matrix of black/white pixels corresponding to the barcode, and possibly points of interest\n * in the image, like the location of finder patterns or corners of the barcode in the image.
\n *\n * @author Sean Owen\n */\npublic class DetectorResult {\n\n private final BitMatrix bits;\n private final ResultPoint[] points;\n\n public DetectorResult(BitMatrix bits, ResultPoint[] points) {\n this.bits = bits;\n this.points = points;\n }\n\n public final BitMatrix getBits() {\n return bits;\n }\n\n public final ResultPoint[] getPoints() {\n return points;\n }\n\n}" }, { "path": "scanner/src/main/java/com/google/zxing/common/GlobalHistogramBinarizer.java", "content": "/*\n * Copyright 2009 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common;\n\nimport com.google.zxing.Binarizer;\nimport com.google.zxing.LuminanceSource;\nimport com.google.zxing.NotFoundException;\n\n/**\n * This Binarizer implementation uses the old ZXing global histogram approach. It is suitable\n * for low-end mobile devices which don't have enough CPU or memory to use a local thresholding\n * algorithm. However, because it picks a global black point, it cannot handle difficult shadows\n * and gradients.\n *\n * Faster mobile devices and all desktop applications should probably use HybridBinarizer instead.\n *\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Sean Owen\n */\npublic class GlobalHistogramBinarizer extends Binarizer {\n\n private static final int LUMINANCE_BITS = 5;\n private static final int LUMINANCE_SHIFT = 8 - LUMINANCE_BITS;\n private static final int LUMINANCE_BUCKETS = 1 << LUMINANCE_BITS;\n private static final byte[] EMPTY = new byte[0];\n\n private byte[] luminances;\n private final int[] buckets;\n\n public GlobalHistogramBinarizer(LuminanceSource source) {\n super(source);\n luminances = EMPTY;\n buckets = new int[LUMINANCE_BUCKETS];\n }\n\n // Applies simple sharpening to the row data to improve performance of the 1D Readers.\n @Override\n public BitArray getBlackRow(int y, BitArray row) throws NotFoundException {\n LuminanceSource source = getLuminanceSource();\n int width = source.getWidth();\n if (row == null || row.getSize() < width) {\n row = new BitArray(width);\n } else {\n row.clear();\n }\n\n initArrays(width);\n byte[] localLuminances = source.getRow(y, luminances);\n int[] localBuckets = buckets;\n for (int x = 0; x < width; x++) {\n localBuckets[(localLuminances[x] & 0xff) >> LUMINANCE_SHIFT]++;\n }\n int blackPoint = estimateBlackPoint(localBuckets);\n\n if (width < 3) {\n // Special case for very small images\n for (int x = 0; x < width; x++) {\n if ((localLuminances[x] & 0xff) < blackPoint) {\n row.set(x);\n }\n }\n } else {\n int left = localLuminances[0] & 0xff;\n int center = localLuminances[1] & 0xff;\n for (int x = 1; x < width - 1; x++) {\n int right = localLuminances[x + 1] & 0xff;\n // A simple -1 4 -1 box filter with a weight of 2.\n if (((center * 4) - left - right) / 2 < blackPoint) {\n row.set(x);\n }\n left = center;\n center = right;\n }\n }\n return row;\n }\n\n // Does not sharpen the data, as this call is intended to only be used by 2D Readers.\n @Override\n public BitMatrix getBlackMatrix() throws NotFoundException {\n LuminanceSource source = getLuminanceSource();\n int width = source.getWidth();\n int height = source.getHeight();\n BitMatrix matrix = new BitMatrix(width, height);\n\n // Quickly calculates the histogram by sampling four rows from the image. This proved to be\n // more robust on the blackbox tests than sampling a diagonal as we used to do.\n initArrays(width);\n int[] localBuckets = buckets;\n for (int y = 1; y < 5; y++) {\n int row = height * y / 5;\n byte[] localLuminances = source.getRow(row, luminances);\n int right = (width * 4) / 5;\n for (int x = width / 5; x < right; x++) {\n int pixel = localLuminances[x] & 0xff;\n localBuckets[pixel >> LUMINANCE_SHIFT]++;\n }\n }\n int blackPoint = estimateBlackPoint(localBuckets);\n\n // We delay reading the entire image luminance until the black point estimation succeeds.\n // Although we end up reading four rows twice, it is consistent with our motto of\n // \"fail quickly\" which is necessary for continuous scanning.\n byte[] localLuminances = source.getMatrix();\n for (int y = 0; y < height; y++) {\n int offset = y * width;\n for (int x = 0; x < width; x++) {\n int pixel = localLuminances[offset + x] & 0xff;\n if (pixel < blackPoint) {\n matrix.set(x, y);\n }\n }\n }\n\n return matrix;\n }\n\n @Override\n public Binarizer createBinarizer(LuminanceSource source) {\n return new GlobalHistogramBinarizer(source);\n }\n\n private void initArrays(int luminanceSize) {\n if (luminances.length < luminanceSize) {\n luminances = new byte[luminanceSize];\n }\n for (int x = 0; x < LUMINANCE_BUCKETS; x++) {\n buckets[x] = 0;\n }\n }\n\n private static int estimateBlackPoint(int[] buckets) throws NotFoundException {\n // Find the tallest peak in the histogram.\n int numBuckets = buckets.length;\n int maxBucketCount = 0;\n int firstPeak = 0;\n int firstPeakSize = 0;\n for (int x = 0; x < numBuckets; x++) {\n if (buckets[x] > firstPeakSize) {\n firstPeak = x;\n firstPeakSize = buckets[x];\n }\n if (buckets[x] > maxBucketCount) {\n maxBucketCount = buckets[x];\n }\n }\n\n // Find the second-tallest peak which is somewhat far from the tallest peak.\n int secondPeak = 0;\n int secondPeakScore = 0;\n for (int x = 0; x < numBuckets; x++) {\n int distanceToBiggest = x - firstPeak;\n // Encourage more distant second peaks by multiplying by square of distance.\n int score = buckets[x] * distanceToBiggest * distanceToBiggest;\n if (score > secondPeakScore) {\n secondPeak = x;\n secondPeakScore = score;\n }\n }\n\n // Make sure firstPeak corresponds to the black peak.\n if (firstPeak > secondPeak) {\n int temp = firstPeak;\n firstPeak = secondPeak;\n secondPeak = temp;\n }\n\n // If there is too little contrast in the image to pick a meaningful black point, throw rather\n // than waste time trying to decode the image, and risk false positives.\n if (secondPeak - firstPeak <= numBuckets / 16) {\n throw NotFoundException.getNotFoundInstance();\n }\n\n // Find a valley between them that is low and closer to the white peak.\n int bestValley = secondPeak - 1;\n int bestValleyScore = -1;\n for (int x = secondPeak - 1; x > firstPeak; x--) {\n int fromFirst = x - firstPeak;\n int score = fromFirst * fromFirst * (secondPeak - x) * (maxBucketCount - buckets[x]);\n if (score > bestValleyScore) {\n bestValley = x;\n bestValleyScore = score;\n }\n }\n\n return bestValley << LUMINANCE_SHIFT;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/common/GridSampler.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common;\n\nimport com.google.zxing.NotFoundException;\n\n/**\n * Implementations of this class can, given locations of finder patterns for a QR code in an\n * image, sample the right points in the image to reconstruct the QR code, accounting for\n * perspective distortion. It is abstracted since it is relatively expensive and should be allowed\n * to take advantage of platform-specific optimized implementations, like Sun's Java Advanced\n * Imaging library, but which may not be available in other environments such as J2ME, and vice\n * versa.\n *\n * The implementation used can be controlled by calling {@link #setGridSampler(GridSampler)}\n * with an instance of a class which implements this interface.\n *\n * @author Sean Owen\n */\npublic abstract class GridSampler {\n\n private static GridSampler gridSampler = new DefaultGridSampler();\n\n /**\n * Sets the implementation of GridSampler used by the library. One global\n * instance is stored, which may sound problematic. But, the implementation provided\n * ought to be appropriate for the entire platform, and all uses of this library\n * in the whole lifetime of the JVM. For instance, an Android activity can swap in\n * an implementation that takes advantage of native platform libraries.\n *\n * @param newGridSampler The platform-specific object to install.\n */\n public static void setGridSampler(GridSampler newGridSampler) {\n gridSampler = newGridSampler;\n }\n\n /**\n * @return the current implementation of GridSampler\n */\n public static GridSampler getInstance() {\n return gridSampler;\n }\n\n /**\n * Samples an image for a rectangular matrix of bits of the given dimension. The sampling\n * transformation is determined by the coordinates of 4 points, in the original and transformed\n * image space.\n *\n * @param image image to sample\n * @param dimensionX width of {@link BitMatrix} to sample from image\n * @param dimensionY height of {@link BitMatrix} to sample from image\n * @param p1ToX point 1 preimage X\n * @param p1ToY point 1 preimage Y\n * @param p2ToX point 2 preimage X\n * @param p2ToY point 2 preimage Y\n * @param p3ToX point 3 preimage X\n * @param p3ToY point 3 preimage Y\n * @param p4ToX point 4 preimage X\n * @param p4ToY point 4 preimage Y\n * @param p1FromX point 1 image X\n * @param p1FromY point 1 image Y\n * @param p2FromX point 2 image X\n * @param p2FromY point 2 image Y\n * @param p3FromX point 3 image X\n * @param p3FromY point 3 image Y\n * @param p4FromX point 4 image X\n * @param p4FromY point 4 image Y\n * @return {@link BitMatrix} representing a grid of points sampled from the image within a region\n * defined by the \"from\" parameters\n * @throws NotFoundException if image can't be sampled, for example, if the transformation defined\n * by the given points is invalid or results in sampling outside the image boundaries\n */\n public abstract BitMatrix sampleGrid(BitMatrix image,\n int dimensionX,\n int dimensionY,\n float p1ToX, float p1ToY,\n float p2ToX, float p2ToY,\n float p3ToX, float p3ToY,\n float p4ToX, float p4ToY,\n float p1FromX, float p1FromY,\n float p2FromX, float p2FromY,\n float p3FromX, float p3FromY,\n float p4FromX, float p4FromY) throws NotFoundException;\n\n public abstract BitMatrix sampleGrid(BitMatrix image,\n int dimensionX,\n int dimensionY,\n PerspectiveTransform transform) throws NotFoundException;\n\n /**\n *Checks a set of points that have been transformed to sample points on an image against\n * the image's dimensions to see if the point are even within the image.
\n *\n *This method will actually \"nudge\" the endpoints back onto the image if they are found to be\n * barely (less than 1 pixel) off the image. This accounts for imperfect detection of finder\n * patterns in an image where the QR Code runs all the way to the image border.
\n *\n *For efficiency, the method will check points from either end of the line until one is found\n * to be within the image. Because the set of points are assumed to be linear, this is valid.
\n *\n * @param image image into which the points should map\n * @param points actual points in x1,y1,...,xn,yn form\n * @throws NotFoundException if an endpoint is lies outside the image boundaries\n */\n protected static void checkAndNudgePoints(BitMatrix image,\n float[] points) throws NotFoundException {\n int width = image.getWidth();\n int height = image.getHeight();\n // Check and nudge points from start until we see some that are OK:\n boolean nudged = true;\n int maxOffset = points.length - 1; // points.length must be even\n for (int offset = 0; offset < maxOffset && nudged; offset += 2) {\n int x = (int) points[offset];\n int y = (int) points[offset + 1];\n if (x < -1 || x > width || y < -1 || y > height) {\n throw NotFoundException.getNotFoundInstance();\n }\n nudged = false;\n if (x == -1) {\n points[offset] = 0.0f;\n nudged = true;\n } else if (x == width) {\n points[offset] = width - 1;\n nudged = true;\n }\n if (y == -1) {\n points[offset + 1] = 0.0f;\n nudged = true;\n } else if (y == height) {\n points[offset + 1] = height - 1;\n nudged = true;\n }\n }\n // Check and nudge points from end:\n nudged = true;\n for (int offset = points.length - 2; offset >= 0 && nudged; offset -= 2) {\n int x = (int) points[offset];\n int y = (int) points[offset + 1];\n if (x < -1 || x > width || y < -1 || y > height) {\n throw NotFoundException.getNotFoundInstance();\n }\n nudged = false;\n if (x == -1) {\n points[offset] = 0.0f;\n nudged = true;\n } else if (x == width) {\n points[offset] = width - 1;\n nudged = true;\n }\n if (y == -1) {\n points[offset + 1] = 0.0f;\n nudged = true;\n } else if (y == height) {\n points[offset + 1] = height - 1;\n nudged = true;\n }\n }\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/common/HybridBinarizer.java", "content": "/*\n * Copyright 2009 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common;\n\nimport com.google.zxing.Binarizer;\nimport com.google.zxing.LuminanceSource;\nimport com.google.zxing.NotFoundException;\n\n/**\n * This class implements a local thresholding algorithm, which while slower than the\n * GlobalHistogramBinarizer, is fairly efficient for what it does. It is designed for\n * high frequency images of barcodes with black data on white backgrounds. For this application,\n * it does a much better job than a global blackpoint with severe shadows and gradients.\n * However it tends to produce artifacts on lower frequency images and is therefore not\n * a good general purpose binarizer for uses outside ZXing.\n *\n * This class extends GlobalHistogramBinarizer, using the older histogram approach for 1D readers,\n * and the newer local approach for 2D readers. 1D decoding using a per-row histogram is already\n * inherently local, and only fails for horizontal gradients. We can revisit that problem later,\n * but for now it was not a win to use local blocks for 1D.\n *\n * This Binarizer is the default for the unit tests and the recommended class for library users.\n *\n * @author dswitkin@google.com (Daniel Switkin)\n */\npublic final class HybridBinarizer extends GlobalHistogramBinarizer {\n\n // This class uses 5x5 blocks to compute local luminance, where each block is 8x8 pixels.\n // So this is the smallest dimension in each axis we can accept.\n private static final int BLOCK_SIZE_POWER = 3;\n private static final int BLOCK_SIZE = 1 << BLOCK_SIZE_POWER; // ...0100...00\n private static final int BLOCK_SIZE_MASK = BLOCK_SIZE - 1; // ...0011...11\n private static final int MINIMUM_DIMENSION = BLOCK_SIZE * 5;\n private static final int MIN_DYNAMIC_RANGE = 24;\n\n private BitMatrix matrix;\n\n public HybridBinarizer(LuminanceSource source) {\n super(source);\n }\n\n /**\n * Calculates the final BitMatrix once for all requests. This could be called once from the\n * constructor instead, but there are some advantages to doing it lazily, such as making\n * profiling easier, and not doing heavy lifting when callers don't expect it.\n */\n @Override\n public BitMatrix getBlackMatrix() throws NotFoundException {\n if (matrix != null) {\n return matrix;\n }\n LuminanceSource source = getLuminanceSource();\n int width = source.getWidth();\n int height = source.getHeight();\n if (width >= MINIMUM_DIMENSION && height >= MINIMUM_DIMENSION) {\n byte[] luminances = source.getMatrix();\n int subWidth = width >> BLOCK_SIZE_POWER;\n if ((width & BLOCK_SIZE_MASK) != 0) {\n subWidth++;\n }\n int subHeight = height >> BLOCK_SIZE_POWER;\n if ((height & BLOCK_SIZE_MASK) != 0) {\n subHeight++;\n }\n int[][] blackPoints = calculateBlackPoints(luminances, subWidth, subHeight, width, height);\n\n BitMatrix newMatrix = new BitMatrix(width, height);\n calculateThresholdForBlock(luminances, subWidth, subHeight, width, height, blackPoints, newMatrix);\n matrix = newMatrix;\n } else {\n // If the image is too small, fall back to the global histogram approach.\n matrix = super.getBlackMatrix();\n }\n return matrix;\n }\n\n @Override\n public Binarizer createBinarizer(LuminanceSource source) {\n return new HybridBinarizer(source);\n }\n\n /**\n * For each block in the image, calculate the average black point using a 5x5 grid\n * of the blocks around it. Also handles the corner cases (fractional blocks are computed based\n * on the last pixels in the row/column which are also used in the previous block).\n */\n private static void calculateThresholdForBlock(byte[] luminances,\n int subWidth,\n int subHeight,\n int width,\n int height,\n int[][] blackPoints,\n BitMatrix matrix) {\n int maxYOffset = height - BLOCK_SIZE;\n int maxXOffset = width - BLOCK_SIZE;\n for (int y = 0; y < subHeight; y++) {\n int yoffset = y << BLOCK_SIZE_POWER;\n if (yoffset > maxYOffset) {\n yoffset = maxYOffset;\n }\n int top = cap(y, 2, subHeight - 3);\n for (int x = 0; x < subWidth; x++) {\n int xoffset = x << BLOCK_SIZE_POWER;\n if (xoffset > maxXOffset) {\n xoffset = maxXOffset;\n }\n int left = cap(x, 2, subWidth - 3);\n int sum = 0;\n for (int z = -2; z <= 2; z++) {\n int[] blackRow = blackPoints[top + z];\n sum += blackRow[left - 2] + blackRow[left - 1] + blackRow[left] + blackRow[left + 1] + blackRow[left + 2];\n }\n int average = sum / 25;\n thresholdBlock(luminances, xoffset, yoffset, average, width, matrix);\n }\n }\n }\n\n private static int cap(int value, int min, int max) {\n return value < min ? min : value > max ? max : value;\n }\n\n /**\n * Applies a single threshold to a block of pixels.\n */\n private static void thresholdBlock(byte[] luminances,\n int xoffset,\n int yoffset,\n int threshold,\n int stride,\n BitMatrix matrix) {\n for (int y = 0, offset = yoffset * stride + xoffset; y < BLOCK_SIZE; y++, offset += stride) {\n for (int x = 0; x < BLOCK_SIZE; x++) {\n // Comparison needs to be <= so that black == 0 pixels are black even if the threshold is 0.\n if ((luminances[offset + x] & 0xFF) <= threshold) {\n matrix.set(xoffset + x, yoffset + y);\n }\n }\n }\n }\n\n /**\n * Calculates a single black point for each block of pixels and saves it away.\n * See the following thread for a discussion of this algorithm:\n * http://groups.google.com/group/zxing/browse_thread/thread/d06efa2c35a7ddc0\n */\n private static int[][] calculateBlackPoints(byte[] luminances,\n int subWidth,\n int subHeight,\n int width,\n int height) {\n int maxYOffset = height - BLOCK_SIZE;\n int maxXOffset = width - BLOCK_SIZE;\n int[][] blackPoints = new int[subHeight][subWidth];\n for (int y = 0; y < subHeight; y++) {\n int yoffset = y << BLOCK_SIZE_POWER;\n if (yoffset > maxYOffset) {\n yoffset = maxYOffset;\n }\n for (int x = 0; x < subWidth; x++) {\n int xoffset = x << BLOCK_SIZE_POWER;\n if (xoffset > maxXOffset) {\n xoffset = maxXOffset;\n }\n int sum = 0;\n int min = 0xFF;\n int max = 0;\n for (int yy = 0, offset = yoffset * width + xoffset; yy < BLOCK_SIZE; yy++, offset += width) {\n for (int xx = 0; xx < BLOCK_SIZE; xx++) {\n int pixel = luminances[offset + xx] & 0xFF;\n sum += pixel;\n // still looking for good contrast\n if (pixel < min) {\n min = pixel;\n }\n if (pixel > max) {\n max = pixel;\n }\n }\n // short-circuit min/max tests once dynamic range is met\n if (max - min > MIN_DYNAMIC_RANGE) {\n // finish the rest of the rows quickly\n for (yy++, offset += width; yy < BLOCK_SIZE; yy++, offset += width) {\n for (int xx = 0; xx < BLOCK_SIZE; xx++) {\n sum += luminances[offset + xx] & 0xFF;\n }\n }\n }\n }\n\n // The default estimate is the average of the values in the block.\n int average = sum >> (BLOCK_SIZE_POWER * 2);\n if (max - min <= MIN_DYNAMIC_RANGE) {\n // If variation within the block is low, assume this is a block with only light or only\n // dark pixels. In that case we do not want to use the average, as it would divide this\n // low contrast area into black and white pixels, essentially creating data out of noise.\n //\n // The default assumption is that the block is light/background. Since no estimate for\n // the level of dark pixels exists locally, use half the min for the block.\n average = min / 2;\n\n if (y > 0 && x > 0) {\n // Correct the \"white background\" assumption for blocks that have neighbors by comparing\n // the pixels in this block to the previously calculated black points. This is based on\n // the fact that dark barcode symbology is always surrounded by some amount of light\n // background for which reasonable black point estimates were made. The bp estimated at\n // the boundaries is used for the interior.\n\n // The (min < bp) is arbitrary but works better than other heuristics that were tried.\n int averageNeighborBlackPoint =\n (blackPoints[y - 1][x] + (2 * blackPoints[y][x - 1]) + blackPoints[y - 1][x - 1]) / 4;\n if (min < averageNeighborBlackPoint) {\n average = averageNeighborBlackPoint;\n }\n }\n }\n blackPoints[y][x] = average;\n }\n }\n return blackPoints;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/common/PerspectiveTransform.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common;\n\n/**\n *This class implements a perspective transform in two dimensions. Given four source and four\n * destination points, it will compute the transformation implied between them. The code is based\n * directly upon section 3.4.2 of George Wolberg's \"Digital Image Warping\"; see pages 54-56.
\n *\n * @author Sean Owen\n */\npublic final class PerspectiveTransform {\n\n private final float a11;\n private final float a12;\n private final float a13;\n private final float a21;\n private final float a22;\n private final float a23;\n private final float a31;\n private final float a32;\n private final float a33;\n\n private PerspectiveTransform(float a11, float a21, float a31,\n float a12, float a22, float a32,\n float a13, float a23, float a33) {\n this.a11 = a11;\n this.a12 = a12;\n this.a13 = a13;\n this.a21 = a21;\n this.a22 = a22;\n this.a23 = a23;\n this.a31 = a31;\n this.a32 = a32;\n this.a33 = a33;\n }\n\n public static PerspectiveTransform quadrilateralToQuadrilateral(float x0, float y0,\n float x1, float y1,\n float x2, float y2,\n float x3, float y3,\n float x0p, float y0p,\n float x1p, float y1p,\n float x2p, float y2p,\n float x3p, float y3p) {\n\n PerspectiveTransform qToS = quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3);\n PerspectiveTransform sToQ = squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p);\n return sToQ.times(qToS);\n }\n\n public void transformPoints(float[] points) {\n float a11 = this.a11;\n float a12 = this.a12;\n float a13 = this.a13;\n float a21 = this.a21;\n float a22 = this.a22;\n float a23 = this.a23;\n float a31 = this.a31;\n float a32 = this.a32;\n float a33 = this.a33;\n int maxI = points.length - 1; // points.length must be even\n for (int i = 0; i < maxI; i += 2) {\n float x = points[i];\n float y = points[i + 1];\n float denominator = a13 * x + a23 * y + a33;\n points[i] = (a11 * x + a21 * y + a31) / denominator;\n points[i + 1] = (a12 * x + a22 * y + a32) / denominator;\n }\n }\n\n public void transformPoints(float[] xValues, float[] yValues) {\n int n = xValues.length;\n for (int i = 0; i < n; i++) {\n float x = xValues[i];\n float y = yValues[i];\n float denominator = a13 * x + a23 * y + a33;\n xValues[i] = (a11 * x + a21 * y + a31) / denominator;\n yValues[i] = (a12 * x + a22 * y + a32) / denominator;\n }\n }\n\n public static PerspectiveTransform squareToQuadrilateral(float x0, float y0,\n float x1, float y1,\n float x2, float y2,\n float x3, float y3) {\n float dx3 = x0 - x1 + x2 - x3;\n float dy3 = y0 - y1 + y2 - y3;\n if (dx3 == 0.0f && dy3 == 0.0f) {\n // Affine\n return new PerspectiveTransform(x1 - x0, x2 - x1, x0,\n y1 - y0, y2 - y1, y0,\n 0.0f, 0.0f, 1.0f);\n } else {\n float dx1 = x1 - x2;\n float dx2 = x3 - x2;\n float dy1 = y1 - y2;\n float dy2 = y3 - y2;\n float denominator = dx1 * dy2 - dx2 * dy1;\n float a13 = (dx3 * dy2 - dx2 * dy3) / denominator;\n float a23 = (dx1 * dy3 - dx3 * dy1) / denominator;\n return new PerspectiveTransform(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0,\n y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0,\n a13, a23, 1.0f);\n }\n }\n\n public static PerspectiveTransform quadrilateralToSquare(float x0, float y0,\n float x1, float y1,\n float x2, float y2,\n float x3, float y3) {\n // Here, the adjoint serves as the inverse:\n return squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3).buildAdjoint();\n }\n\n PerspectiveTransform buildAdjoint() {\n // Adjoint is the transpose of the cofactor matrix:\n return new PerspectiveTransform(a22 * a33 - a23 * a32,\n a23 * a31 - a21 * a33,\n a21 * a32 - a22 * a31,\n a13 * a32 - a12 * a33,\n a11 * a33 - a13 * a31,\n a12 * a31 - a11 * a32,\n a12 * a23 - a13 * a22,\n a13 * a21 - a11 * a23,\n a11 * a22 - a12 * a21);\n }\n\n PerspectiveTransform times(PerspectiveTransform other) {\n return new PerspectiveTransform(a11 * other.a11 + a21 * other.a12 + a31 * other.a13,\n a11 * other.a21 + a21 * other.a22 + a31 * other.a23,\n a11 * other.a31 + a21 * other.a32 + a31 * other.a33,\n a12 * other.a11 + a22 * other.a12 + a32 * other.a13,\n a12 * other.a21 + a22 * other.a22 + a32 * other.a23,\n a12 * other.a31 + a22 * other.a32 + a32 * other.a33,\n a13 * other.a11 + a23 * other.a12 + a33 * other.a13,\n a13 * other.a21 + a23 * other.a22 + a33 * other.a23,\n a13 * other.a31 + a23 * other.a32 + a33 * other.a33);\n\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/common/StringUtils.java", "content": "/*\n * Copyright (C) 2010 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common;\n\nimport java.nio.charset.Charset;\nimport java.util.Map;\n\nimport com.google.zxing.DecodeHintType;\n\n/**\n * Common string-related functions.\n *\n * @author Sean Owen\n * @author Alex Dupre\n */\npublic final class StringUtils {\n\n private static final String PLATFORM_DEFAULT_ENCODING = Charset.defaultCharset().name();\n public static final String SHIFT_JIS = \"SJIS\";\n public static final String GB2312 = \"GB2312\";\n private static final String EUC_JP = \"EUC_JP\";\n private static final String UTF8 = \"UTF8\";\n private static final String ISO88591 = \"ISO8859_1\";\n private static final boolean ASSUME_SHIFT_JIS =\n SHIFT_JIS.equalsIgnoreCase(PLATFORM_DEFAULT_ENCODING) ||\n EUC_JP.equalsIgnoreCase(PLATFORM_DEFAULT_ENCODING);\n\n private StringUtils() { }\n\n /**\n * @param bytes bytes encoding a string, whose encoding should be guessed\n * @param hints decode hints if applicable\n * @return name of guessed encoding; at the moment will only guess one of:\n * {@link #SHIFT_JIS}, {@link #UTF8}, {@link #ISO88591}, or the platform\n * default encoding if none of these can possibly be correct\n */\n public static String guessEncoding(byte[] bytes, MapA somewhat generic detector that looks for a barcode-like rectangular region within an image.\n * It looks within a mostly white region of an image for a region of black and white, but mostly\n * black. It returns the four corners of the region, as best it can determine.
\n *\n * @author Sean Owen\n * @deprecated without replacement since 3.3.0\n */\n@Deprecated\npublic final class MonochromeRectangleDetector {\n\n private static final int MAX_MODULES = 32;\n\n private final BitMatrix image;\n\n public MonochromeRectangleDetector(BitMatrix image) {\n this.image = image;\n }\n\n /**\n *Detects a rectangular region of black and white -- mostly black -- with a region of mostly\n * white, in an image.
\n *\n * @return {@link ResultPoint}[] describing the corners of the rectangular region. The first and\n * last points are opposed on the diagonal, as are the second and third. The first point will be\n * the topmost point and the last, the bottommost. The second point will be leftmost and the\n * third, the rightmost\n * @throws NotFoundException if no Data Matrix Code can be found\n */\n public ResultPoint[] detect() throws NotFoundException {\n int height = image.getHeight();\n int width = image.getWidth();\n int halfHeight = height / 2;\n int halfWidth = width / 2;\n int deltaY = Math.max(1, height / (MAX_MODULES * 8));\n int deltaX = Math.max(1, width / (MAX_MODULES * 8));\n\n int top = 0;\n int bottom = height;\n int left = 0;\n int right = width;\n ResultPoint pointA = findCornerFromCenter(halfWidth, 0, left, right,\n halfHeight, -deltaY, top, bottom, halfWidth / 2);\n top = (int) pointA.getY() - 1;\n ResultPoint pointB = findCornerFromCenter(halfWidth, -deltaX, left, right,\n halfHeight, 0, top, bottom, halfHeight / 2);\n left = (int) pointB.getX() - 1;\n ResultPoint pointC = findCornerFromCenter(halfWidth, deltaX, left, right,\n halfHeight, 0, top, bottom, halfHeight / 2);\n right = (int) pointC.getX() + 1;\n ResultPoint pointD = findCornerFromCenter(halfWidth, 0, left, right,\n halfHeight, deltaY, top, bottom, halfWidth / 2);\n bottom = (int) pointD.getY() + 1;\n\n // Go try to find point A again with better information -- might have been off at first.\n pointA = findCornerFromCenter(halfWidth, 0, left, right,\n halfHeight, -deltaY, top, bottom, halfWidth / 4);\n\n return new ResultPoint[] { pointA, pointB, pointC, pointD };\n }\n\n /**\n * Attempts to locate a corner of the barcode by scanning up, down, left or right from a center\n * point which should be within the barcode.\n *\n * @param centerX center's x component (horizontal)\n * @param deltaX same as deltaY but change in x per step instead\n * @param left minimum value of x\n * @param right maximum value of x\n * @param centerY center's y component (vertical)\n * @param deltaY change in y per step. If scanning up this is negative; down, positive;\n * left or right, 0\n * @param top minimum value of y to search through (meaningless when di == 0)\n * @param bottom maximum value of y\n * @param maxWhiteRun maximum run of white pixels that can still be considered to be within\n * the barcode\n * @return a {@link ResultPoint} encapsulating the corner that was found\n * @throws NotFoundException if such a point cannot be found\n */\n private ResultPoint findCornerFromCenter(int centerX,\n int deltaX,\n int left,\n int right,\n int centerY,\n int deltaY,\n int top,\n int bottom,\n int maxWhiteRun) throws NotFoundException {\n int[] lastRange = null;\n for (int y = centerY, x = centerX;\n y < bottom && y >= top && x < right && x >= left;\n y += deltaY, x += deltaX) {\n int[] range;\n if (deltaX == 0) {\n // horizontal slices, up and down\n range = blackWhiteRange(y, maxWhiteRun, left, right, true);\n } else {\n // vertical slices, left and right\n range = blackWhiteRange(x, maxWhiteRun, top, bottom, false);\n }\n if (range == null) {\n if (lastRange == null) {\n throw NotFoundException.getNotFoundInstance();\n }\n // lastRange was found\n if (deltaX == 0) {\n int lastY = y - deltaY;\n if (lastRange[0] < centerX) {\n if (lastRange[1] > centerX) {\n // straddle, choose one or the other based on direction\n return new ResultPoint(lastRange[deltaY > 0 ? 0 : 1], lastY);\n }\n return new ResultPoint(lastRange[0], lastY);\n } else {\n return new ResultPoint(lastRange[1], lastY);\n }\n } else {\n int lastX = x - deltaX;\n if (lastRange[0] < centerY) {\n if (lastRange[1] > centerY) {\n return new ResultPoint(lastX, lastRange[deltaX < 0 ? 0 : 1]);\n }\n return new ResultPoint(lastX, lastRange[0]);\n } else {\n return new ResultPoint(lastX, lastRange[1]);\n }\n }\n }\n lastRange = range;\n }\n throw NotFoundException.getNotFoundInstance();\n }\n\n /**\n * Computes the start and end of a region of pixels, either horizontally or vertically, that could\n * be part of a Data Matrix barcode.\n *\n * @param fixedDimension if scanning horizontally, this is the row (the fixed vertical location)\n * where we are scanning. If scanning vertically it's the column, the fixed horizontal location\n * @param maxWhiteRun largest run of white pixels that can still be considered part of the\n * barcode region\n * @param minDim minimum pixel location, horizontally or vertically, to consider\n * @param maxDim maximum pixel location, horizontally or vertically, to consider\n * @param horizontal if true, we're scanning left-right, instead of up-down\n * @return int[] with start and end of found range, or null if no such range is found\n * (e.g. only white was found)\n */\n private int[] blackWhiteRange(int fixedDimension, int maxWhiteRun, int minDim, int maxDim, boolean horizontal) {\n\n int center = (minDim + maxDim) / 2;\n\n // Scan left/up first\n int start = center;\n while (start >= minDim) {\n if (horizontal ? image.get(start, fixedDimension) : image.get(fixedDimension, start)) {\n start--;\n } else {\n int whiteRunStart = start;\n do {\n start--;\n } while (start >= minDim && !(horizontal ? image.get(start, fixedDimension) :\n image.get(fixedDimension, start)));\n int whiteRunSize = whiteRunStart - start;\n if (start < minDim || whiteRunSize > maxWhiteRun) {\n start = whiteRunStart;\n break;\n }\n }\n }\n start++;\n\n // Then try right/down\n int end = center;\n while (end < maxDim) {\n if (horizontal ? image.get(end, fixedDimension) : image.get(fixedDimension, end)) {\n end++;\n } else {\n int whiteRunStart = end;\n do {\n end++;\n } while (end < maxDim && !(horizontal ? image.get(end, fixedDimension) :\n image.get(fixedDimension, end)));\n int whiteRunSize = end - whiteRunStart;\n if (end >= maxDim || whiteRunSize > maxWhiteRun) {\n end = whiteRunStart;\n break;\n }\n }\n }\n end--;\n\n return end > start ? new int[]{start, end} : null;\n }\n\n}" }, { "path": "scanner/src/main/java/com/google/zxing/common/detector/WhiteRectangleDetector.java", "content": "/*\n * Copyright 2010 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common.detector;\n\nimport com.google.zxing.NotFoundException;\nimport com.google.zxing.ResultPoint;\nimport com.google.zxing.common.BitMatrix;\n\n/**\n *\n * Detects a candidate barcode-like rectangular region within an image. It\n * starts around the center of the image, increases the size of the candidate\n * region until it finds a white rectangular region. By keeping track of the\n * last black points it encountered, it determines the corners of the barcode.\n *
\n *\n * @author David Olivier\n */\npublic final class WhiteRectangleDetector {\n\n private static final int INIT_SIZE = 10;\n private static final int CORR = 1;\n\n private final BitMatrix image;\n private final int height;\n private final int width;\n private final int leftInit;\n private final int rightInit;\n private final int downInit;\n private final int upInit;\n\n public WhiteRectangleDetector(BitMatrix image) throws NotFoundException {\n this(image, INIT_SIZE, image.getWidth() / 2, image.getHeight() / 2);\n }\n\n /**\n * @param image barcode image to find a rectangle in\n * @param initSize initial size of search area around center\n * @param x x position of search center\n * @param y y position of search center\n * @throws NotFoundException if image is too small to accommodate {@code initSize}\n */\n public WhiteRectangleDetector(BitMatrix image, int initSize, int x, int y) throws NotFoundException {\n this.image = image;\n height = image.getHeight();\n width = image.getWidth();\n int halfsize = initSize / 2;\n leftInit = x - halfsize;\n rightInit = x + halfsize;\n upInit = y - halfsize;\n downInit = y + halfsize;\n if (upInit < 0 || leftInit < 0 || downInit >= height || rightInit >= width) {\n throw NotFoundException.getNotFoundInstance();\n }\n }\n\n /**\n *\n * Detects a candidate barcode-like rectangular region within an image. It\n * starts around the center of the image, increases the size of the candidate\n * region until it finds a white rectangular region.\n *
\n *\n * @return {@link ResultPoint}[] describing the corners of the rectangular\n * region. The first and last points are opposed on the diagonal, as\n * are the second and third. The first point will be the topmost\n * point and the last, the bottommost. The second point will be\n * leftmost and the third, the rightmost\n * @throws NotFoundException if no Data Matrix Code can be found\n */\n public ResultPoint[] detect() throws NotFoundException {\n\n int left = leftInit;\n int right = rightInit;\n int up = upInit;\n int down = downInit;\n boolean sizeExceeded = false;\n boolean aBlackPointFoundOnBorder = true;\n\n boolean atLeastOneBlackPointFoundOnRight = false;\n boolean atLeastOneBlackPointFoundOnBottom = false;\n boolean atLeastOneBlackPointFoundOnLeft = false;\n boolean atLeastOneBlackPointFoundOnTop = false;\n\n while (aBlackPointFoundOnBorder) {\n\n aBlackPointFoundOnBorder = false;\n\n // .....\n // . |\n // .....\n boolean rightBorderNotWhite = true;\n while ((rightBorderNotWhite || !atLeastOneBlackPointFoundOnRight) && right < width) {\n rightBorderNotWhite = containsBlackPoint(up, down, right, false);\n if (rightBorderNotWhite) {\n right++;\n aBlackPointFoundOnBorder = true;\n atLeastOneBlackPointFoundOnRight = true;\n } else if (!atLeastOneBlackPointFoundOnRight) {\n right++;\n }\n }\n\n if (right >= width) {\n sizeExceeded = true;\n break;\n }\n\n // .....\n // . .\n // .___.\n boolean bottomBorderNotWhite = true;\n while ((bottomBorderNotWhite || !atLeastOneBlackPointFoundOnBottom) && down < height) {\n bottomBorderNotWhite = containsBlackPoint(left, right, down, true);\n if (bottomBorderNotWhite) {\n down++;\n aBlackPointFoundOnBorder = true;\n atLeastOneBlackPointFoundOnBottom = true;\n } else if (!atLeastOneBlackPointFoundOnBottom) {\n down++;\n }\n }\n\n if (down >= height) {\n sizeExceeded = true;\n break;\n }\n\n // .....\n // | .\n // .....\n boolean leftBorderNotWhite = true;\n while ((leftBorderNotWhite || !atLeastOneBlackPointFoundOnLeft) && left >= 0) {\n leftBorderNotWhite = containsBlackPoint(up, down, left, false);\n if (leftBorderNotWhite) {\n left--;\n aBlackPointFoundOnBorder = true;\n atLeastOneBlackPointFoundOnLeft = true;\n } else if (!atLeastOneBlackPointFoundOnLeft) {\n left--;\n }\n }\n\n if (left < 0) {\n sizeExceeded = true;\n break;\n }\n\n // .___.\n // . .\n // .....\n boolean topBorderNotWhite = true;\n while ((topBorderNotWhite || !atLeastOneBlackPointFoundOnTop) && up >= 0) {\n topBorderNotWhite = containsBlackPoint(left, right, up, true);\n if (topBorderNotWhite) {\n up--;\n aBlackPointFoundOnBorder = true;\n atLeastOneBlackPointFoundOnTop = true;\n } else if (!atLeastOneBlackPointFoundOnTop) {\n up--;\n }\n }\n\n if (up < 0) {\n sizeExceeded = true;\n break;\n }\n\n }\n\n if (!sizeExceeded) {\n\n int maxSize = right - left;\n\n ResultPoint z = null;\n for (int i = 1; z == null && i < maxSize; i++) {\n z = getBlackPointOnSegment(left, down - i, left + i, down);\n }\n\n if (z == null) {\n throw NotFoundException.getNotFoundInstance();\n }\n\n ResultPoint t = null;\n //go down right\n for (int i = 1; t == null && i < maxSize; i++) {\n t = getBlackPointOnSegment(left, up + i, left + i, up);\n }\n\n if (t == null) {\n throw NotFoundException.getNotFoundInstance();\n }\n\n ResultPoint x = null;\n //go down left\n for (int i = 1; x == null && i < maxSize; i++) {\n x = getBlackPointOnSegment(right, up + i, right - i, up);\n }\n\n if (x == null) {\n throw NotFoundException.getNotFoundInstance();\n }\n\n ResultPoint y = null;\n //go up left\n for (int i = 1; y == null && i < maxSize; i++) {\n y = getBlackPointOnSegment(right, down - i, right - i, down);\n }\n\n if (y == null) {\n throw NotFoundException.getNotFoundInstance();\n }\n\n return centerEdges(y, z, x, t);\n\n } else {\n throw NotFoundException.getNotFoundInstance();\n }\n }\n\n private ResultPoint getBlackPointOnSegment(float aX, float aY, float bX, float bY) {\n int dist = MathUtils.round(MathUtils.distance(aX, aY, bX, bY));\n float xStep = (bX - aX) / dist;\n float yStep = (bY - aY) / dist;\n\n for (int i = 0; i < dist; i++) {\n int x = MathUtils.round(aX + i * xStep);\n int y = MathUtils.round(aY + i * yStep);\n if (image.get(x, y)) {\n return new ResultPoint(x, y);\n }\n }\n return null;\n }\n\n /**\n * recenters the points of a constant distance towards the center\n *\n * @param y bottom most point\n * @param z left most point\n * @param x right most point\n * @param t top most point\n * @return {@link ResultPoint}[] describing the corners of the rectangular\n * region. The first and last points are opposed on the diagonal, as\n * are the second and third. The first point will be the topmost\n * point and the last, the bottommost. The second point will be\n * leftmost and the third, the rightmost\n */\n private ResultPoint[] centerEdges(ResultPoint y, ResultPoint z,\n ResultPoint x, ResultPoint t) {\n\n //\n // t t\n // z x\n // x OR z\n // y y\n //\n\n float yi = y.getX();\n float yj = y.getY();\n float zi = z.getX();\n float zj = z.getY();\n float xi = x.getX();\n float xj = x.getY();\n float ti = t.getX();\n float tj = t.getY();\n\n if (yi < width / 2.0f) {\n return new ResultPoint[]{\n new ResultPoint(ti - CORR, tj + CORR),\n new ResultPoint(zi + CORR, zj + CORR),\n new ResultPoint(xi - CORR, xj - CORR),\n new ResultPoint(yi + CORR, yj - CORR)};\n } else {\n return new ResultPoint[]{\n new ResultPoint(ti + CORR, tj + CORR),\n new ResultPoint(zi + CORR, zj - CORR),\n new ResultPoint(xi - CORR, xj + CORR),\n new ResultPoint(yi - CORR, yj - CORR)};\n }\n }\n\n /**\n * Determines whether a segment contains a black point\n *\n * @param a min value of the scanned coordinate\n * @param b max value of the scanned coordinate\n * @param fixed value of fixed coordinate\n * @param horizontal set to true if scan must be horizontal, false if vertical\n * @return true if a black point has been found, else false.\n */\n private boolean containsBlackPoint(int a, int b, int fixed, boolean horizontal) {\n\n if (horizontal) {\n for (int x = a; x <= b; x++) {\n if (image.get(x, fixed)) {\n return true;\n }\n }\n } else {\n for (int y = a; y <= b; y++) {\n if (image.get(fixed, y)) {\n return true;\n }\n }\n }\n\n return false;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/common/reedsolomon/GenericGF.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common.reedsolomon;\n\n/**\n *This class contains utility methods for performing mathematical operations over\n * the Galois Fields. Operations use a given primitive polynomial in calculations.
\n *\n *Throughout this package, elements of the GF are represented as an {@code int}\n * for convenience and speed (but at the cost of memory).\n *
\n *\n * @author Sean Owen\n * @author David Olivier\n */\npublic final class GenericGF {\n\n public static final GenericGF AZTEC_DATA_12 = new GenericGF(0x1069, 4096, 1); // x^12 + x^6 + x^5 + x^3 + 1\n public static final GenericGF AZTEC_DATA_10 = new GenericGF(0x409, 1024, 1); // x^10 + x^3 + 1\n public static final GenericGF AZTEC_DATA_6 = new GenericGF(0x43, 64, 1); // x^6 + x + 1\n public static final GenericGF AZTEC_PARAM = new GenericGF(0x13, 16, 1); // x^4 + x + 1\n public static final GenericGF QR_CODE_FIELD_256 = new GenericGF(0x011D, 256, 0); // x^8 + x^4 + x^3 + x^2 + 1\n public static final GenericGF DATA_MATRIX_FIELD_256 = new GenericGF(0x012D, 256, 1); // x^8 + x^5 + x^3 + x^2 + 1\n public static final GenericGF AZTEC_DATA_8 = DATA_MATRIX_FIELD_256;\n public static final GenericGF MAXICODE_FIELD_64 = AZTEC_DATA_6;\n\n private final int[] expTable;\n private final int[] logTable;\n private final GenericGFPoly zero;\n private final GenericGFPoly one;\n private final int size;\n private final int primitive;\n private final int generatorBase;\n\n /**\n * Create a representation of GF(size) using the given primitive polynomial.\n *\n * @param primitive irreducible polynomial whose coefficients are represented by\n * the bits of an int, where the least-significant bit represents the constant\n * coefficient\n * @param size the size of the field\n * @param b the factor b in the generator polynomial can be 0- or 1-based\n * (g(x) = (x+a^b)(x+a^(b+1))...(x+a^(b+2t-1))).\n * In most cases it should be 1, but for QR code it is 0.\n */\n public GenericGF(int primitive, int size, int b) {\n this.primitive = primitive;\n this.size = size;\n this.generatorBase = b;\n\n expTable = new int[size];\n logTable = new int[size];\n int x = 1;\n for (int i = 0; i < size; i++) {\n expTable[i] = x;\n x *= 2; // we're assuming the generator alpha is 2\n if (x >= size) {\n x ^= primitive;\n x &= size - 1;\n }\n }\n for (int i = 0; i < size - 1; i++) {\n logTable[expTable[i]] = i;\n }\n // logTable[0] == 0 but this should never be used\n zero = new GenericGFPoly(this, new int[]{0});\n one = new GenericGFPoly(this, new int[]{1});\n }\n\n GenericGFPoly getZero() {\n return zero;\n }\n\n GenericGFPoly getOne() {\n return one;\n }\n\n /**\n * @return the monomial representing coefficient * x^degree\n */\n GenericGFPoly buildMonomial(int degree, int coefficient) {\n if (degree < 0) {\n throw new IllegalArgumentException();\n }\n if (coefficient == 0) {\n return zero;\n }\n int[] coefficients = new int[degree + 1];\n coefficients[0] = coefficient;\n return new GenericGFPoly(this, coefficients);\n }\n\n /**\n * Implements both addition and subtraction -- they are the same in GF(size).\n *\n * @return sum/difference of a and b\n */\n static int addOrSubtract(int a, int b) {\n return a ^ b;\n }\n\n /**\n * @return 2 to the power of a in GF(size)\n */\n int exp(int a) {\n return expTable[a];\n }\n\n /**\n * @return base 2 log of a in GF(size)\n */\n int log(int a) {\n if (a == 0) {\n throw new IllegalArgumentException();\n }\n return logTable[a];\n }\n\n /**\n * @return multiplicative inverse of a\n */\n int inverse(int a) {\n if (a == 0) {\n throw new ArithmeticException();\n }\n return expTable[size - logTable[a] - 1];\n }\n\n /**\n * @return product of a and b in GF(size)\n */\n int multiply(int a, int b) {\n if (a == 0 || b == 0) {\n return 0;\n }\n return expTable[(logTable[a] + logTable[b]) % (size - 1)];\n }\n\n public int getSize() {\n return size;\n }\n\n public int getGeneratorBase() {\n return generatorBase;\n }\n\n @Override\n public String toString() {\n return \"GF(0x\" + Integer.toHexString(primitive) + ',' + size + ')';\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/common/reedsolomon/GenericGFPoly.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common.reedsolomon;\n\n/**\n *Represents a polynomial whose coefficients are elements of a GF.\n * Instances of this class are immutable.
\n *\n *Much credit is due to William Rucklidge since portions of this code are an indirect\n * port of his C++ Reed-Solomon implementation.
\n *\n * @author Sean Owen\n */\nfinal class GenericGFPoly {\n\n private final GenericGF field;\n private final int[] coefficients;\n\n /**\n * @param field the {@link GenericGF} instance representing the field to use\n * to perform computations\n * @param coefficients coefficients as ints representing elements of GF(size), arranged\n * from most significant (highest-power term) coefficient to least significant\n * @throws IllegalArgumentException if argument is null or empty,\n * or if leading coefficient is 0 and this is not a\n * constant polynomial (that is, it is not the monomial \"0\")\n */\n GenericGFPoly(GenericGF field, int[] coefficients) {\n if (coefficients.length == 0) {\n throw new IllegalArgumentException();\n }\n this.field = field;\n int coefficientsLength = coefficients.length;\n if (coefficientsLength > 1 && coefficients[0] == 0) {\n // Leading term must be non-zero for anything except the constant polynomial \"0\"\n int firstNonZero = 1;\n while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) {\n firstNonZero++;\n }\n if (firstNonZero == coefficientsLength) {\n this.coefficients = new int[]{0};\n } else {\n this.coefficients = new int[coefficientsLength - firstNonZero];\n System.arraycopy(coefficients,\n firstNonZero,\n this.coefficients,\n 0,\n this.coefficients.length);\n }\n } else {\n this.coefficients = coefficients;\n }\n }\n\n int[] getCoefficients() {\n return coefficients;\n }\n\n /**\n * @return degree of this polynomial\n */\n int getDegree() {\n return coefficients.length - 1;\n }\n\n /**\n * @return true iff this polynomial is the monomial \"0\"\n */\n boolean isZero() {\n return coefficients[0] == 0;\n }\n\n /**\n * @return coefficient of x^degree term in this polynomial\n */\n int getCoefficient(int degree) {\n return coefficients[coefficients.length - 1 - degree];\n }\n\n /**\n * @return evaluation of this polynomial at a given point\n */\n int evaluateAt(int a) {\n if (a == 0) {\n // Just return the x^0 coefficient\n return getCoefficient(0);\n }\n if (a == 1) {\n // Just the sum of the coefficients\n int result = 0;\n for (int coefficient : coefficients) {\n result = GenericGF.addOrSubtract(result, coefficient);\n }\n return result;\n }\n int result = coefficients[0];\n int size = coefficients.length;\n for (int i = 1; i < size; i++) {\n result = GenericGF.addOrSubtract(field.multiply(a, result), coefficients[i]);\n }\n return result;\n }\n\n GenericGFPoly addOrSubtract(GenericGFPoly other) {\n if (!field.equals(other.field)) {\n throw new IllegalArgumentException(\"GenericGFPolys do not have same GenericGF field\");\n }\n if (isZero()) {\n return other;\n }\n if (other.isZero()) {\n return this;\n }\n\n int[] smallerCoefficients = this.coefficients;\n int[] largerCoefficients = other.coefficients;\n if (smallerCoefficients.length > largerCoefficients.length) {\n int[] temp = smallerCoefficients;\n smallerCoefficients = largerCoefficients;\n largerCoefficients = temp;\n }\n int[] sumDiff = new int[largerCoefficients.length];\n int lengthDiff = largerCoefficients.length - smallerCoefficients.length;\n // Copy high-order terms only found in higher-degree polynomial's coefficients\n System.arraycopy(largerCoefficients, 0, sumDiff, 0, lengthDiff);\n\n for (int i = lengthDiff; i < largerCoefficients.length; i++) {\n sumDiff[i] = GenericGF.addOrSubtract(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);\n }\n\n return new GenericGFPoly(field, sumDiff);\n }\n\n GenericGFPoly multiply(GenericGFPoly other) {\n if (!field.equals(other.field)) {\n throw new IllegalArgumentException(\"GenericGFPolys do not have same GenericGF field\");\n }\n if (isZero() || other.isZero()) {\n return field.getZero();\n }\n int[] aCoefficients = this.coefficients;\n int aLength = aCoefficients.length;\n int[] bCoefficients = other.coefficients;\n int bLength = bCoefficients.length;\n int[] product = new int[aLength + bLength - 1];\n for (int i = 0; i < aLength; i++) {\n int aCoeff = aCoefficients[i];\n for (int j = 0; j < bLength; j++) {\n product[i + j] = GenericGF.addOrSubtract(product[i + j],\n field.multiply(aCoeff, bCoefficients[j]));\n }\n }\n return new GenericGFPoly(field, product);\n }\n\n GenericGFPoly multiply(int scalar) {\n if (scalar == 0) {\n return field.getZero();\n }\n if (scalar == 1) {\n return this;\n }\n int size = coefficients.length;\n int[] product = new int[size];\n for (int i = 0; i < size; i++) {\n product[i] = field.multiply(coefficients[i], scalar);\n }\n return new GenericGFPoly(field, product);\n }\n\n GenericGFPoly multiplyByMonomial(int degree, int coefficient) {\n if (degree < 0) {\n throw new IllegalArgumentException();\n }\n if (coefficient == 0) {\n return field.getZero();\n }\n int size = coefficients.length;\n int[] product = new int[size + degree];\n for (int i = 0; i < size; i++) {\n product[i] = field.multiply(coefficients[i], coefficient);\n }\n return new GenericGFPoly(field, product);\n }\n\n GenericGFPoly[] divide(GenericGFPoly other) {\n if (!field.equals(other.field)) {\n throw new IllegalArgumentException(\"GenericGFPolys do not have same GenericGF field\");\n }\n if (other.isZero()) {\n throw new IllegalArgumentException(\"Divide by 0\");\n }\n\n GenericGFPoly quotient = field.getZero();\n GenericGFPoly remainder = this;\n\n int denominatorLeadingTerm = other.getCoefficient(other.getDegree());\n int inverseDenominatorLeadingTerm = field.inverse(denominatorLeadingTerm);\n\n while (remainder.getDegree() >= other.getDegree() && !remainder.isZero()) {\n int degreeDifference = remainder.getDegree() - other.getDegree();\n int scale = field.multiply(remainder.getCoefficient(remainder.getDegree()), inverseDenominatorLeadingTerm);\n GenericGFPoly term = other.multiplyByMonomial(degreeDifference, scale);\n GenericGFPoly iterationQuotient = field.buildMonomial(degreeDifference, scale);\n quotient = quotient.addOrSubtract(iterationQuotient);\n remainder = remainder.addOrSubtract(term);\n }\n\n return new GenericGFPoly[] { quotient, remainder };\n }\n\n @Override\n public String toString() {\n if (isZero()) {\n return \"0\";\n }\n StringBuilder result = new StringBuilder(8 * getDegree());\n for (int degree = getDegree(); degree >= 0; degree--) {\n int coefficient = getCoefficient(degree);\n if (coefficient != 0) {\n if (coefficient < 0) {\n if (degree == getDegree()) {\n result.append(\"-\");\n } else {\n result.append(\" - \");\n }\n coefficient = -coefficient;\n } else {\n if (result.length() > 0) {\n result.append(\" + \");\n }\n }\n if (degree == 0 || coefficient != 1) {\n int alphaPower = field.log(coefficient);\n if (alphaPower == 0) {\n result.append('1');\n } else if (alphaPower == 1) {\n result.append('a');\n } else {\n result.append(\"a^\");\n result.append(alphaPower);\n }\n }\n if (degree != 0) {\n if (degree == 1) {\n result.append('x');\n } else {\n result.append(\"x^\");\n result.append(degree);\n }\n }\n }\n }\n return result.toString();\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/common/reedsolomon/ReedSolomonDecoder.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common.reedsolomon;\n\n/**\n *Implements Reed-Solomon decoding, as the name implies.
\n *\n *The algorithm will not be explained here, but the following references were helpful\n * in creating this implementation:
\n *\n *Much credit is due to William Rucklidge since portions of this code are an indirect\n * port of his C++ Reed-Solomon implementation.
\n *\n * @author Sean Owen\n * @author William Rucklidge\n * @author sanfordsquires\n */\npublic final class ReedSolomonDecoder {\n\n private final GenericGF field;\n\n public ReedSolomonDecoder(GenericGF field) {\n this.field = field;\n }\n\n /**\n *Decodes given set of received codewords, which include both data and error-correction\n * codewords. Really, this means it uses Reed-Solomon to detect and correct errors, in-place,\n * in the input.
\n *\n * @param received data and error-correction codewords\n * @param twoS number of error-correction codewords available\n * @throws ReedSolomonException if decoding fails for any reason\n */\n public void decode(int[] received, int twoS) throws ReedSolomonException {\n GenericGFPoly poly = new GenericGFPoly(field, received);\n int[] syndromeCoefficients = new int[twoS];\n boolean noError = true;\n for (int i = 0; i < twoS; i++) {\n int eval = poly.evaluateAt(field.exp(i + field.getGeneratorBase()));\n syndromeCoefficients[syndromeCoefficients.length - 1 - i] = eval;\n if (eval != 0) {\n noError = false;\n }\n }\n if (noError) {\n return;\n }\n GenericGFPoly syndrome = new GenericGFPoly(field, syndromeCoefficients);\n GenericGFPoly[] sigmaOmega =\n runEuclideanAlgorithm(field.buildMonomial(twoS, 1), syndrome, twoS);\n GenericGFPoly sigma = sigmaOmega[0];\n GenericGFPoly omega = sigmaOmega[1];\n int[] errorLocations = findErrorLocations(sigma);\n int[] errorMagnitudes = findErrorMagnitudes(omega, errorLocations);\n for (int i = 0; i < errorLocations.length; i++) {\n int position = received.length - 1 - field.log(errorLocations[i]);\n if (position < 0) {\n throw new ReedSolomonException(\"Bad error location\");\n }\n received[position] = GenericGF.addOrSubtract(received[position], errorMagnitudes[i]);\n }\n }\n\n private GenericGFPoly[] runEuclideanAlgorithm(GenericGFPoly a, GenericGFPoly b, int R)\n throws ReedSolomonException {\n // Assume a's degree is >= b's\n if (a.getDegree() < b.getDegree()) {\n GenericGFPoly temp = a;\n a = b;\n b = temp;\n }\n\n GenericGFPoly rLast = a;\n GenericGFPoly r = b;\n GenericGFPoly tLast = field.getZero();\n GenericGFPoly t = field.getOne();\n\n // Run Euclidean algorithm until r's degree is less than R/2\n while (r.getDegree() >= R / 2) {\n GenericGFPoly rLastLast = rLast;\n GenericGFPoly tLastLast = tLast;\n rLast = r;\n tLast = t;\n\n // Divide rLastLast by rLast, with quotient in q and remainder in r\n if (rLast.isZero()) {\n // Oops, Euclidean algorithm already terminated?\n throw new ReedSolomonException(\"r_{i-1} was zero\");\n }\n r = rLastLast;\n GenericGFPoly q = field.getZero();\n int denominatorLeadingTerm = rLast.getCoefficient(rLast.getDegree());\n int dltInverse = field.inverse(denominatorLeadingTerm);\n while (r.getDegree() >= rLast.getDegree() && !r.isZero()) {\n int degreeDiff = r.getDegree() - rLast.getDegree();\n int scale = field.multiply(r.getCoefficient(r.getDegree()), dltInverse);\n q = q.addOrSubtract(field.buildMonomial(degreeDiff, scale));\n r = r.addOrSubtract(rLast.multiplyByMonomial(degreeDiff, scale));\n }\n\n t = q.multiply(tLast).addOrSubtract(tLastLast);\n\n if (r.getDegree() >= rLast.getDegree()) {\n throw new IllegalStateException(\"Division algorithm failed to reduce polynomial?\");\n }\n }\n\n int sigmaTildeAtZero = t.getCoefficient(0);\n if (sigmaTildeAtZero == 0) {\n throw new ReedSolomonException(\"sigmaTilde(0) was zero\");\n }\n\n int inverse = field.inverse(sigmaTildeAtZero);\n GenericGFPoly sigma = t.multiply(inverse);\n GenericGFPoly omega = r.multiply(inverse);\n return new GenericGFPoly[]{sigma, omega};\n }\n\n private int[] findErrorLocations(GenericGFPoly errorLocator) throws ReedSolomonException {\n // This is a direct application of Chien's search\n int numErrors = errorLocator.getDegree();\n if (numErrors == 1) { // shortcut\n return new int[] { errorLocator.getCoefficient(1) };\n }\n int[] result = new int[numErrors];\n int e = 0;\n for (int i = 1; i < field.getSize() && e < numErrors; i++) {\n if (errorLocator.evaluateAt(i) == 0) {\n result[e] = field.inverse(i);\n e++;\n }\n }\n if (e != numErrors) {\n throw new ReedSolomonException(\"Error locator degree does not match number of roots\");\n }\n return result;\n }\n\n private int[] findErrorMagnitudes(GenericGFPoly errorEvaluator, int[] errorLocations) {\n // This is directly applying Forney's Formula\n int s = errorLocations.length;\n int[] result = new int[s];\n for (int i = 0; i < s; i++) {\n int xiInverse = field.inverse(errorLocations[i]);\n int denominator = 1;\n for (int j = 0; j < s; j++) {\n if (i != j) {\n //denominator = field.multiply(denominator,\n // GenericGF.addOrSubtract(1, field.multiply(errorLocations[j], xiInverse)));\n // Above should work but fails on some Apple and Linux JDKs due to a Hotspot bug.\n // Below is a funny-looking workaround from Steven Parkes\n int term = field.multiply(errorLocations[j], xiInverse);\n int termPlus1 = (term & 0x1) == 0 ? term | 1 : term & ~1;\n denominator = field.multiply(denominator, termPlus1);\n }\n }\n result[i] = field.multiply(errorEvaluator.evaluateAt(xiInverse),\n field.inverse(denominator));\n if (field.getGeneratorBase() != 0) {\n result[i] = field.multiply(result[i], xiInverse);\n }\n }\n return result;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/common/reedsolomon/ReedSolomonEncoder.java", "content": "/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.common.reedsolomon;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\n/**\n *Implements Reed-Solomon encoding, as the name implies.
\n *\n * @author Sean Owen\n * @author William Rucklidge\n */\npublic final class ReedSolomonEncoder {\n\n private final GenericGF field;\n private final ListThrown when an exception occurs during Reed-Solomon decoding, such as when\n * there are too many errors to correct.
\n *\n * @author Sean Owen\n */\npublic final class ReedSolomonException extends Exception {\n\n public ReedSolomonException(String message) {\n super(message);\n }\n\n}" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/DataMatrixReader.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix;\n\nimport com.google.zxing.BarcodeFormat;\nimport com.google.zxing.BinaryBitmap;\nimport com.google.zxing.ChecksumException;\nimport com.google.zxing.DecodeHintType;\nimport com.google.zxing.FormatException;\nimport com.google.zxing.NotFoundException;\nimport com.google.zxing.Reader;\nimport com.google.zxing.Result;\nimport com.google.zxing.ResultMetadataType;\nimport com.google.zxing.ResultPoint;\nimport com.google.zxing.common.BitMatrix;\nimport com.google.zxing.common.DecoderResult;\nimport com.google.zxing.common.DetectorResult;\nimport com.google.zxing.datamatrix.decoder.Decoder;\nimport com.google.zxing.datamatrix.detector.Detector;\n\nimport java.util.List;\nimport java.util.Map;\n\n/**\n * This implementation can detect and decode Data Matrix codes in an image.\n *\n * @author bbrown@google.com (Brian Brown)\n */\npublic final class DataMatrixReader implements Reader {\n\n private static final ResultPoint[] NO_POINTS = new ResultPoint[0];\n\n private final Decoder decoder = new Decoder();\n\n /**\n * Locates and decodes a Data Matrix code in an image.\n *\n * @return a String representing the content encoded by the Data Matrix code\n * @throws NotFoundException if a Data Matrix code cannot be found\n * @throws FormatException if a Data Matrix code cannot be decoded\n * @throws ChecksumException if error correction fails\n */\n @Override\n public Result decode(BinaryBitmap image) throws NotFoundException, ChecksumException, FormatException {\n return decode(image, null);\n }\n\n @Override\n public Result decode(BinaryBitmap image, MapCreates the version object based on the dimension of the original bit matrix from \n * the datamatrix code.
\n *\n *See ISO 16022:2006 Table 7 - ECC 200 symbol attributes
\n *\n * @param bitMatrix Original {@link BitMatrix} including alignment patterns\n * @return {@link Version} encapsulating the Data Matrix Code's \"version\"\n * @throws FormatException if the dimensions of the mapping matrix are not valid\n * Data Matrix dimensions.\n */\n private static Version readVersion(BitMatrix bitMatrix) throws FormatException {\n int numRows = bitMatrix.getHeight();\n int numColumns = bitMatrix.getWidth();\n return Version.getVersionForDimensions(numRows, numColumns);\n }\n\n /**\n *Reads the bits in the {@link BitMatrix} representing the mapping matrix (No alignment patterns)\n * in the correct order in order to reconstitute the codewords bytes contained within the\n * Data Matrix Code.
\n *\n * @return bytes encoded within the Data Matrix Code\n * @throws FormatException if the exact number of bytes expected is not read\n */\n byte[] readCodewords() throws FormatException {\n\n byte[] result = new byte[version.getTotalCodewords()];\n int resultOffset = 0;\n\n int row = 4;\n int column = 0;\n\n int numRows = mappingBitMatrix.getHeight();\n int numColumns = mappingBitMatrix.getWidth();\n\n boolean corner1Read = false;\n boolean corner2Read = false;\n boolean corner3Read = false;\n boolean corner4Read = false;\n\n // Read all of the codewords\n do {\n // Check the four corner cases\n if ((row == numRows) && (column == 0) && !corner1Read) {\n result[resultOffset++] = (byte) readCorner1(numRows, numColumns);\n row -= 2;\n column += 2;\n corner1Read = true;\n } else if ((row == numRows - 2) && (column == 0) && ((numColumns & 0x03) != 0) && !corner2Read) {\n result[resultOffset++] = (byte) readCorner2(numRows, numColumns);\n row -= 2;\n column += 2;\n corner2Read = true;\n } else if ((row == numRows + 4) && (column == 2) && ((numColumns & 0x07) == 0) && !corner3Read) {\n result[resultOffset++] = (byte) readCorner3(numRows, numColumns);\n row -= 2;\n column += 2;\n corner3Read = true;\n } else if ((row == numRows - 2) && (column == 0) && ((numColumns & 0x07) == 4) && !corner4Read) {\n result[resultOffset++] = (byte) readCorner4(numRows, numColumns);\n row -= 2;\n column += 2;\n corner4Read = true;\n } else {\n // Sweep upward diagonally to the right\n do {\n if ((row < numRows) && (column >= 0) && !readMappingMatrix.get(column, row)) {\n result[resultOffset++] = (byte) readUtah(row, column, numRows, numColumns);\n }\n row -= 2;\n column += 2;\n } while ((row >= 0) && (column < numColumns));\n row += 1;\n column += 3;\n\n // Sweep downward diagonally to the left\n do {\n if ((row >= 0) && (column < numColumns) && !readMappingMatrix.get(column, row)) {\n result[resultOffset++] = (byte) readUtah(row, column, numRows, numColumns);\n }\n row += 2;\n column -= 2;\n } while ((row < numRows) && (column >= 0));\n row += 3;\n column += 1;\n }\n } while ((row < numRows) || (column < numColumns));\n\n if (resultOffset != version.getTotalCodewords()) {\n throw FormatException.getFormatInstance();\n }\n return result;\n }\n\n /**\n *Reads a bit of the mapping matrix accounting for boundary wrapping.
\n *\n * @param row Row to read in the mapping matrix\n * @param column Column to read in the mapping matrix\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return value of the given bit in the mapping matrix\n */\n private boolean readModule(int row, int column, int numRows, int numColumns) {\n // Adjust the row and column indices based on boundary wrapping\n if (row < 0) {\n row += numRows;\n column += 4 - ((numRows + 4) & 0x07);\n }\n if (column < 0) {\n column += numColumns;\n row += 4 - ((numColumns + 4) & 0x07);\n }\n readMappingMatrix.set(column, row);\n return mappingBitMatrix.get(column, row);\n }\n\n /**\n *Reads the 8 bits of the standard Utah-shaped pattern.
\n *\n *See ISO 16022:2006, 5.8.1 Figure 6
\n *\n * @param row Current row in the mapping matrix, anchored at the 8th bit (LSB) of the pattern\n * @param column Current column in the mapping matrix, anchored at the 8th bit (LSB) of the pattern\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return byte from the utah shape\n */\n private int readUtah(int row, int column, int numRows, int numColumns) {\n int currentByte = 0;\n if (readModule(row - 2, column - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(row - 2, column - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(row - 1, column - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(row - 1, column - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(row - 1, column, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(row, column - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(row, column - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(row, column, numRows, numColumns)) {\n currentByte |= 1;\n }\n return currentByte;\n }\n\n /**\n *Reads the 8 bits of the special corner condition 1.
\n *\n *See ISO 16022:2006, Figure F.3
\n *\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return byte from the Corner condition 1\n */\n private int readCorner1(int numRows, int numColumns) {\n int currentByte = 0;\n if (readModule(numRows - 1, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(numRows - 1, 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(numRows - 1, 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(0, numColumns - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(0, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(1, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(2, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(3, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n return currentByte;\n }\n\n /**\n *Reads the 8 bits of the special corner condition 2.
\n *\n *See ISO 16022:2006, Figure F.4
\n *\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return byte from the Corner condition 2\n */\n private int readCorner2(int numRows, int numColumns) {\n int currentByte = 0;\n if (readModule(numRows - 3, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(numRows - 2, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(numRows - 1, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(0, numColumns - 4, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(0, numColumns - 3, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(0, numColumns - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(0, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(1, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n return currentByte;\n }\n\n /**\n *Reads the 8 bits of the special corner condition 3.
\n *\n *See ISO 16022:2006, Figure F.5
\n *\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return byte from the Corner condition 3\n */\n private int readCorner3(int numRows, int numColumns) {\n int currentByte = 0;\n if (readModule(numRows - 1, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(numRows - 1, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(0, numColumns - 3, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(0, numColumns - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(0, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(1, numColumns - 3, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(1, numColumns - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(1, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n return currentByte;\n }\n\n /**\n *Reads the 8 bits of the special corner condition 4.
\n *\n *See ISO 16022:2006, Figure F.6
\n *\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return byte from the Corner condition 4\n */\n private int readCorner4(int numRows, int numColumns) {\n int currentByte = 0;\n if (readModule(numRows - 3, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(numRows - 2, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(numRows - 1, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(0, numColumns - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(0, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(1, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(2, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (readModule(3, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n return currentByte;\n }\n\n /**\n *Extracts the data region from a {@link BitMatrix} that contains\n * alignment patterns.
\n *\n * @param bitMatrix Original {@link BitMatrix} with alignment patterns\n * @return BitMatrix that has the alignment patterns removed\n */\n private BitMatrix extractDataRegion(BitMatrix bitMatrix) {\n int symbolSizeRows = version.getSymbolSizeRows();\n int symbolSizeColumns = version.getSymbolSizeColumns();\n\n if (bitMatrix.getHeight() != symbolSizeRows) {\n throw new IllegalArgumentException(\"Dimension of bitMatrix must match the version size\");\n }\n\n int dataRegionSizeRows = version.getDataRegionSizeRows();\n int dataRegionSizeColumns = version.getDataRegionSizeColumns();\n\n int numDataRegionsRow = symbolSizeRows / dataRegionSizeRows;\n int numDataRegionsColumn = symbolSizeColumns / dataRegionSizeColumns;\n\n int sizeDataRegionRow = numDataRegionsRow * dataRegionSizeRows;\n int sizeDataRegionColumn = numDataRegionsColumn * dataRegionSizeColumns;\n\n BitMatrix bitMatrixWithoutAlignment = new BitMatrix(sizeDataRegionColumn, sizeDataRegionRow);\n for (int dataRegionRow = 0; dataRegionRow < numDataRegionsRow; ++dataRegionRow) {\n int dataRegionRowOffset = dataRegionRow * dataRegionSizeRows;\n for (int dataRegionColumn = 0; dataRegionColumn < numDataRegionsColumn; ++dataRegionColumn) {\n int dataRegionColumnOffset = dataRegionColumn * dataRegionSizeColumns;\n for (int i = 0; i < dataRegionSizeRows; ++i) {\n int readRowOffset = dataRegionRow * (dataRegionSizeRows + 2) + 1 + i;\n int writeRowOffset = dataRegionRowOffset + i;\n for (int j = 0; j < dataRegionSizeColumns; ++j) {\n int readColumnOffset = dataRegionColumn * (dataRegionSizeColumns + 2) + 1 + j;\n if (bitMatrix.get(readColumnOffset, readRowOffset)) {\n int writeColumnOffset = dataRegionColumnOffset + j;\n bitMatrixWithoutAlignment.set(writeColumnOffset, writeRowOffset);\n }\n }\n }\n }\n }\n return bitMatrixWithoutAlignment;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/decoder/DataBlock.java", "content": "/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.decoder;\n\n/**\n *Encapsulates a block of data within a Data Matrix Code. Data Matrix Codes may split their data into\n * multiple blocks, each of which is a unit of data and error-correction codewords. Each\n * is represented by an instance of this class.
\n *\n * @author bbrown@google.com (Brian Brown)\n */\nfinal class DataBlock {\n\n private final int numDataCodewords;\n private final byte[] codewords;\n\n private DataBlock(int numDataCodewords, byte[] codewords) {\n this.numDataCodewords = numDataCodewords;\n this.codewords = codewords;\n }\n\n /**\n *When Data Matrix Codes use multiple data blocks, they actually interleave the bytes of each of them.\n * That is, the first byte of data block 1 to n is written, then the second bytes, and so on. This\n * method will separate the data into original blocks.
\n *\n * @param rawCodewords bytes as read directly from the Data Matrix Code\n * @param version version of the Data Matrix Code\n * @return DataBlocks containing original bytes, \"de-interleaved\" from representation in the\n * Data Matrix Code\n */\n static DataBlock[] getDataBlocks(byte[] rawCodewords,\n Version version) {\n // Figure out the number and size of data blocks used by this version\n Version.ECBlocks ecBlocks = version.getECBlocks();\n\n // First count the total number of data blocks\n int totalBlocks = 0;\n Version.ECB[] ecBlockArray = ecBlocks.getECBlocks();\n for (Version.ECB ecBlock : ecBlockArray) {\n totalBlocks += ecBlock.getCount();\n }\n\n // Now establish DataBlocks of the appropriate size and number of data codewords\n DataBlock[] result = new DataBlock[totalBlocks];\n int numResultBlocks = 0;\n for (Version.ECB ecBlock : ecBlockArray) {\n for (int i = 0; i < ecBlock.getCount(); i++) {\n int numDataCodewords = ecBlock.getDataCodewords();\n int numBlockCodewords = ecBlocks.getECCodewords() + numDataCodewords;\n result[numResultBlocks++] = new DataBlock(numDataCodewords, new byte[numBlockCodewords]);\n }\n }\n\n // All blocks have the same amount of data, except that the last n\n // (where n may be 0) have 1 less byte. Figure out where these start.\n // TODO(bbrown): There is only one case where there is a difference for Data Matrix for size 144\n int longerBlocksTotalCodewords = result[0].codewords.length;\n //int shorterBlocksTotalCodewords = longerBlocksTotalCodewords - 1;\n\n int longerBlocksNumDataCodewords = longerBlocksTotalCodewords - ecBlocks.getECCodewords();\n int shorterBlocksNumDataCodewords = longerBlocksNumDataCodewords - 1;\n // The last elements of result may be 1 element shorter for 144 matrix\n // first fill out as many elements as all of them have minus 1\n int rawCodewordsOffset = 0;\n for (int i = 0; i < shorterBlocksNumDataCodewords; i++) {\n for (int j = 0; j < numResultBlocks; j++) {\n result[j].codewords[i] = rawCodewords[rawCodewordsOffset++];\n }\n }\n\n // Fill out the last data block in the longer ones\n boolean specialVersion = version.getVersionNumber() == 24;\n int numLongerBlocks = specialVersion ? 8 : numResultBlocks;\n for (int j = 0; j < numLongerBlocks; j++) {\n result[j].codewords[longerBlocksNumDataCodewords - 1] = rawCodewords[rawCodewordsOffset++];\n }\n\n // Now add in error correction blocks\n int max = result[0].codewords.length;\n for (int i = longerBlocksNumDataCodewords; i < max; i++) {\n for (int j = 0; j < numResultBlocks; j++) {\n int jOffset = specialVersion ? (j + 8) % numResultBlocks : j;\n int iOffset = specialVersion && jOffset > 7 ? i - 1 : i;\n result[jOffset].codewords[iOffset] = rawCodewords[rawCodewordsOffset++];\n }\n }\n\n if (rawCodewordsOffset != rawCodewords.length) {\n throw new IllegalArgumentException();\n }\n\n return result;\n }\n\n int getNumDataCodewords() {\n return numDataCodewords;\n }\n\n byte[] getCodewords() {\n return codewords;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/decoder/DecodedBitStreamParser.java", "content": "/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.decoder;\n\nimport com.google.zxing.FormatException;\nimport com.google.zxing.common.BitSource;\nimport com.google.zxing.common.DecoderResult;\n\nimport java.io.UnsupportedEncodingException;\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.List;\n\n/**\n *Data Matrix Codes can encode text as bits in one of several modes, and can use multiple modes\n * in one Data Matrix Code. This class decodes the bits back into text.
\n *\n *See ISO 16022:2006, 5.2.1 - 5.2.9.2
\n *\n * @author bbrown@google.com (Brian Brown)\n * @author Sean Owen\n */\nfinal class DecodedBitStreamParser {\n\n private enum Mode {\n PAD_ENCODE, // Not really a mode\n ASCII_ENCODE,\n C40_ENCODE,\n TEXT_ENCODE,\n ANSIX12_ENCODE,\n EDIFACT_ENCODE,\n BASE256_ENCODE\n }\n\n /**\n * See ISO 16022:2006, Annex C Table C.1\n * The C40 Basic Character Set (*'s used for placeholders for the shift values)\n */\n private static final char[] C40_BASIC_SET_CHARS = {\n '*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\n 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',\n 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'\n };\n\n private static final char[] C40_SHIFT2_SET_CHARS = {\n '!', '\"', '#', '$', '%', '&', '\\'', '(', ')', '*', '+', ',', '-', '.',\n '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\\\', ']', '^', '_'\n };\n\n /**\n * See ISO 16022:2006, Annex C Table C.2\n * The Text Basic Character Set (*'s used for placeholders for the shift values)\n */\n private static final char[] TEXT_BASIC_SET_CHARS = {\n '*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\n 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',\n 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'\n };\n\n // Shift 2 for Text is the same encoding as C40\n private static final char[] TEXT_SHIFT2_SET_CHARS = C40_SHIFT2_SET_CHARS;\n\n private static final char[] TEXT_SHIFT3_SET_CHARS = {\n '`', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',\n 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '~', (char) 127\n };\n\n private DecodedBitStreamParser() {\n }\n\n static DecoderResult decode(byte[] bytes) throws FormatException {\n BitSource bits = new BitSource(bytes);\n StringBuilder result = new StringBuilder(100);\n StringBuilder resultTrailer = new StringBuilder(0);\n ListThe main class which implements Data Matrix Code decoding -- as opposed to locating and extracting\n * the Data Matrix Code from an image.
\n *\n * @author bbrown@google.com (Brian Brown)\n */\npublic final class Decoder {\n\n private final ReedSolomonDecoder rsDecoder;\n\n public Decoder() {\n rsDecoder = new ReedSolomonDecoder(GenericGF.DATA_MATRIX_FIELD_256);\n }\n\n /**\n *Convenience method that can decode a Data Matrix Code represented as a 2D array of booleans.\n * \"true\" is taken to mean a black module.
\n *\n * @param image booleans representing white/black Data Matrix Code modules\n * @return text and bytes encoded within the Data Matrix Code\n * @throws FormatException if the Data Matrix Code cannot be decoded\n * @throws ChecksumException if error correction fails\n */\n public DecoderResult decode(boolean[][] image) throws FormatException, ChecksumException {\n return decode(BitMatrix.parse(image));\n }\n\n /**\n *Decodes a Data Matrix Code represented as a {@link BitMatrix}. A 1 or \"true\" is taken\n * to mean a black module.
\n *\n * @param bits booleans representing white/black Data Matrix Code modules\n * @return text and bytes encoded within the Data Matrix Code\n * @throws FormatException if the Data Matrix Code cannot be decoded\n * @throws ChecksumException if error correction fails\n */\n public DecoderResult decode(BitMatrix bits) throws FormatException, ChecksumException {\n\n // Construct a parser and read version, error-correction level\n BitMatrixParser parser = new BitMatrixParser(bits);\n Version version = parser.getVersion();\n\n // Read codewords\n byte[] codewords = parser.readCodewords();\n // Separate into data blocks\n DataBlock[] dataBlocks = DataBlock.getDataBlocks(codewords, version);\n\n // Count total number of data bytes\n int totalBytes = 0;\n for (DataBlock db : dataBlocks) {\n totalBytes += db.getNumDataCodewords();\n }\n byte[] resultBytes = new byte[totalBytes];\n\n int dataBlocksCount = dataBlocks.length;\n // Error-correct and copy data blocks together into a stream of bytes\n for (int j = 0; j < dataBlocksCount; j++) {\n DataBlock dataBlock = dataBlocks[j];\n byte[] codewordBytes = dataBlock.getCodewords();\n int numDataCodewords = dataBlock.getNumDataCodewords();\n correctErrors(codewordBytes, numDataCodewords);\n for (int i = 0; i < numDataCodewords; i++) {\n // De-interlace data blocks.\n resultBytes[i * dataBlocksCount + j] = codewordBytes[i];\n }\n }\n\n // Decode the contents of that stream of bytes\n return DecodedBitStreamParser.decode(resultBytes);\n }\n\n /**\n *Given data and error-correction codewords received, possibly corrupted by errors, attempts to\n * correct the errors in-place using Reed-Solomon error correction.
\n *\n * @param codewordBytes data and error correction codewords\n * @param numDataCodewords number of codewords that are data bytes\n * @throws ChecksumException if error correction fails\n */\n private void correctErrors(byte[] codewordBytes, int numDataCodewords) throws ChecksumException {\n int numCodewords = codewordBytes.length;\n // First read into an array of ints\n int[] codewordsInts = new int[numCodewords];\n for (int i = 0; i < numCodewords; i++) {\n codewordsInts[i] = codewordBytes[i] & 0xFF;\n }\n try {\n rsDecoder.decode(codewordsInts, codewordBytes.length - numDataCodewords);\n } catch (ReedSolomonException ignored) {\n throw ChecksumException.getChecksumInstance();\n }\n // Copy back into array of bytes -- only need to worry about the bytes that were data\n // We don't care about errors in the error-correction codewords\n for (int i = 0; i < numDataCodewords; i++) {\n codewordBytes[i] = (byte) codewordsInts[i];\n }\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/decoder/Version.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.decoder;\n\nimport com.google.zxing.FormatException;\n\n/**\n * The Version object encapsulates attributes about a particular\n * size Data Matrix Code.\n *\n * @author bbrown@google.com (Brian Brown)\n */\npublic final class Version {\n\n private static final Version[] VERSIONS = buildVersions();\n\n private final int versionNumber;\n private final int symbolSizeRows;\n private final int symbolSizeColumns;\n private final int dataRegionSizeRows;\n private final int dataRegionSizeColumns;\n private final ECBlocks ecBlocks;\n private final int totalCodewords;\n\n private Version(int versionNumber,\n int symbolSizeRows,\n int symbolSizeColumns,\n int dataRegionSizeRows,\n int dataRegionSizeColumns,\n ECBlocks ecBlocks) {\n this.versionNumber = versionNumber;\n this.symbolSizeRows = symbolSizeRows;\n this.symbolSizeColumns = symbolSizeColumns;\n this.dataRegionSizeRows = dataRegionSizeRows;\n this.dataRegionSizeColumns = dataRegionSizeColumns;\n this.ecBlocks = ecBlocks;\n\n // Calculate the total number of codewords\n int total = 0;\n int ecCodewords = ecBlocks.getECCodewords();\n ECB[] ecbArray = ecBlocks.getECBlocks();\n for (ECB ecBlock : ecbArray) {\n total += ecBlock.getCount() * (ecBlock.getDataCodewords() + ecCodewords);\n }\n this.totalCodewords = total;\n }\n\n public int getVersionNumber() {\n return versionNumber;\n }\n\n public int getSymbolSizeRows() {\n return symbolSizeRows;\n }\n\n public int getSymbolSizeColumns() {\n return symbolSizeColumns;\n }\n\n public int getDataRegionSizeRows() {\n return dataRegionSizeRows;\n }\n\n public int getDataRegionSizeColumns() {\n return dataRegionSizeColumns;\n }\n\n public int getTotalCodewords() {\n return totalCodewords;\n }\n\n ECBlocks getECBlocks() {\n return ecBlocks;\n }\n\n /**\n *Deduces version information from Data Matrix dimensions.
\n *\n * @param numRows Number of rows in modules\n * @param numColumns Number of columns in modules\n * @return Version for a Data Matrix Code of those dimensions\n * @throws FormatException if dimensions do correspond to a valid Data Matrix size\n */\n public static Version getVersionForDimensions(int numRows, int numColumns) throws FormatException {\n if ((numRows & 0x01) != 0 || (numColumns & 0x01) != 0) {\n throw FormatException.getFormatInstance();\n }\n\n for (Version version : VERSIONS) {\n if (version.symbolSizeRows == numRows && version.symbolSizeColumns == numColumns) {\n return version;\n }\n }\n\n throw FormatException.getFormatInstance();\n }\n\n /**\n *Encapsulates a set of error-correction blocks in one symbol version. Most versions will\n * use blocks of differing sizes within one version, so, this encapsulates the parameters for\n * each set of blocks. It also holds the number of error-correction codewords per block since it\n * will be the same across all blocks within one version.
\n */\n static final class ECBlocks {\n private final int ecCodewords;\n private final ECB[] ecBlocks;\n\n private ECBlocks(int ecCodewords, ECB ecBlocks) {\n this.ecCodewords = ecCodewords;\n this.ecBlocks = new ECB[] { ecBlocks };\n }\n\n private ECBlocks(int ecCodewords, ECB ecBlocks1, ECB ecBlocks2) {\n this.ecCodewords = ecCodewords;\n this.ecBlocks = new ECB[] { ecBlocks1, ecBlocks2 };\n }\n\n int getECCodewords() {\n return ecCodewords;\n }\n\n ECB[] getECBlocks() {\n return ecBlocks;\n }\n }\n\n /**\n *Encapsulates the parameters for one error-correction block in one symbol version.\n * This includes the number of data codewords, and the number of times a block with these\n * parameters is used consecutively in the Data Matrix code version's format.
\n */\n static final class ECB {\n private final int count;\n private final int dataCodewords;\n\n private ECB(int count, int dataCodewords) {\n this.count = count;\n this.dataCodewords = dataCodewords;\n }\n\n int getCount() {\n return count;\n }\n\n int getDataCodewords() {\n return dataCodewords;\n }\n }\n\n @Override\n public String toString() {\n return String.valueOf(versionNumber);\n }\n\n /**\n * See ISO 16022:2006 5.5.1 Table 7\n */\n private static Version[] buildVersions() {\n return new Version[]{\n new Version(1, 10, 10, 8, 8,\n new ECBlocks(5, new ECB(1, 3))),\n new Version(2, 12, 12, 10, 10,\n new ECBlocks(7, new ECB(1, 5))),\n new Version(3, 14, 14, 12, 12,\n new ECBlocks(10, new ECB(1, 8))),\n new Version(4, 16, 16, 14, 14,\n new ECBlocks(12, new ECB(1, 12))),\n new Version(5, 18, 18, 16, 16,\n new ECBlocks(14, new ECB(1, 18))),\n new Version(6, 20, 20, 18, 18,\n new ECBlocks(18, new ECB(1, 22))),\n new Version(7, 22, 22, 20, 20,\n new ECBlocks(20, new ECB(1, 30))),\n new Version(8, 24, 24, 22, 22,\n new ECBlocks(24, new ECB(1, 36))),\n new Version(9, 26, 26, 24, 24,\n new ECBlocks(28, new ECB(1, 44))),\n new Version(10, 32, 32, 14, 14,\n new ECBlocks(36, new ECB(1, 62))),\n new Version(11, 36, 36, 16, 16,\n new ECBlocks(42, new ECB(1, 86))),\n new Version(12, 40, 40, 18, 18,\n new ECBlocks(48, new ECB(1, 114))),\n new Version(13, 44, 44, 20, 20,\n new ECBlocks(56, new ECB(1, 144))),\n new Version(14, 48, 48, 22, 22,\n new ECBlocks(68, new ECB(1, 174))),\n new Version(15, 52, 52, 24, 24,\n new ECBlocks(42, new ECB(2, 102))),\n new Version(16, 64, 64, 14, 14,\n new ECBlocks(56, new ECB(2, 140))),\n new Version(17, 72, 72, 16, 16,\n new ECBlocks(36, new ECB(4, 92))),\n new Version(18, 80, 80, 18, 18,\n new ECBlocks(48, new ECB(4, 114))),\n new Version(19, 88, 88, 20, 20,\n new ECBlocks(56, new ECB(4, 144))),\n new Version(20, 96, 96, 22, 22,\n new ECBlocks(68, new ECB(4, 174))),\n new Version(21, 104, 104, 24, 24,\n new ECBlocks(56, new ECB(6, 136))),\n new Version(22, 120, 120, 18, 18,\n new ECBlocks(68, new ECB(6, 175))),\n new Version(23, 132, 132, 20, 20,\n new ECBlocks(62, new ECB(8, 163))),\n new Version(24, 144, 144, 22, 22,\n new ECBlocks(62, new ECB(8, 156), new ECB(2, 155))),\n new Version(25, 8, 18, 6, 16,\n new ECBlocks(7, new ECB(1, 5))),\n new Version(26, 8, 32, 6, 14,\n new ECBlocks(11, new ECB(1, 10))),\n new Version(27, 12, 26, 10, 24,\n new ECBlocks(14, new ECB(1, 16))),\n new Version(28, 12, 36, 10, 16,\n new ECBlocks(18, new ECB(1, 22))),\n new Version(29, 16, 36, 14, 16,\n new ECBlocks(24, new ECB(1, 32))),\n new Version(30, 16, 48, 14, 22,\n new ECBlocks(28, new ECB(1, 49)))\n };\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/detector/Detector.java", "content": "/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.detector;\n\nimport com.google.zxing.NotFoundException;\nimport com.google.zxing.ResultPoint;\nimport com.google.zxing.common.BitMatrix;\nimport com.google.zxing.common.DetectorResult;\nimport com.google.zxing.common.GridSampler;\nimport com.google.zxing.common.detector.WhiteRectangleDetector;\n\n/**\n *Encapsulates logic that can detect a Data Matrix Code in an image, even if the Data Matrix Code\n * is rotated or skewed, or partially obscured.
\n *\n * @author Sean Owen\n */\npublic final class Detector {\n\n private final BitMatrix image;\n private final WhiteRectangleDetector rectangleDetector;\n\n public Detector(BitMatrix image) throws NotFoundException {\n this.image = image;\n rectangleDetector = new WhiteRectangleDetector(image);\n }\n\n /**\n *Detects a Data Matrix Code in an image.
\n *\n * @return {@link DetectorResult} encapsulating results of detecting a Data Matrix Code\n * @throws NotFoundException if no Data Matrix Code can be found\n */\n public DetectorResult detect() throws NotFoundException {\n\n ResultPoint[] cornerPoints = rectangleDetector.detect();\n\n ResultPoint[] points = detectSolid1(cornerPoints);\n points = detectSolid2(points);\n points[3] = correctTopRight(points);\n if (points[3] == null) {\n throw NotFoundException.getNotFoundInstance();\n }\n points = shiftToModuleCenter(points);\n\n ResultPoint topLeft = points[0];\n ResultPoint bottomLeft = points[1];\n ResultPoint bottomRight = points[2];\n ResultPoint topRight = points[3];\n\n int dimensionTop = transitionsBetween(topLeft, topRight) + 1;\n int dimensionRight = transitionsBetween(bottomRight, topRight) + 1;\n if ((dimensionTop & 0x01) == 1) {\n dimensionTop += 1;\n }\n if ((dimensionRight & 0x01) == 1) {\n dimensionRight += 1;\n }\n\n if (4 * dimensionTop < 7 * dimensionRight && 4 * dimensionRight < 7 * dimensionTop) {\n // The matrix is square\n dimensionTop = dimensionRight = Math.max(dimensionTop, dimensionRight);\n }\n\n BitMatrix bits = sampleGrid(image, \n topLeft,\n bottomLeft,\n bottomRight,\n topRight,\n dimensionTop,\n dimensionRight);\n\n return new DetectorResult(bits, new ResultPoint[]{topLeft, bottomLeft, bottomRight, topRight});\n }\n\n private ResultPoint shiftPoint(ResultPoint point, ResultPoint to, int div) {\n float x = (to.getX() - point.getX()) / (div + 1);\n float y = (to.getY() - point.getY()) / (div + 1);\n return new ResultPoint(point.getX() + x, point.getY() + y);\n }\n\n private ResultPoint moveAway(ResultPoint point, float fromX, float fromY) {\n float x = point.getX();\n float y = point.getY();\n\n if (x < fromX) {\n x -= 1;\n } else {\n x += 1;\n }\n\n if (y < fromY) {\n y -= 1;\n } else {\n y += 1;\n }\n\n return new ResultPoint(x, y);\n }\n\n /**\n * Detect a solid side which has minimum transition.\n */\n private ResultPoint[] detectSolid1(ResultPoint[] cornerPoints) {\n // 0 2\n // 1 3\n ResultPoint pointA = cornerPoints[0];\n ResultPoint pointB = cornerPoints[1];\n ResultPoint pointC = cornerPoints[3];\n ResultPoint pointD = cornerPoints[2];\n\n int trAB = transitionsBetween(pointA, pointB);\n int trBC = transitionsBetween(pointB, pointC);\n int trCD = transitionsBetween(pointC, pointD);\n int trDA = transitionsBetween(pointD, pointA);\n\n // 0..3\n // : :\n // 1--2\n int min = trAB;\n ResultPoint[] points = {pointD, pointA, pointB, pointC};\n if (min > trBC) {\n min = trBC;\n points[0] = pointA;\n points[1] = pointB;\n points[2] = pointC;\n points[3] = pointD;\n }\n if (min > trCD) {\n min = trCD;\n points[0] = pointB;\n points[1] = pointC;\n points[2] = pointD;\n points[3] = pointA;\n }\n if (min > trDA) {\n points[0] = pointC;\n points[1] = pointD;\n points[2] = pointA;\n points[3] = pointB;\n }\n\n return points;\n }\n\n /**\n * Detect a second solid side next to first solid side.\n */\n private ResultPoint[] detectSolid2(ResultPoint[] points) {\n // A..D\n // : :\n // B--C\n ResultPoint pointA = points[0];\n ResultPoint pointB = points[1];\n ResultPoint pointC = points[2];\n ResultPoint pointD = points[3];\n\n // Transition detection on the edge is not stable.\n // To safely detect, shift the points to the module center.\n int tr = transitionsBetween(pointA, pointD);\n ResultPoint pointBs = shiftPoint(pointB, pointC, (tr + 1) * 4);\n ResultPoint pointCs = shiftPoint(pointC, pointB, (tr + 1) * 4);\n int trBA = transitionsBetween(pointBs, pointA);\n int trCD = transitionsBetween(pointCs, pointD);\n\n // 0..3\n // | :\n // 1--2\n if (trBA < trCD) {\n // solid sides: A-B-C\n points[0] = pointA;\n points[1] = pointB;\n points[2] = pointC;\n points[3] = pointD;\n } else {\n // solid sides: B-C-D\n points[0] = pointB;\n points[1] = pointC;\n points[2] = pointD;\n points[3] = pointA;\n }\n\n return points;\n }\n\n /**\n * Calculates the corner position of the white top right module.\n */\n private ResultPoint correctTopRight(ResultPoint[] points) {\n // A..D\n // | :\n // B--C\n ResultPoint pointA = points[0];\n ResultPoint pointB = points[1];\n ResultPoint pointC = points[2];\n ResultPoint pointD = points[3];\n\n // shift points for safe transition detection.\n int trTop = transitionsBetween(pointA, pointD);\n int trRight = transitionsBetween(pointB, pointD);\n ResultPoint pointAs = shiftPoint(pointA, pointB, (trRight + 1) * 4);\n ResultPoint pointCs = shiftPoint(pointC, pointB, (trTop + 1) * 4);\n\n trTop = transitionsBetween(pointAs, pointD);\n trRight = transitionsBetween(pointCs, pointD);\n\n ResultPoint candidate1 = new ResultPoint(\n pointD.getX() + (pointC.getX() - pointB.getX()) / (trTop + 1),\n pointD.getY() + (pointC.getY() - pointB.getY()) / (trTop + 1));\n ResultPoint candidate2 = new ResultPoint(\n pointD.getX() + (pointA.getX() - pointB.getX()) / (trRight + 1),\n pointD.getY() + (pointA.getY() - pointB.getY()) / (trRight + 1));\n\n if (!isValid(candidate1)) {\n if (isValid(candidate2)) {\n return candidate2;\n }\n return null;\n }\n if (!isValid(candidate2)) {\n return candidate1;\n }\n\n int sumc1 = transitionsBetween(pointAs, candidate1) + transitionsBetween(pointCs, candidate1);\n int sumc2 = transitionsBetween(pointAs, candidate2) + transitionsBetween(pointCs, candidate2);\n\n if (sumc1 > sumc2) {\n return candidate1;\n } else {\n return candidate2;\n }\n }\n\n /**\n * Shift the edge points to the module center.\n */\n private ResultPoint[] shiftToModuleCenter(ResultPoint[] points) {\n // A..D\n // | :\n // B--C\n ResultPoint pointA = points[0];\n ResultPoint pointB = points[1];\n ResultPoint pointC = points[2];\n ResultPoint pointD = points[3];\n\n // calculate pseudo dimensions\n int dimH = transitionsBetween(pointA, pointD) + 1;\n int dimV = transitionsBetween(pointC, pointD) + 1;\n\n // shift points for safe dimension detection\n ResultPoint pointAs = shiftPoint(pointA, pointB, dimV * 4);\n ResultPoint pointCs = shiftPoint(pointC, pointB, dimH * 4);\n\n // calculate more precise dimensions\n dimH = transitionsBetween(pointAs, pointD) + 1;\n dimV = transitionsBetween(pointCs, pointD) + 1;\n if ((dimH & 0x01) == 1) {\n dimH += 1;\n }\n if ((dimV & 0x01) == 1) {\n dimV += 1;\n }\n\n // WhiteRectangleDetector returns points inside of the rectangle.\n // I want points on the edges.\n float centerX = (pointA.getX() + pointB.getX() + pointC.getX() + pointD.getX()) / 4;\n float centerY = (pointA.getY() + pointB.getY() + pointC.getY() + pointD.getY()) / 4;\n pointA = moveAway(pointA, centerX, centerY);\n pointB = moveAway(pointB, centerX, centerY);\n pointC = moveAway(pointC, centerX, centerY);\n pointD = moveAway(pointD, centerX, centerY);\n\n ResultPoint pointBs;\n ResultPoint pointDs;\n\n // shift points to the center of each modules\n pointAs = shiftPoint(pointA, pointB, dimV * 4);\n pointAs = shiftPoint(pointAs, pointD, dimH * 4);\n pointBs = shiftPoint(pointB, pointA, dimV * 4);\n pointBs = shiftPoint(pointBs, pointC, dimH * 4);\n pointCs = shiftPoint(pointC, pointD, dimV * 4);\n pointCs = shiftPoint(pointCs, pointB, dimH * 4);\n pointDs = shiftPoint(pointD, pointC, dimV * 4);\n pointDs = shiftPoint(pointDs, pointA, dimH * 4);\n\n return new ResultPoint[]{pointAs, pointBs, pointCs, pointDs};\n }\n\n private boolean isValid(ResultPoint p) {\n return p.getX() >= 0 && p.getX() < image.getWidth() && p.getY() > 0 && p.getY() < image.getHeight();\n }\n\n private static BitMatrix sampleGrid(BitMatrix image,\n ResultPoint topLeft,\n ResultPoint bottomLeft,\n ResultPoint bottomRight,\n ResultPoint topRight,\n int dimensionX,\n int dimensionY) throws NotFoundException {\n\n GridSampler sampler = GridSampler.getInstance();\n\n return sampler.sampleGrid(image,\n dimensionX,\n dimensionY,\n 0.5f,\n 0.5f,\n dimensionX - 0.5f,\n 0.5f,\n dimensionX - 0.5f,\n dimensionY - 0.5f,\n 0.5f,\n dimensionY - 0.5f,\n topLeft.getX(),\n topLeft.getY(),\n topRight.getX(),\n topRight.getY(),\n bottomRight.getX(),\n bottomRight.getY(),\n bottomLeft.getX(),\n bottomLeft.getY());\n }\n\n /**\n * Counts the number of black/white transitions between two points, using something like Bresenham's algorithm.\n */\n private int transitionsBetween(ResultPoint from, ResultPoint to) {\n // See QR Code Detector, sizeOfBlackWhiteBlackRun()\n int fromX = (int) from.getX();\n int fromY = (int) from.getY();\n int toX = (int) to.getX();\n int toY = (int) to.getY();\n boolean steep = Math.abs(toY - fromY) > Math.abs(toX - fromX);\n if (steep) {\n int temp = fromX;\n fromX = fromY;\n fromY = temp;\n temp = toX;\n toX = toY;\n toY = temp;\n }\n\n int dx = Math.abs(toX - fromX);\n int dy = Math.abs(toY - fromY);\n int error = -dx / 2;\n int ystep = fromY < toY ? 1 : -1;\n int xstep = fromX < toX ? 1 : -1;\n int transitions = 0;\n boolean inBlack = image.get(steep ? fromY : fromX, steep ? fromX : fromY);\n for (int x = fromX, y = fromY; x != toX; x += xstep) {\n boolean isBlack = image.get(steep ? y : x, steep ? x : y);\n if (isBlack != inBlack) {\n transitions++;\n inBlack = isBlack;\n }\n error += dy;\n if (error > 0) {\n if (y == toY) {\n break;\n }\n y += ystep;\n error -= dx;\n }\n }\n return transitions;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/ASCIIEncoder.java", "content": "/*\n * Copyright 2006-2007 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\nfinal class ASCIIEncoder implements Encoder {\n\n @Override\n public int getEncodingMode() {\n return HighLevelEncoder.ASCII_ENCODATION;\n }\n\n @Override\n public void encode(EncoderContext context) {\n //step B\n int n = HighLevelEncoder.determineConsecutiveDigitCount(context.getMessage(), context.pos);\n if (n >= 2) {\n context.writeCodeword(encodeASCIIDigits(context.getMessage().charAt(context.pos),\n context.getMessage().charAt(context.pos + 1)));\n context.pos += 2;\n } else {\n char c = context.getCurrentChar();\n int newMode = HighLevelEncoder.lookAheadTest(context.getMessage(), context.pos, getEncodingMode());\n if (newMode != getEncodingMode()) {\n switch (newMode) {\n case HighLevelEncoder.BASE256_ENCODATION:\n context.writeCodeword(HighLevelEncoder.LATCH_TO_BASE256);\n context.signalEncoderChange(HighLevelEncoder.BASE256_ENCODATION);\n return;\n case HighLevelEncoder.C40_ENCODATION:\n context.writeCodeword(HighLevelEncoder.LATCH_TO_C40);\n context.signalEncoderChange(HighLevelEncoder.C40_ENCODATION);\n return;\n case HighLevelEncoder.X12_ENCODATION:\n context.writeCodeword(HighLevelEncoder.LATCH_TO_ANSIX12);\n context.signalEncoderChange(HighLevelEncoder.X12_ENCODATION);\n break;\n case HighLevelEncoder.TEXT_ENCODATION:\n context.writeCodeword(HighLevelEncoder.LATCH_TO_TEXT);\n context.signalEncoderChange(HighLevelEncoder.TEXT_ENCODATION);\n break;\n case HighLevelEncoder.EDIFACT_ENCODATION:\n context.writeCodeword(HighLevelEncoder.LATCH_TO_EDIFACT);\n context.signalEncoderChange(HighLevelEncoder.EDIFACT_ENCODATION);\n break;\n default:\n throw new IllegalStateException(\"Illegal mode: \" + newMode);\n }\n } else if (HighLevelEncoder.isExtendedASCII(c)) {\n context.writeCodeword(HighLevelEncoder.UPPER_SHIFT);\n context.writeCodeword((char) (c - 128 + 1));\n context.pos++;\n } else {\n context.writeCodeword((char) (c + 1));\n context.pos++;\n }\n\n }\n }\n\n private static char encodeASCIIDigits(char digit1, char digit2) {\n if (HighLevelEncoder.isDigit(digit1) && HighLevelEncoder.isDigit(digit2)) {\n int num = (digit1 - 48) * 10 + (digit2 - 48);\n return (char) (num + 130);\n }\n throw new IllegalArgumentException(\"not digits: \" + digit1 + digit2);\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/Base256Encoder.java", "content": "/*\n * Copyright 2006-2007 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\nfinal class Base256Encoder implements Encoder {\n\n @Override\n public int getEncodingMode() {\n return HighLevelEncoder.BASE256_ENCODATION;\n }\n\n @Override\n public void encode(EncoderContext context) {\n StringBuilder buffer = new StringBuilder();\n buffer.append('\\0'); //Initialize length field\n while (context.hasMoreCharacters()) {\n char c = context.getCurrentChar();\n buffer.append(c);\n\n context.pos++;\n\n int newMode = HighLevelEncoder.lookAheadTest(context.getMessage(), context.pos, getEncodingMode());\n if (newMode != getEncodingMode()) {\n // Return to ASCII encodation, which will actually handle latch to new mode\n context.signalEncoderChange(HighLevelEncoder.ASCII_ENCODATION);\n break;\n }\n }\n int dataCount = buffer.length() - 1;\n int lengthFieldSize = 1;\n int currentSize = context.getCodewordCount() + dataCount + lengthFieldSize;\n context.updateSymbolInfo(currentSize);\n boolean mustPad = (context.getSymbolInfo().getDataCapacity() - currentSize) > 0;\n if (context.hasMoreCharacters() || mustPad) {\n if (dataCount <= 249) {\n buffer.setCharAt(0, (char) dataCount);\n } else if (dataCount <= 1555) {\n buffer.setCharAt(0, (char) ((dataCount / 250) + 249));\n buffer.insert(1, (char) (dataCount % 250));\n } else {\n throw new IllegalStateException(\n \"Message length not in valid ranges: \" + dataCount);\n }\n }\n for (int i = 0, c = buffer.length(); i < c; i++) {\n context.writeCodeword(randomize255State(\n buffer.charAt(i), context.getCodewordCount() + 1));\n }\n }\n\n private static char randomize255State(char ch, int codewordPosition) {\n int pseudoRandom = ((149 * codewordPosition) % 255) + 1;\n int tempVariable = ch + pseudoRandom;\n if (tempVariable <= 255) {\n return (char) tempVariable;\n } else {\n return (char) (tempVariable - 256);\n }\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/C40Encoder.java", "content": "/*\n * Copyright 2006-2007 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\nclass C40Encoder implements Encoder {\n\n @Override\n public int getEncodingMode() {\n return HighLevelEncoder.C40_ENCODATION;\n }\n\n @Override\n public void encode(EncoderContext context) {\n //step C\n StringBuilder buffer = new StringBuilder();\n while (context.hasMoreCharacters()) {\n char c = context.getCurrentChar();\n context.pos++;\n\n int lastCharSize = encodeChar(c, buffer);\n\n int unwritten = (buffer.length() / 3) * 2;\n\n int curCodewordCount = context.getCodewordCount() + unwritten;\n context.updateSymbolInfo(curCodewordCount);\n int available = context.getSymbolInfo().getDataCapacity() - curCodewordCount;\n\n if (!context.hasMoreCharacters()) {\n //Avoid having a single C40 value in the last triplet\n StringBuilder removed = new StringBuilder();\n if ((buffer.length() % 3) == 2 && (available < 2 || available > 2)) {\n lastCharSize = backtrackOneCharacter(context, buffer, removed, lastCharSize);\n }\n while ((buffer.length() % 3) == 1 && (lastCharSize > 3 || available != 1)) {\n lastCharSize = backtrackOneCharacter(context, buffer, removed, lastCharSize);\n }\n break;\n }\n\n int count = buffer.length();\n if ((count % 3) == 0) {\n int newMode = HighLevelEncoder.lookAheadTest(context.getMessage(), context.pos, getEncodingMode());\n if (newMode != getEncodingMode()) {\n // Return to ASCII encodation, which will actually handle latch to new mode\n context.signalEncoderChange(HighLevelEncoder.ASCII_ENCODATION);\n break;\n }\n }\n }\n handleEOD(context, buffer);\n }\n\n private int backtrackOneCharacter(EncoderContext context,\n StringBuilder buffer, StringBuilder removed, int lastCharSize) {\n int count = buffer.length();\n buffer.delete(count - lastCharSize, count);\n context.pos--;\n char c = context.getCurrentChar();\n lastCharSize = encodeChar(c, removed);\n context.resetSymbolInfo(); //Deal with possible reduction in symbol size\n return lastCharSize;\n }\n\n static void writeNextTriplet(EncoderContext context, StringBuilder buffer) {\n context.writeCodewords(encodeToCodewords(buffer, 0));\n buffer.delete(0, 3);\n }\n\n /**\n * Handle \"end of data\" situations\n *\n * @param context the encoder context\n * @param buffer the buffer with the remaining encoded characters\n */\n void handleEOD(EncoderContext context, StringBuilder buffer) {\n int unwritten = (buffer.length() / 3) * 2;\n int rest = buffer.length() % 3;\n\n int curCodewordCount = context.getCodewordCount() + unwritten;\n context.updateSymbolInfo(curCodewordCount);\n int available = context.getSymbolInfo().getDataCapacity() - curCodewordCount;\n\n if (rest == 2) {\n buffer.append('\\0'); //Shift 1\n while (buffer.length() >= 3) {\n writeNextTriplet(context, buffer);\n }\n if (context.hasMoreCharacters()) {\n context.writeCodeword(HighLevelEncoder.C40_UNLATCH);\n }\n } else if (available == 1 && rest == 1) {\n while (buffer.length() >= 3) {\n writeNextTriplet(context, buffer);\n }\n if (context.hasMoreCharacters()) {\n context.writeCodeword(HighLevelEncoder.C40_UNLATCH);\n }\n // else no unlatch\n context.pos--;\n } else if (rest == 0) {\n while (buffer.length() >= 3) {\n writeNextTriplet(context, buffer);\n }\n if (available > 0 || context.hasMoreCharacters()) {\n context.writeCodeword(HighLevelEncoder.C40_UNLATCH);\n }\n } else {\n throw new IllegalStateException(\"Unexpected case. Please report!\");\n }\n context.signalEncoderChange(HighLevelEncoder.ASCII_ENCODATION);\n }\n\n int encodeChar(char c, StringBuilder sb) {\n if (c == ' ') {\n sb.append('\\3');\n return 1;\n }\n if (c >= '0' && c <= '9') {\n sb.append((char) (c - 48 + 4));\n return 1;\n }\n if (c >= 'A' && c <= 'Z') {\n sb.append((char) (c - 65 + 14));\n return 1;\n }\n if (c < ' ') {\n sb.append('\\0'); //Shift 1 Set\n sb.append(c);\n return 2;\n }\n if (c >= '!' && c <= '/') {\n sb.append('\\1'); //Shift 2 Set\n sb.append((char) (c - 33));\n return 2;\n }\n if (c >= ':' && c <= '@') {\n sb.append('\\1'); //Shift 2 Set\n sb.append((char) (c - 58 + 15));\n return 2;\n }\n if (c >= '[' && c <= '_') {\n sb.append('\\1'); //Shift 2 Set\n sb.append((char) (c - 91 + 22));\n return 2;\n }\n if (c >= '`' && c <= 127) {\n sb.append('\\2'); //Shift 3 Set\n sb.append((char) (c - 96));\n return 2;\n }\n sb.append(\"\\1\\u001e\"); //Shift 2, Upper Shift\n int len = 2;\n len += encodeChar((char) (c - 128), sb);\n return len;\n }\n\n private static String encodeToCodewords(CharSequence sb, int startPos) {\n char c1 = sb.charAt(startPos);\n char c2 = sb.charAt(startPos + 1);\n char c3 = sb.charAt(startPos + 2);\n int v = (1600 * c1) + (40 * c2) + c3 + 1;\n char cw1 = (char) (v / 256);\n char cw2 = (char) (v % 256);\n return new String(new char[] {cw1, cw2});\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/DataMatrixSymbolInfo144.java", "content": "/*\n * Copyright 2006 Jeremias Maerki\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\nfinal class DataMatrixSymbolInfo144 extends SymbolInfo {\n\n DataMatrixSymbolInfo144() {\n super(false, 1558, 620, 22, 22, 36, -1, 62);\n }\n\n @Override\n public int getInterleavedBlockCount() {\n return 10;\n }\n\n @Override\n public int getDataLengthForInterleavedBlock(int index) {\n return (index <= 8) ? 156 : 155;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/DefaultPlacement.java", "content": "/*\n * Copyright 2006 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\nimport java.util.Arrays;\n\n/**\n * Symbol Character Placement Program. Adapted from Annex M.1 in ISO/IEC 16022:2000(E).\n */\npublic class DefaultPlacement {\n\n private final CharSequence codewords;\n private final int numrows;\n private final int numcols;\n private final byte[] bits;\n\n /**\n * Main constructor\n *\n * @param codewords the codewords to place\n * @param numcols the number of columns\n * @param numrows the number of rows\n */\n public DefaultPlacement(CharSequence codewords, int numcols, int numrows) {\n this.codewords = codewords;\n this.numcols = numcols;\n this.numrows = numrows;\n this.bits = new byte[numcols * numrows];\n Arrays.fill(this.bits, (byte) -1); //Initialize with \"not set\" value\n }\n\n final int getNumrows() {\n return numrows;\n }\n\n final int getNumcols() {\n return numcols;\n }\n\n final byte[] getBits() {\n return bits;\n }\n\n public final boolean getBit(int col, int row) {\n return bits[row * numcols + col] == 1;\n }\n\n private void setBit(int col, int row, boolean bit) {\n bits[row * numcols + col] = (byte) (bit ? 1 : 0);\n }\n\n private boolean hasBit(int col, int row) {\n return bits[row * numcols + col] >= 0;\n }\n\n public final void place() {\n int pos = 0;\n int row = 4;\n int col = 0;\n\n do {\n /* repeatedly first check for one of the special corner cases, then... */\n if ((row == numrows) && (col == 0)) {\n corner1(pos++);\n }\n if ((row == numrows - 2) && (col == 0) && ((numcols % 4) != 0)) {\n corner2(pos++);\n }\n if ((row == numrows - 2) && (col == 0) && (numcols % 8 == 4)) {\n corner3(pos++);\n }\n if ((row == numrows + 4) && (col == 2) && ((numcols % 8) == 0)) {\n corner4(pos++);\n }\n /* sweep upward diagonally, inserting successive characters... */\n do {\n if ((row < numrows) && (col >= 0) && !hasBit(col, row)) {\n utah(row, col, pos++);\n }\n row -= 2;\n col += 2;\n } while (row >= 0 && (col < numcols));\n row++;\n col += 3;\n\n /* and then sweep downward diagonally, inserting successive characters, ... */\n do {\n if ((row >= 0) && (col < numcols) && !hasBit(col, row)) {\n utah(row, col, pos++);\n }\n row += 2;\n col -= 2;\n } while ((row < numrows) && (col >= 0));\n row += 3;\n col++;\n\n /* ...until the entire array is scanned */\n } while ((row < numrows) || (col < numcols));\n\n /* Lastly, if the lower righthand corner is untouched, fill in fixed pattern */\n if (!hasBit(numcols - 1, numrows - 1)) {\n setBit(numcols - 1, numrows - 1, true);\n setBit(numcols - 2, numrows - 2, true);\n }\n }\n\n private void module(int row, int col, int pos, int bit) {\n if (row < 0) {\n row += numrows;\n col += 4 - ((numrows + 4) % 8);\n }\n if (col < 0) {\n col += numcols;\n row += 4 - ((numcols + 4) % 8);\n }\n // Note the conversion:\n int v = codewords.charAt(pos);\n v &= 1 << (8 - bit);\n setBit(col, row, v != 0);\n }\n\n /**\n * Places the 8 bits of a utah-shaped symbol character in ECC200.\n *\n * @param row the row\n * @param col the column\n * @param pos character position\n */\n private void utah(int row, int col, int pos) {\n module(row - 2, col - 2, pos, 1);\n module(row - 2, col - 1, pos, 2);\n module(row - 1, col - 2, pos, 3);\n module(row - 1, col - 1, pos, 4);\n module(row - 1, col, pos, 5);\n module(row, col - 2, pos, 6);\n module(row, col - 1, pos, 7);\n module(row, col, pos, 8);\n }\n\n private void corner1(int pos) {\n module(numrows - 1, 0, pos, 1);\n module(numrows - 1, 1, pos, 2);\n module(numrows - 1, 2, pos, 3);\n module(0, numcols - 2, pos, 4);\n module(0, numcols - 1, pos, 5);\n module(1, numcols - 1, pos, 6);\n module(2, numcols - 1, pos, 7);\n module(3, numcols - 1, pos, 8);\n }\n\n private void corner2(int pos) {\n module(numrows - 3, 0, pos, 1);\n module(numrows - 2, 0, pos, 2);\n module(numrows - 1, 0, pos, 3);\n module(0, numcols - 4, pos, 4);\n module(0, numcols - 3, pos, 5);\n module(0, numcols - 2, pos, 6);\n module(0, numcols - 1, pos, 7);\n module(1, numcols - 1, pos, 8);\n }\n\n private void corner3(int pos) {\n module(numrows - 3, 0, pos, 1);\n module(numrows - 2, 0, pos, 2);\n module(numrows - 1, 0, pos, 3);\n module(0, numcols - 2, pos, 4);\n module(0, numcols - 1, pos, 5);\n module(1, numcols - 1, pos, 6);\n module(2, numcols - 1, pos, 7);\n module(3, numcols - 1, pos, 8);\n }\n\n private void corner4(int pos) {\n module(numrows - 1, 0, pos, 1);\n module(numrows - 1, numcols - 1, pos, 2);\n module(0, numcols - 3, pos, 3);\n module(0, numcols - 2, pos, 4);\n module(0, numcols - 1, pos, 5);\n module(1, numcols - 3, pos, 6);\n module(1, numcols - 2, pos, 7);\n module(1, numcols - 1, pos, 8);\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/EdifactEncoder.java", "content": "/*\n * Copyright 2006-2007 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\nfinal class EdifactEncoder implements Encoder {\n\n @Override\n public int getEncodingMode() {\n return HighLevelEncoder.EDIFACT_ENCODATION;\n }\n\n @Override\n public void encode(EncoderContext context) {\n //step F\n StringBuilder buffer = new StringBuilder();\n while (context.hasMoreCharacters()) {\n char c = context.getCurrentChar();\n encodeChar(c, buffer);\n context.pos++;\n\n int count = buffer.length();\n if (count >= 4) {\n context.writeCodewords(encodeToCodewords(buffer, 0));\n buffer.delete(0, 4);\n\n int newMode = HighLevelEncoder.lookAheadTest(context.getMessage(), context.pos, getEncodingMode());\n if (newMode != getEncodingMode()) {\n // Return to ASCII encodation, which will actually handle latch to new mode\n context.signalEncoderChange(HighLevelEncoder.ASCII_ENCODATION);\n break;\n }\n }\n }\n buffer.append((char) 31); //Unlatch\n handleEOD(context, buffer);\n }\n\n /**\n * Handle \"end of data\" situations\n *\n * @param context the encoder context\n * @param buffer the buffer with the remaining encoded characters\n */\n private static void handleEOD(EncoderContext context, CharSequence buffer) {\n try {\n int count = buffer.length();\n if (count == 0) {\n return; //Already finished\n }\n if (count == 1) {\n //Only an unlatch at the end\n context.updateSymbolInfo();\n int available = context.getSymbolInfo().getDataCapacity() - context.getCodewordCount();\n int remaining = context.getRemainingCharacters();\n // The following two lines are a hack inspired by the 'fix' from https://sourceforge.net/p/barcode4j/svn/221/\n if (remaining > available) {\n context.updateSymbolInfo(context.getCodewordCount() + 1);\n available = context.getSymbolInfo().getDataCapacity() - context.getCodewordCount();\n }\n if (remaining <= available && available <= 2) {\n return; //No unlatch\n }\n }\n\n if (count > 4) {\n throw new IllegalStateException(\"Count must not exceed 4\");\n }\n int restChars = count - 1;\n String encoded = encodeToCodewords(buffer, 0);\n boolean endOfSymbolReached = !context.hasMoreCharacters();\n boolean restInAscii = endOfSymbolReached && restChars <= 2;\n\n if (restChars <= 2) {\n context.updateSymbolInfo(context.getCodewordCount() + restChars);\n int available = context.getSymbolInfo().getDataCapacity() - context.getCodewordCount();\n if (available >= 3) {\n restInAscii = false;\n context.updateSymbolInfo(context.getCodewordCount() + encoded.length());\n //available = context.symbolInfo.dataCapacity - context.getCodewordCount();\n }\n }\n\n if (restInAscii) {\n context.resetSymbolInfo();\n context.pos -= restChars;\n } else {\n context.writeCodewords(encoded);\n }\n } finally {\n context.signalEncoderChange(HighLevelEncoder.ASCII_ENCODATION);\n }\n }\n\n private static void encodeChar(char c, StringBuilder sb) {\n if (c >= ' ' && c <= '?') {\n sb.append(c);\n } else if (c >= '@' && c <= '^') {\n sb.append((char) (c - 64));\n } else {\n HighLevelEncoder.illegalCharacter(c);\n }\n }\n\n private static String encodeToCodewords(CharSequence sb, int startPos) {\n int len = sb.length() - startPos;\n if (len == 0) {\n throw new IllegalStateException(\"StringBuilder must not be empty\");\n }\n char c1 = sb.charAt(startPos);\n char c2 = len >= 2 ? sb.charAt(startPos + 1) : 0;\n char c3 = len >= 3 ? sb.charAt(startPos + 2) : 0;\n char c4 = len >= 4 ? sb.charAt(startPos + 3) : 0;\n\n int v = (c1 << 18) + (c2 << 12) + (c3 << 6) + c4;\n char cw1 = (char) ((v >> 16) & 255);\n char cw2 = (char) ((v >> 8) & 255);\n char cw3 = (char) (v & 255);\n StringBuilder res = new StringBuilder(3);\n res.append(cw1);\n if (len >= 2) {\n res.append(cw2);\n }\n if (len >= 3) {\n res.append(cw3);\n }\n return res.toString();\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/Encoder.java", "content": "/*\n * Copyright 2006-2007 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\ninterface Encoder {\n\n int getEncodingMode();\n\n void encode(EncoderContext context);\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/EncoderContext.java", "content": "/*\n * Copyright 2006-2007 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\nimport com.google.zxing.Dimension;\n\nimport java.nio.charset.StandardCharsets;\n\nfinal class EncoderContext {\n\n private final String msg;\n private SymbolShapeHint shape;\n private Dimension minSize;\n private Dimension maxSize;\n private final StringBuilder codewords;\n int pos;\n private int newEncoding;\n private SymbolInfo symbolInfo;\n private int skipAtEnd;\n\n EncoderContext(String msg) {\n //From this point on Strings are not Unicode anymore!\n byte[] msgBinary = msg.getBytes(StandardCharsets.ISO_8859_1);\n StringBuilder sb = new StringBuilder(msgBinary.length);\n for (int i = 0, c = msgBinary.length; i < c; i++) {\n char ch = (char) (msgBinary[i] & 0xff);\n if (ch == '?' && msg.charAt(i) != '?') {\n throw new IllegalArgumentException(\"Message contains characters outside ISO-8859-1 encoding.\");\n }\n sb.append(ch);\n }\n this.msg = sb.toString(); //Not Unicode here!\n shape = SymbolShapeHint.FORCE_NONE;\n this.codewords = new StringBuilder(msg.length());\n newEncoding = -1;\n }\n\n public void setSymbolShape(SymbolShapeHint shape) {\n this.shape = shape;\n }\n\n public void setSizeConstraints(Dimension minSize, Dimension maxSize) {\n this.minSize = minSize;\n this.maxSize = maxSize;\n }\n\n public String getMessage() {\n return this.msg;\n }\n\n public void setSkipAtEnd(int count) {\n this.skipAtEnd = count;\n }\n\n public char getCurrentChar() {\n return msg.charAt(pos);\n }\n\n public char getCurrent() {\n return msg.charAt(pos);\n }\n\n public StringBuilder getCodewords() {\n return codewords;\n }\n\n public void writeCodewords(String codewords) {\n this.codewords.append(codewords);\n }\n\n public void writeCodeword(char codeword) {\n this.codewords.append(codeword);\n }\n\n public int getCodewordCount() {\n return this.codewords.length();\n }\n\n public int getNewEncoding() {\n return newEncoding;\n }\n\n public void signalEncoderChange(int encoding) {\n this.newEncoding = encoding;\n }\n\n public void resetEncoderSignal() {\n this.newEncoding = -1;\n }\n\n public boolean hasMoreCharacters() {\n return pos < getTotalMessageCharCount();\n }\n\n private int getTotalMessageCharCount() {\n return msg.length() - skipAtEnd;\n }\n\n public int getRemainingCharacters() {\n return getTotalMessageCharCount() - pos;\n }\n\n public SymbolInfo getSymbolInfo() {\n return symbolInfo;\n }\n\n public void updateSymbolInfo() {\n updateSymbolInfo(getCodewordCount());\n }\n\n public void updateSymbolInfo(int len) {\n if (this.symbolInfo == null || len > this.symbolInfo.getDataCapacity()) {\n this.symbolInfo = SymbolInfo.lookup(len, shape, minSize, maxSize, true);\n }\n }\n\n public void resetSymbolInfo() {\n this.symbolInfo = null;\n }\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/ErrorCorrection.java", "content": "/*\n * Copyright 2006 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\n/**\n * Error Correction Code for ECC200.\n */\npublic final class ErrorCorrection {\n\n /**\n * Lookup table which factors to use for which number of error correction codewords.\n * See FACTORS.\n */\n private static final int[] FACTOR_SETS\n = {5, 7, 10, 11, 12, 14, 18, 20, 24, 28, 36, 42, 48, 56, 62, 68};\n\n /**\n * Precomputed polynomial factors for ECC 200.\n */\n private static final int[][] FACTORS = {\n {228, 48, 15, 111, 62},\n {23, 68, 144, 134, 240, 92, 254},\n {28, 24, 185, 166, 223, 248, 116, 255, 110, 61},\n {175, 138, 205, 12, 194, 168, 39, 245, 60, 97, 120},\n {41, 153, 158, 91, 61, 42, 142, 213, 97, 178, 100, 242},\n {156, 97, 192, 252, 95, 9, 157, 119, 138, 45, 18, 186, 83, 185},\n {83, 195, 100, 39, 188, 75, 66, 61, 241, 213, 109, 129, 94, 254, 225, 48, 90, 188},\n {15, 195, 244, 9, 233, 71, 168, 2, 188, 160, 153, 145, 253, 79, 108, 82, 27, 174, 186, 172},\n {52, 190, 88, 205, 109, 39, 176, 21, 155, 197, 251, 223, 155, 21, 5, 172,\n 254, 124, 12, 181, 184, 96, 50, 193},\n {211, 231, 43, 97, 71, 96, 103, 174, 37, 151, 170, 53, 75, 34, 249, 121,\n 17, 138, 110, 213, 141, 136, 120, 151, 233, 168, 93, 255},\n {245, 127, 242, 218, 130, 250, 162, 181, 102, 120, 84, 179, 220, 251, 80, 182,\n 229, 18, 2, 4, 68, 33, 101, 137, 95, 119, 115, 44, 175, 184, 59, 25,\n 225, 98, 81, 112},\n {77, 193, 137, 31, 19, 38, 22, 153, 247, 105, 122, 2, 245, 133, 242, 8,\n 175, 95, 100, 9, 167, 105, 214, 111, 57, 121, 21, 1, 253, 57, 54, 101,\n 248, 202, 69, 50, 150, 177, 226, 5, 9, 5},\n {245, 132, 172, 223, 96, 32, 117, 22, 238, 133, 238, 231, 205, 188, 237, 87,\n 191, 106, 16, 147, 118, 23, 37, 90, 170, 205, 131, 88, 120, 100, 66, 138,\n 186, 240, 82, 44, 176, 87, 187, 147, 160, 175, 69, 213, 92, 253, 225, 19},\n {175, 9, 223, 238, 12, 17, 220, 208, 100, 29, 175, 170, 230, 192, 215, 235,\n 150, 159, 36, 223, 38, 200, 132, 54, 228, 146, 218, 234, 117, 203, 29, 232,\n 144, 238, 22, 150, 201, 117, 62, 207, 164, 13, 137, 245, 127, 67, 247, 28,\n 155, 43, 203, 107, 233, 53, 143, 46},\n {242, 93, 169, 50, 144, 210, 39, 118, 202, 188, 201, 189, 143, 108, 196, 37,\n 185, 112, 134, 230, 245, 63, 197, 190, 250, 106, 185, 221, 175, 64, 114, 71,\n 161, 44, 147, 6, 27, 218, 51, 63, 87, 10, 40, 130, 188, 17, 163, 31,\n 176, 170, 4, 107, 232, 7, 94, 166, 224, 124, 86, 47, 11, 204},\n {220, 228, 173, 89, 251, 149, 159, 56, 89, 33, 147, 244, 154, 36, 73, 127,\n 213, 136, 248, 180, 234, 197, 158, 177, 68, 122, 93, 213, 15, 160, 227, 236,\n 66, 139, 153, 185, 202, 167, 179, 25, 220, 232, 96, 210, 231, 136, 223, 239,\n 181, 241, 59, 52, 172, 25, 49, 232, 211, 189, 64, 54, 108, 153, 132, 63,\n 96, 103, 82, 186}};\n\n private static final int MODULO_VALUE = 0x12D;\n\n private static final int[] LOG;\n private static final int[] ALOG;\n\n static {\n //Create log and antilog table\n LOG = new int[256];\n ALOG = new int[255];\n\n int p = 1;\n for (int i = 0; i < 255; i++) {\n ALOG[i] = p;\n LOG[p] = i;\n p *= 2;\n if (p >= 256) {\n p ^= MODULO_VALUE;\n }\n }\n }\n\n private ErrorCorrection() {\n }\n\n /**\n * Creates the ECC200 error correction for an encoded message.\n *\n * @param codewords the codewords\n * @param symbolInfo information about the symbol to be encoded\n * @return the codewords with interleaved error correction.\n */\n public static String encodeECC200(String codewords, SymbolInfo symbolInfo) {\n if (codewords.length() != symbolInfo.getDataCapacity()) {\n throw new IllegalArgumentException(\n \"The number of codewords does not match the selected symbol\");\n }\n StringBuilder sb = new StringBuilder(symbolInfo.getDataCapacity() + symbolInfo.getErrorCodewords());\n sb.append(codewords);\n int blockCount = symbolInfo.getInterleavedBlockCount();\n if (blockCount == 1) {\n String ecc = createECCBlock(codewords, symbolInfo.getErrorCodewords());\n sb.append(ecc);\n } else {\n sb.setLength(sb.capacity());\n int[] dataSizes = new int[blockCount];\n int[] errorSizes = new int[blockCount];\n int[] startPos = new int[blockCount];\n for (int i = 0; i < blockCount; i++) {\n dataSizes[i] = symbolInfo.getDataLengthForInterleavedBlock(i + 1);\n errorSizes[i] = symbolInfo.getErrorLengthForInterleavedBlock(i + 1);\n startPos[i] = 0;\n if (i > 0) {\n startPos[i] = startPos[i - 1] + dataSizes[i];\n }\n }\n for (int block = 0; block < blockCount; block++) {\n StringBuilder temp = new StringBuilder(dataSizes[block]);\n for (int d = block; d < symbolInfo.getDataCapacity(); d += blockCount) {\n temp.append(codewords.charAt(d));\n }\n String ecc = createECCBlock(temp.toString(), errorSizes[block]);\n int pos = 0;\n for (int e = block; e < errorSizes[block] * blockCount; e += blockCount) {\n sb.setCharAt(symbolInfo.getDataCapacity() + e, ecc.charAt(pos++));\n }\n }\n }\n return sb.toString();\n\n }\n\n private static String createECCBlock(CharSequence codewords, int numECWords) {\n return createECCBlock(codewords, 0, codewords.length(), numECWords);\n }\n\n private static String createECCBlock(CharSequence codewords, int start, int len, int numECWords) {\n int table = -1;\n for (int i = 0; i < FACTOR_SETS.length; i++) {\n if (FACTOR_SETS[i] == numECWords) {\n table = i;\n break;\n }\n }\n if (table < 0) {\n throw new IllegalArgumentException(\n \"Illegal number of error correction codewords specified: \" + numECWords);\n }\n int[] poly = FACTORS[table];\n char[] ecc = new char[numECWords];\n for (int i = 0; i < numECWords; i++) {\n ecc[i] = 0;\n }\n for (int i = start; i < start + len; i++) {\n int m = ecc[numECWords - 1] ^ codewords.charAt(i);\n for (int k = numECWords - 1; k > 0; k--) {\n if (m != 0 && poly[k] != 0) {\n ecc[k] = (char) (ecc[k - 1] ^ ALOG[(LOG[m] + LOG[poly[k]]) % 255]);\n } else {\n ecc[k] = ecc[k - 1];\n }\n }\n if (m != 0 && poly[0] != 0) {\n ecc[0] = (char) ALOG[(LOG[m] + LOG[poly[0]]) % 255];\n } else {\n ecc[0] = 0;\n }\n }\n char[] eccReversed = new char[numECWords];\n for (int i = 0; i < numECWords; i++) {\n eccReversed[i] = ecc[numECWords - i - 1];\n }\n return String.valueOf(eccReversed);\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/HighLevelEncoder.java", "content": "/*\n * Copyright 2006-2007 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\nimport com.google.zxing.Dimension;\n\nimport java.util.Arrays;\n\n/**\n * DataMatrix ECC 200 data encoder following the algorithm described in ISO/IEC 16022:200(E) in\n * annex S.\n */\npublic final class HighLevelEncoder {\n\n /**\n * Padding character\n */\n private static final char PAD = 129;\n /**\n * mode latch to C40 encodation mode\n */\n static final char LATCH_TO_C40 = 230;\n /**\n * mode latch to Base 256 encodation mode\n */\n static final char LATCH_TO_BASE256 = 231;\n /**\n * FNC1 Codeword\n */\n //private static final char FNC1 = 232;\n /**\n * Structured Append Codeword\n */\n //private static final char STRUCTURED_APPEND = 233;\n /**\n * Reader Programming\n */\n //private static final char READER_PROGRAMMING = 234;\n /**\n * Upper Shift\n */\n static final char UPPER_SHIFT = 235;\n /**\n * 05 Macro\n */\n private static final char MACRO_05 = 236;\n /**\n * 06 Macro\n */\n private static final char MACRO_06 = 237;\n /**\n * mode latch to ANSI X.12 encodation mode\n */\n static final char LATCH_TO_ANSIX12 = 238;\n /**\n * mode latch to Text encodation mode\n */\n static final char LATCH_TO_TEXT = 239;\n /**\n * mode latch to EDIFACT encodation mode\n */\n static final char LATCH_TO_EDIFACT = 240;\n /**\n * ECI character (Extended Channel Interpretation)\n */\n //private static final char ECI = 241;\n\n /**\n * Unlatch from C40 encodation\n */\n static final char C40_UNLATCH = 254;\n /**\n * Unlatch from X12 encodation\n */\n static final char X12_UNLATCH = 254;\n\n /**\n * 05 Macro header\n */\n private static final String MACRO_05_HEADER = \"[)>\\u001E05\\u001D\";\n /**\n * 06 Macro header\n */\n private static final String MACRO_06_HEADER = \"[)>\\u001E06\\u001D\";\n /**\n * Macro trailer\n */\n private static final String MACRO_TRAILER = \"\\u001E\\u0004\";\n\n static final int ASCII_ENCODATION = 0;\n static final int C40_ENCODATION = 1;\n static final int TEXT_ENCODATION = 2;\n static final int X12_ENCODATION = 3;\n static final int EDIFACT_ENCODATION = 4;\n static final int BASE256_ENCODATION = 5;\n\n private HighLevelEncoder() {\n }\n\n /*\n * Converts the message to a byte array using the default encoding (cp437) as defined by the\n * specification\n *\n * @param msg the message\n * @return the byte array of the message\n */\n\n /*\n public static byte[] getBytesForMessage(String msg) {\n return msg.getBytes(Charset.forName(\"cp437\")); //See 4.4.3 and annex B of ISO/IEC 15438:2001(E)\n }\n */\n\n private static char randomize253State(char ch, int codewordPosition) {\n int pseudoRandom = ((149 * codewordPosition) % 253) + 1;\n int tempVariable = ch + pseudoRandom;\n return (char) (tempVariable <= 254 ? tempVariable : tempVariable - 254);\n }\n\n /**\n * Performs message encoding of a DataMatrix message using the algorithm described in annex P\n * of ISO/IEC 16022:2000(E).\n *\n * @param msg the message\n * @return the encoded message (the char values range from 0 to 255)\n */\n public static String encodeHighLevel(String msg) {\n return encodeHighLevel(msg, SymbolShapeHint.FORCE_NONE, null, null);\n }\n\n /**\n * Performs message encoding of a DataMatrix message using the algorithm described in annex P\n * of ISO/IEC 16022:2000(E).\n *\n * @param msg the message\n * @param shape requested shape. May be {@code SymbolShapeHint.FORCE_NONE},\n * {@code SymbolShapeHint.FORCE_SQUARE} or {@code SymbolShapeHint.FORCE_RECTANGLE}.\n * @param minSize the minimum symbol size constraint or null for no constraint\n * @param maxSize the maximum symbol size constraint or null for no constraint\n * @return the encoded message (the char values range from 0 to 255)\n */\n public static String encodeHighLevel(String msg,\n SymbolShapeHint shape,\n Dimension minSize,\n Dimension maxSize) {\n //the codewords 0..255 are encoded as Unicode characters\n Encoder[] encoders = {\n new ASCIIEncoder(), new C40Encoder(), new TextEncoder(),\n new X12Encoder(), new EdifactEncoder(), new Base256Encoder()\n };\n\n EncoderContext context = new EncoderContext(msg);\n context.setSymbolShape(shape);\n context.setSizeConstraints(minSize, maxSize);\n\n if (msg.startsWith(MACRO_05_HEADER) && msg.endsWith(MACRO_TRAILER)) {\n context.writeCodeword(MACRO_05);\n context.setSkipAtEnd(2);\n context.pos += MACRO_05_HEADER.length();\n } else if (msg.startsWith(MACRO_06_HEADER) && msg.endsWith(MACRO_TRAILER)) {\n context.writeCodeword(MACRO_06);\n context.setSkipAtEnd(2);\n context.pos += MACRO_06_HEADER.length();\n }\n\n int encodingMode = ASCII_ENCODATION; //Default mode\n while (context.hasMoreCharacters()) {\n encoders[encodingMode].encode(context);\n if (context.getNewEncoding() >= 0) {\n encodingMode = context.getNewEncoding();\n context.resetEncoderSignal();\n }\n }\n int len = context.getCodewordCount();\n context.updateSymbolInfo();\n int capacity = context.getSymbolInfo().getDataCapacity();\n if (len < capacity &&\n encodingMode != ASCII_ENCODATION &&\n encodingMode != BASE256_ENCODATION &&\n encodingMode != EDIFACT_ENCODATION) {\n context.writeCodeword('\\u00fe'); //Unlatch (254)\n }\n //Padding\n StringBuilder codewords = context.getCodewords();\n if (codewords.length() < capacity) {\n codewords.append(PAD);\n }\n while (codewords.length() < capacity) {\n codewords.append(randomize253State(PAD, codewords.length() + 1));\n }\n\n return context.getCodewords().toString();\n }\n\n static int lookAheadTest(CharSequence msg, int startpos, int currentMode) {\n if (startpos >= msg.length()) {\n return currentMode;\n }\n float[] charCounts;\n //step J\n if (currentMode == ASCII_ENCODATION) {\n charCounts = new float[]{0, 1, 1, 1, 1, 1.25f};\n } else {\n charCounts = new float[]{1, 2, 2, 2, 2, 2.25f};\n charCounts[currentMode] = 0;\n }\n\n int charsProcessed = 0;\n while (true) {\n //step K\n if ((startpos + charsProcessed) == msg.length()) {\n int min = Integer.MAX_VALUE;\n byte[] mins = new byte[6];\n int[] intCharCounts = new int[6];\n min = findMinimums(charCounts, intCharCounts, min, mins);\n int minCount = getMinimumCount(mins);\n\n if (intCharCounts[ASCII_ENCODATION] == min) {\n return ASCII_ENCODATION;\n }\n if (minCount == 1 && mins[BASE256_ENCODATION] > 0) {\n return BASE256_ENCODATION;\n }\n if (minCount == 1 && mins[EDIFACT_ENCODATION] > 0) {\n return EDIFACT_ENCODATION;\n }\n if (minCount == 1 && mins[TEXT_ENCODATION] > 0) {\n return TEXT_ENCODATION;\n }\n if (minCount == 1 && mins[X12_ENCODATION] > 0) {\n return X12_ENCODATION;\n }\n return C40_ENCODATION;\n }\n\n char c = msg.charAt(startpos + charsProcessed);\n charsProcessed++;\n\n //step L\n if (isDigit(c)) {\n charCounts[ASCII_ENCODATION] += 0.5f;\n } else if (isExtendedASCII(c)) {\n charCounts[ASCII_ENCODATION] = (float) Math.ceil(charCounts[ASCII_ENCODATION]);\n charCounts[ASCII_ENCODATION] += 2.0f;\n } else {\n charCounts[ASCII_ENCODATION] = (float) Math.ceil(charCounts[ASCII_ENCODATION]);\n charCounts[ASCII_ENCODATION]++;\n }\n\n //step M\n if (isNativeC40(c)) {\n charCounts[C40_ENCODATION] += 2.0f / 3.0f;\n } else if (isExtendedASCII(c)) {\n charCounts[C40_ENCODATION] += 8.0f / 3.0f;\n } else {\n charCounts[C40_ENCODATION] += 4.0f / 3.0f;\n }\n\n //step N\n if (isNativeText(c)) {\n charCounts[TEXT_ENCODATION] += 2.0f / 3.0f;\n } else if (isExtendedASCII(c)) {\n charCounts[TEXT_ENCODATION] += 8.0f / 3.0f;\n } else {\n charCounts[TEXT_ENCODATION] += 4.0f / 3.0f;\n }\n\n //step O\n if (isNativeX12(c)) {\n charCounts[X12_ENCODATION] += 2.0f / 3.0f;\n } else if (isExtendedASCII(c)) {\n charCounts[X12_ENCODATION] += 13.0f / 3.0f;\n } else {\n charCounts[X12_ENCODATION] += 10.0f / 3.0f;\n }\n\n //step P\n if (isNativeEDIFACT(c)) {\n charCounts[EDIFACT_ENCODATION] += 3.0f / 4.0f;\n } else if (isExtendedASCII(c)) {\n charCounts[EDIFACT_ENCODATION] += 17.0f / 4.0f;\n } else {\n charCounts[EDIFACT_ENCODATION] += 13.0f / 4.0f;\n }\n\n // step Q\n if (isSpecialB256(c)) {\n charCounts[BASE256_ENCODATION] += 4.0f;\n } else {\n charCounts[BASE256_ENCODATION]++;\n }\n\n //step R\n if (charsProcessed >= 4) {\n int[] intCharCounts = new int[6];\n byte[] mins = new byte[6];\n findMinimums(charCounts, intCharCounts, Integer.MAX_VALUE, mins);\n int minCount = getMinimumCount(mins);\n\n if (intCharCounts[ASCII_ENCODATION] < intCharCounts[BASE256_ENCODATION]\n && intCharCounts[ASCII_ENCODATION] < intCharCounts[C40_ENCODATION]\n && intCharCounts[ASCII_ENCODATION] < intCharCounts[TEXT_ENCODATION]\n && intCharCounts[ASCII_ENCODATION] < intCharCounts[X12_ENCODATION]\n && intCharCounts[ASCII_ENCODATION] < intCharCounts[EDIFACT_ENCODATION]) {\n return ASCII_ENCODATION;\n }\n if (intCharCounts[BASE256_ENCODATION] < intCharCounts[ASCII_ENCODATION]\n || (mins[C40_ENCODATION] + mins[TEXT_ENCODATION] + mins[X12_ENCODATION] + mins[EDIFACT_ENCODATION]) == 0) {\n return BASE256_ENCODATION;\n }\n if (minCount == 1 && mins[EDIFACT_ENCODATION] > 0) {\n return EDIFACT_ENCODATION;\n }\n if (minCount == 1 && mins[TEXT_ENCODATION] > 0) {\n return TEXT_ENCODATION;\n }\n if (minCount == 1 && mins[X12_ENCODATION] > 0) {\n return X12_ENCODATION;\n }\n if (intCharCounts[C40_ENCODATION] + 1 < intCharCounts[ASCII_ENCODATION]\n && intCharCounts[C40_ENCODATION] + 1 < intCharCounts[BASE256_ENCODATION]\n && intCharCounts[C40_ENCODATION] + 1 < intCharCounts[EDIFACT_ENCODATION]\n && intCharCounts[C40_ENCODATION] + 1 < intCharCounts[TEXT_ENCODATION]) {\n if (intCharCounts[C40_ENCODATION] < intCharCounts[X12_ENCODATION]) {\n return C40_ENCODATION;\n }\n if (intCharCounts[C40_ENCODATION] == intCharCounts[X12_ENCODATION]) {\n int p = startpos + charsProcessed + 1;\n while (p < msg.length()) {\n char tc = msg.charAt(p);\n if (isX12TermSep(tc)) {\n return X12_ENCODATION;\n }\n if (!isNativeX12(tc)) {\n break;\n }\n p++;\n }\n return C40_ENCODATION;\n }\n }\n }\n }\n }\n\n private static int findMinimums(float[] charCounts, int[] intCharCounts, int min, byte[] mins) {\n Arrays.fill(mins, (byte) 0);\n for (int i = 0; i < 6; i++) {\n intCharCounts[i] = (int) Math.ceil(charCounts[i]);\n int current = intCharCounts[i];\n if (min > current) {\n min = current;\n Arrays.fill(mins, (byte) 0);\n }\n if (min == current) {\n mins[i]++;\n\n }\n }\n return min;\n }\n\n private static int getMinimumCount(byte[] mins) {\n int minCount = 0;\n for (int i = 0; i < 6; i++) {\n minCount += mins[i];\n }\n return minCount;\n }\n\n static boolean isDigit(char ch) {\n return ch >= '0' && ch <= '9';\n }\n\n static boolean isExtendedASCII(char ch) {\n return ch >= 128 && ch <= 255;\n }\n\n private static boolean isNativeC40(char ch) {\n return (ch == ' ') || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z');\n }\n\n private static boolean isNativeText(char ch) {\n return (ch == ' ') || (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z');\n }\n\n private static boolean isNativeX12(char ch) {\n return isX12TermSep(ch) || (ch == ' ') || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z');\n }\n\n private static boolean isX12TermSep(char ch) {\n return (ch == '\\r') //CR\n || (ch == '*')\n || (ch == '>');\n }\n\n private static boolean isNativeEDIFACT(char ch) {\n return ch >= ' ' && ch <= '^';\n }\n\n private static boolean isSpecialB256(char ch) {\n return false; //TODO NOT IMPLEMENTED YET!!!\n }\n\n /**\n * Determines the number of consecutive characters that are encodable using numeric compaction.\n *\n * @param msg the message\n * @param startpos the start position within the message\n * @return the requested character count\n */\n public static int determineConsecutiveDigitCount(CharSequence msg, int startpos) {\n int count = 0;\n int len = msg.length();\n int idx = startpos;\n if (idx < len) {\n char ch = msg.charAt(idx);\n while (isDigit(ch) && idx < len) {\n count++;\n idx++;\n if (idx < len) {\n ch = msg.charAt(idx);\n }\n }\n }\n return count;\n }\n\n static void illegalCharacter(char c) {\n String hex = Integer.toHexString(c);\n hex = \"0000\".substring(0, 4 - hex.length()) + hex;\n throw new IllegalArgumentException(\"Illegal character: \" + c + \" (0x\" + hex + ')');\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/SymbolInfo.java", "content": "/*\n * Copyright 2006 Jeremias Maerki\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\nimport com.google.zxing.Dimension;\n\n/**\n * Symbol info table for DataMatrix.\n *\n * @version $Id$\n */\npublic class SymbolInfo {\n\n static final SymbolInfo[] PROD_SYMBOLS = {\n new SymbolInfo(false, 3, 5, 8, 8, 1),\n new SymbolInfo(false, 5, 7, 10, 10, 1),\n /*rect*/new SymbolInfo(true, 5, 7, 16, 6, 1),\n new SymbolInfo(false, 8, 10, 12, 12, 1),\n /*rect*/new SymbolInfo(true, 10, 11, 14, 6, 2),\n new SymbolInfo(false, 12, 12, 14, 14, 1),\n /*rect*/new SymbolInfo(true, 16, 14, 24, 10, 1),\n\n new SymbolInfo(false, 18, 14, 16, 16, 1),\n new SymbolInfo(false, 22, 18, 18, 18, 1),\n /*rect*/new SymbolInfo(true, 22, 18, 16, 10, 2),\n new SymbolInfo(false, 30, 20, 20, 20, 1),\n /*rect*/new SymbolInfo(true, 32, 24, 16, 14, 2),\n new SymbolInfo(false, 36, 24, 22, 22, 1),\n new SymbolInfo(false, 44, 28, 24, 24, 1),\n /*rect*/new SymbolInfo(true, 49, 28, 22, 14, 2),\n\n new SymbolInfo(false, 62, 36, 14, 14, 4),\n new SymbolInfo(false, 86, 42, 16, 16, 4),\n new SymbolInfo(false, 114, 48, 18, 18, 4),\n new SymbolInfo(false, 144, 56, 20, 20, 4),\n new SymbolInfo(false, 174, 68, 22, 22, 4),\n\n new SymbolInfo(false, 204, 84, 24, 24, 4, 102, 42),\n new SymbolInfo(false, 280, 112, 14, 14, 16, 140, 56),\n new SymbolInfo(false, 368, 144, 16, 16, 16, 92, 36),\n new SymbolInfo(false, 456, 192, 18, 18, 16, 114, 48),\n new SymbolInfo(false, 576, 224, 20, 20, 16, 144, 56),\n new SymbolInfo(false, 696, 272, 22, 22, 16, 174, 68),\n new SymbolInfo(false, 816, 336, 24, 24, 16, 136, 56),\n new SymbolInfo(false, 1050, 408, 18, 18, 36, 175, 68),\n new SymbolInfo(false, 1304, 496, 20, 20, 36, 163, 62),\n new DataMatrixSymbolInfo144(),\n };\n\n private static SymbolInfo[] symbols = PROD_SYMBOLS;\n\n private final boolean rectangular;\n private final int dataCapacity;\n private final int errorCodewords;\n public final int matrixWidth;\n public final int matrixHeight;\n private final int dataRegions;\n private final int rsBlockData;\n private final int rsBlockError;\n\n /**\n * Overrides the symbol info set used by this class. Used for testing purposes.\n *\n * @param override the symbol info set to use\n */\n public static void overrideSymbolSet(SymbolInfo[] override) {\n symbols = override;\n }\n\n public SymbolInfo(boolean rectangular, int dataCapacity, int errorCodewords,\n int matrixWidth, int matrixHeight, int dataRegions) {\n this(rectangular, dataCapacity, errorCodewords, matrixWidth, matrixHeight, dataRegions,\n dataCapacity, errorCodewords);\n }\n\n SymbolInfo(boolean rectangular, int dataCapacity, int errorCodewords,\n int matrixWidth, int matrixHeight, int dataRegions,\n int rsBlockData, int rsBlockError) {\n this.rectangular = rectangular;\n this.dataCapacity = dataCapacity;\n this.errorCodewords = errorCodewords;\n this.matrixWidth = matrixWidth;\n this.matrixHeight = matrixHeight;\n this.dataRegions = dataRegions;\n this.rsBlockData = rsBlockData;\n this.rsBlockError = rsBlockError;\n }\n\n public static SymbolInfo lookup(int dataCodewords) {\n return lookup(dataCodewords, SymbolShapeHint.FORCE_NONE, true);\n }\n\n public static SymbolInfo lookup(int dataCodewords, SymbolShapeHint shape) {\n return lookup(dataCodewords, shape, true);\n }\n\n public static SymbolInfo lookup(int dataCodewords, boolean allowRectangular, boolean fail) {\n SymbolShapeHint shape = allowRectangular\n ? SymbolShapeHint.FORCE_NONE : SymbolShapeHint.FORCE_SQUARE;\n return lookup(dataCodewords, shape, fail);\n }\n\n private static SymbolInfo lookup(int dataCodewords, SymbolShapeHint shape, boolean fail) {\n return lookup(dataCodewords, shape, null, null, fail);\n }\n\n public static SymbolInfo lookup(int dataCodewords,\n SymbolShapeHint shape,\n Dimension minSize,\n Dimension maxSize,\n boolean fail) {\n for (SymbolInfo symbol : symbols) {\n if (shape == SymbolShapeHint.FORCE_SQUARE && symbol.rectangular) {\n continue;\n }\n if (shape == SymbolShapeHint.FORCE_RECTANGLE && !symbol.rectangular) {\n continue;\n }\n if (minSize != null\n && (symbol.getSymbolWidth() < minSize.getWidth()\n || symbol.getSymbolHeight() < minSize.getHeight())) {\n continue;\n }\n if (maxSize != null\n && (symbol.getSymbolWidth() > maxSize.getWidth()\n || symbol.getSymbolHeight() > maxSize.getHeight())) {\n continue;\n }\n if (dataCodewords <= symbol.dataCapacity) {\n return symbol;\n }\n }\n if (fail) {\n throw new IllegalArgumentException(\n \"Can't find a symbol arrangement that matches the message. Data codewords: \"\n + dataCodewords);\n }\n return null;\n }\n\n private int getHorizontalDataRegions() {\n switch (dataRegions) {\n case 1:\n return 1;\n case 2:\n case 4:\n return 2;\n case 16:\n return 4;\n case 36:\n return 6;\n default:\n throw new IllegalStateException(\"Cannot handle this number of data regions\");\n }\n }\n\n private int getVerticalDataRegions() {\n switch (dataRegions) {\n case 1:\n case 2:\n return 1;\n case 4:\n return 2;\n case 16:\n return 4;\n case 36:\n return 6;\n default:\n throw new IllegalStateException(\"Cannot handle this number of data regions\");\n }\n }\n\n public final int getSymbolDataWidth() {\n return getHorizontalDataRegions() * matrixWidth;\n }\n\n public final int getSymbolDataHeight() {\n return getVerticalDataRegions() * matrixHeight;\n }\n\n public final int getSymbolWidth() {\n return getSymbolDataWidth() + (getHorizontalDataRegions() * 2);\n }\n\n public final int getSymbolHeight() {\n return getSymbolDataHeight() + (getVerticalDataRegions() * 2);\n }\n\n public int getCodewordCount() {\n return dataCapacity + errorCodewords;\n }\n\n public int getInterleavedBlockCount() {\n return dataCapacity / rsBlockData;\n }\n\n public final int getDataCapacity() {\n return dataCapacity;\n }\n\n public final int getErrorCodewords() {\n return errorCodewords;\n }\n\n public int getDataLengthForInterleavedBlock(int index) {\n return rsBlockData;\n }\n\n public final int getErrorLengthForInterleavedBlock(int index) {\n return rsBlockError;\n }\n\n @Override\n public final String toString() {\n return (rectangular ? \"Rectangular Symbol:\" : \"Square Symbol:\") +\n \" data region \" + matrixWidth + 'x' + matrixHeight +\n \", symbol size \" + getSymbolWidth() + 'x' + getSymbolHeight() +\n \", symbol data size \" + getSymbolDataWidth() + 'x' + getSymbolDataHeight() +\n \", codewords \" + dataCapacity + '+' + errorCodewords;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/SymbolShapeHint.java", "content": "/*\n * Copyright 2007 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\n/**\n * Enumeration for DataMatrix symbol shape hint. It can be used to force square or rectangular\n * symbols.\n */\npublic enum SymbolShapeHint {\n\n FORCE_NONE,\n FORCE_SQUARE,\n FORCE_RECTANGLE,\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/TextEncoder.java", "content": "/*\n * Copyright 2006-2007 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\nfinal class TextEncoder extends C40Encoder {\n\n @Override\n public int getEncodingMode() {\n return HighLevelEncoder.TEXT_ENCODATION;\n }\n\n @Override\n int encodeChar(char c, StringBuilder sb) {\n if (c == ' ') {\n sb.append('\\3');\n return 1;\n }\n if (c >= '0' && c <= '9') {\n sb.append((char) (c - 48 + 4));\n return 1;\n }\n if (c >= 'a' && c <= 'z') {\n sb.append((char) (c - 97 + 14));\n return 1;\n }\n if (c < ' ') {\n sb.append('\\0'); //Shift 1 Set\n sb.append(c);\n return 2;\n }\n if (c >= '!' && c <= '/') {\n sb.append('\\1'); //Shift 2 Set\n sb.append((char) (c - 33));\n return 2;\n }\n if (c >= ':' && c <= '@') {\n sb.append('\\1'); //Shift 2 Set\n sb.append((char) (c - 58 + 15));\n return 2;\n }\n if (c >= '[' && c <= '_') {\n sb.append('\\1'); //Shift 2 Set\n sb.append((char) (c - 91 + 22));\n return 2;\n }\n if (c == '`') {\n sb.append('\\2'); //Shift 3 Set\n sb.append((char) (c - 96));\n return 2;\n }\n if (c >= 'A' && c <= 'Z') {\n sb.append('\\2'); //Shift 3 Set\n sb.append((char) (c - 65 + 1));\n return 2;\n }\n if (c >= '{' && c <= 127) {\n sb.append('\\2'); //Shift 3 Set\n sb.append((char) (c - 123 + 27));\n return 2;\n }\n sb.append(\"\\1\\u001e\"); //Shift 2, Upper Shift\n int len = 2;\n len += encodeChar((char) (c - 128), sb);\n return len;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/datamatrix/encoder/X12Encoder.java", "content": "/*\n * Copyright 2006-2007 Jeremias Maerki.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.datamatrix.encoder;\n\nfinal class X12Encoder extends C40Encoder {\n\n @Override\n public int getEncodingMode() {\n return HighLevelEncoder.X12_ENCODATION;\n }\n\n @Override\n public void encode(EncoderContext context) {\n //step C\n StringBuilder buffer = new StringBuilder();\n while (context.hasMoreCharacters()) {\n char c = context.getCurrentChar();\n context.pos++;\n\n encodeChar(c, buffer);\n\n int count = buffer.length();\n if ((count % 3) == 0) {\n writeNextTriplet(context, buffer);\n\n int newMode = HighLevelEncoder.lookAheadTest(context.getMessage(), context.pos, getEncodingMode());\n if (newMode != getEncodingMode()) {\n // Return to ASCII encodation, which will actually handle latch to new mode\n context.signalEncoderChange(HighLevelEncoder.ASCII_ENCODATION);\n break;\n }\n }\n }\n handleEOD(context, buffer);\n }\n\n @Override\n int encodeChar(char c, StringBuilder sb) {\n switch (c) {\n case '\\r':\n sb.append('\\0');\n break;\n case '*':\n sb.append('\\1');\n break;\n case '>':\n sb.append('\\2');\n break;\n case ' ':\n sb.append('\\3');\n break;\n default:\n if (c >= '0' && c <= '9') {\n sb.append((char) (c - 48 + 4));\n } else if (c >= 'A' && c <= 'Z') {\n sb.append((char) (c - 65 + 14));\n } else {\n HighLevelEncoder.illegalCharacter(c);\n }\n break;\n }\n return 1;\n }\n\n @Override\n void handleEOD(EncoderContext context, StringBuilder buffer) {\n context.updateSymbolInfo();\n int available = context.getSymbolInfo().getDataCapacity() - context.getCodewordCount();\n int count = buffer.length();\n context.pos -= count;\n if (context.getRemainingCharacters() > 1 || available > 1 ||\n context.getRemainingCharacters() != available) {\n context.writeCodeword(HighLevelEncoder.X12_UNLATCH);\n }\n if (context.getNewEncoding() < 0) {\n context.signalEncoderChange(HighLevelEncoder.ASCII_ENCODATION);\n }\n }\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/maxicode/MaxiCodeReader.java", "content": "/*\n * Copyright 2011 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.maxicode;\n\nimport com.google.zxing.BarcodeFormat;\nimport com.google.zxing.BinaryBitmap;\nimport com.google.zxing.ChecksumException;\nimport com.google.zxing.DecodeHintType;\nimport com.google.zxing.FormatException;\nimport com.google.zxing.NotFoundException;\nimport com.google.zxing.Reader;\nimport com.google.zxing.Result;\nimport com.google.zxing.ResultMetadataType;\nimport com.google.zxing.ResultPoint;\nimport com.google.zxing.common.BitMatrix;\nimport com.google.zxing.common.DecoderResult;\nimport com.google.zxing.maxicode.decoder.Decoder;\n\nimport java.util.Map;\n\n/**\n * This implementation can detect and decode a MaxiCode in an image.\n */\npublic final class MaxiCodeReader implements Reader {\n\n private static final ResultPoint[] NO_POINTS = new ResultPoint[0];\n private static final int MATRIX_WIDTH = 30;\n private static final int MATRIX_HEIGHT = 33;\n\n private final Decoder decoder = new Decoder();\n\n /**\n * Locates and decodes a MaxiCode in an image.\n *\n * @return a String representing the content encoded by the MaxiCode\n * @throws NotFoundException if a MaxiCode cannot be found\n * @throws FormatException if a MaxiCode cannot be decoded\n * @throws ChecksumException if error correction fails\n */\n @Override\n public Result decode(BinaryBitmap image) throws NotFoundException, ChecksumException, FormatException {\n return decode(image, null);\n }\n\n @Override\n public Result decode(BinaryBitmap image, MapMaxiCodes can encode text or structured information as bits in one of several modes,\n * with multiple character sets in one code. This class decodes the bits back into text.
\n *\n * @author mike32767\n * @author Manuel Kasten\n */\nfinal class DecodedBitStreamParser {\n\n private static final char SHIFTA = '\\uFFF0';\n private static final char SHIFTB = '\\uFFF1';\n private static final char SHIFTC = '\\uFFF2';\n private static final char SHIFTD = '\\uFFF3';\n private static final char SHIFTE = '\\uFFF4';\n private static final char TWOSHIFTA = '\\uFFF5';\n private static final char THREESHIFTA = '\\uFFF6';\n private static final char LATCHA = '\\uFFF7';\n private static final char LATCHB = '\\uFFF8';\n private static final char LOCK = '\\uFFF9';\n private static final char ECI = '\\uFFFA';\n private static final char NS = '\\uFFFB';\n private static final char PAD = '\\uFFFC';\n private static final char FS = '\\u001C';\n private static final char GS = '\\u001D';\n private static final char RS = '\\u001E';\n\n private static final String[] SETS = {\n \"\\nABCDEFGHIJKLMNOPQRSTUVWXYZ\" + ECI + FS + GS + RS + NS + ' ' + PAD +\n \"\\\"#$%&'()*+,-./0123456789:\" + SHIFTB + SHIFTC + SHIFTD + SHIFTE + LATCHB,\n \"`abcdefghijklmnopqrstuvwxyz\" + ECI + FS + GS + RS + NS + '{' + PAD +\n \"}~\\u007F;<=>?[\\\\]^_ ,./:@!|\" + PAD + TWOSHIFTA + THREESHIFTA + PAD +\n SHIFTA + SHIFTC + SHIFTD + SHIFTE + LATCHA,\n \"\\u00C0\\u00C1\\u00C2\\u00C3\\u00C4\\u00C5\\u00C6\\u00C7\\u00C8\\u00C9\\u00CA\\u00CB\\u00CC\\u00CD\\u00CE\\u00CF\\u00D0\\u00D1\\u00D2\\u00D3\\u00D4\\u00D5\\u00D6\\u00D7\\u00D8\\u00D9\\u00DA\" +\n ECI + FS + GS + RS +\n \"\\u00DB\\u00DC\\u00DD\\u00DE\\u00DF\\u00AA\\u00AC\\u00B1\\u00B2\\u00B3\\u00B5\\u00B9\\u00BA\\u00BC\\u00BD\\u00BE\\u0080\\u0081\\u0082\\u0083\\u0084\\u0085\\u0086\\u0087\\u0088\\u0089\" +\n LATCHA + ' ' + LOCK + SHIFTD + SHIFTE + LATCHB,\n \"\\u00E0\\u00E1\\u00E2\\u00E3\\u00E4\\u00E5\\u00E6\\u00E7\\u00E8\\u00E9\\u00EA\\u00EB\\u00EC\\u00ED\\u00EE\\u00EF\\u00F0\\u00F1\\u00F2\\u00F3\\u00F4\\u00F5\\u00F6\\u00F7\\u00F8\\u00F9\\u00FA\" +\n ECI + FS + GS + RS + NS +\n \"\\u00FB\\u00FC\\u00FD\\u00FE\\u00FF\\u00A1\\u00A8\\u00AB\\u00AF\\u00B0\\u00B4\\u00B7\\u00B8\\u00BB\\u00BF\\u008A\\u008B\\u008C\\u008D\\u008E\\u008F\\u0090\\u0091\\u0092\\u0093\\u0094\" +\n LATCHA + ' ' + SHIFTC + LOCK + SHIFTE + LATCHB,\n \"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\u0008\\u0009\\n\\u000B\\u000C\\r\\u000E\\u000F\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001A\" +\n ECI + PAD + PAD + '\\u001B' + NS + FS + GS + RS +\n \"\\u001F\\u009F\\u00A0\\u00A2\\u00A3\\u00A4\\u00A5\\u00A6\\u00A7\\u00A9\\u00AD\\u00AE\\u00B6\\u0095\\u0096\\u0097\\u0098\\u0099\\u009A\\u009B\\u009C\\u009D\\u009E\" +\n LATCHA + ' ' + SHIFTC + SHIFTD + LOCK + LATCHB,\n \"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\u0008\\u0009\\n\\u000B\\u000C\\r\\u000E\\u000F\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001A\\u001B\\u001C\\u001D\\u001E\\u001F\\u0020\\u0021\\\"\\u0023\\u0024\\u0025\\u0026\\u0027\\u0028\\u0029\\u002A\\u002B\\u002C\\u002D\\u002E\\u002F\\u0030\\u0031\\u0032\\u0033\\u0034\\u0035\\u0036\\u0037\\u0038\\u0039\\u003A\\u003B\\u003C\\u003D\\u003E\\u003F\"\n };\n\n private DecodedBitStreamParser() {\n }\n\n static DecoderResult decode(byte[] bytes, int mode) {\n StringBuilder result = new StringBuilder(144);\n switch (mode) {\n case 2:\n case 3:\n String postcode;\n if (mode == 2) {\n int pc = getPostCode2(bytes);\n NumberFormat df = new DecimalFormat(\"0000000000\".substring(0, getPostCode2Length(bytes)));\n postcode = df.format(pc);\n } else {\n postcode = getPostCode3(bytes);\n }\n NumberFormat threeDigits = new DecimalFormat(\"000\");\n String country = threeDigits.format(getCountry(bytes));\n String service = threeDigits.format(getServiceClass(bytes));\n result.append(getMessage(bytes, 10, 84));\n if (result.toString().startsWith(\"[)>\" + RS + \"01\" + GS)) {\n result.insert(9, postcode + GS + country + GS + service + GS);\n } else {\n result.insert(0, postcode + GS + country + GS + service + GS);\n }\n break;\n case 4:\n result.append(getMessage(bytes, 1, 93));\n break;\n case 5:\n result.append(getMessage(bytes, 1, 77));\n break;\n }\n return new DecoderResult(bytes, result.toString(), null, String.valueOf(mode));\n }\n\n private static int getBit(int bit, byte[] bytes) {\n bit--;\n return (bytes[bit / 6] & (1 << (5 - (bit % 6)))) == 0 ? 0 : 1;\n }\n\n private static int getInt(byte[] bytes, byte[] x) {\n if (x.length == 0) {\n throw new IllegalArgumentException();\n }\n int val = 0;\n for (int i = 0; i < x.length; i++) {\n val += getBit(x[i], bytes) << (x.length - i - 1);\n }\n return val;\n }\n\n private static int getCountry(byte[] bytes) {\n return getInt(bytes, new byte[] {53, 54, 43, 44, 45, 46, 47, 48, 37, 38});\n }\n\n private static int getServiceClass(byte[] bytes) {\n return getInt(bytes, new byte[] {55, 56, 57, 58, 59, 60, 49, 50, 51, 52});\n }\n\n private static int getPostCode2Length(byte[] bytes) {\n return getInt(bytes, new byte[] {39, 40, 41, 42, 31, 32});\n }\n\n private static int getPostCode2(byte[] bytes) {\n return getInt(bytes, new byte[] {33, 34, 35, 36, 25, 26, 27, 28, 29, 30, 19,\n 20, 21, 22, 23, 24, 13, 14, 15, 16, 17, 18, 7, 8, 9, 10, 11, 12, 1, 2});\n }\n\n private static String getPostCode3(byte[] bytes) {\n return String.valueOf(\n new char[] {\n SETS[0].charAt(getInt(bytes, new byte[] {39, 40, 41, 42, 31, 32})),\n SETS[0].charAt(getInt(bytes, new byte[] {33, 34, 35, 36, 25, 26})),\n SETS[0].charAt(getInt(bytes, new byte[] {27, 28, 29, 30, 19, 20})),\n SETS[0].charAt(getInt(bytes, new byte[] {21, 22, 23, 24, 13, 14})),\n SETS[0].charAt(getInt(bytes, new byte[] {15, 16, 17, 18, 7, 8})),\n SETS[0].charAt(getInt(bytes, new byte[] { 9, 10, 11, 12, 1, 2})),\n }\n );\n }\n\n private static String getMessage(byte[] bytes, int start, int len) {\n StringBuilder sb = new StringBuilder();\n int shift = -1;\n int set = 0;\n int lastset = 0;\n for (int i = start; i < start + len; i++) {\n char c = SETS[set].charAt(bytes[i]);\n switch (c) {\n case LATCHA:\n set = 0;\n shift = -1;\n break;\n case LATCHB:\n set = 1;\n shift = -1;\n break;\n case SHIFTA:\n case SHIFTB:\n case SHIFTC:\n case SHIFTD:\n case SHIFTE:\n lastset = set;\n set = c - SHIFTA;\n shift = 1;\n break;\n case TWOSHIFTA:\n lastset = set;\n set = 0;\n shift = 2;\n break;\n case THREESHIFTA:\n lastset = set;\n set = 0;\n shift = 3;\n break;\n case NS:\n int nsval = (bytes[++i] << 24) + (bytes[++i] << 18) + (bytes[++i] << 12) + (bytes[++i] << 6) + bytes[++i];\n sb.append(new DecimalFormat(\"000000000\").format(nsval));\n break;\n case LOCK:\n shift = -1;\n break;\n default:\n sb.append(c);\n }\n if (shift-- == 0) {\n set = lastset;\n }\n }\n while (sb.length() > 0 && sb.charAt(sb.length() - 1) == PAD) {\n sb.setLength(sb.length() - 1);\n }\n return sb.toString();\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/maxicode/decoder/Decoder.java", "content": "/*\n * Copyright 2011 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.maxicode.decoder;\n\nimport com.google.zxing.ChecksumException;\nimport com.google.zxing.DecodeHintType;\nimport com.google.zxing.FormatException;\nimport com.google.zxing.common.BitMatrix;\nimport com.google.zxing.common.DecoderResult;\nimport com.google.zxing.common.reedsolomon.GenericGF;\nimport com.google.zxing.common.reedsolomon.ReedSolomonDecoder;\nimport com.google.zxing.common.reedsolomon.ReedSolomonException;\n\nimport java.util.Map;\n\n/**\n *The main class which implements MaxiCode decoding -- as opposed to locating and extracting\n * the MaxiCode from an image.
\n *\n * @author Manuel Kasten\n */\npublic final class Decoder {\n\n private static final int ALL = 0;\n private static final int EVEN = 1;\n private static final int ODD = 2;\n\n private final ReedSolomonDecoder rsDecoder;\n\n public Decoder() {\n rsDecoder = new ReedSolomonDecoder(GenericGF.MAXICODE_FIELD_64);\n }\n\n public DecoderResult decode(BitMatrix bits) throws ChecksumException, FormatException {\n return decode(bits, null);\n }\n\n public DecoderResult decode(BitMatrix bits,\n MapAttempts to locate multiple barcodes in an image by repeatedly decoding portion of the image.\n * After one barcode is found, the areas left, above, right and below the barcode's\n * {@link ResultPoint}s are scanned, recursively.
\n *\n *A caller may want to also employ {@link ByQuadrantReader} when attempting to find multiple\n * 2D barcodes, like QR Codes, in an image, where the presence of multiple barcodes might prevent\n * detecting any one of them.
\n *\n *That is, instead of passing a {@link Reader} a caller might pass\n * {@code new ByQuadrantReader(reader)}.
\n *\n * @author Sean Owen\n */\npublic final class GenericMultipleBarcodeReader implements MultipleBarcodeReader {\n\n private static final int MIN_DIMENSION_TO_RECUR = 100;\n private static final int MAX_DEPTH = 4;\n\n static final Result[] EMPTY_RESULT_ARRAY = new Result[0];\n\n private final Reader delegate;\n\n public GenericMultipleBarcodeReader(Reader delegate) {\n this.delegate = delegate;\n }\n\n @Override\n public Result[] decodeMultiple(BinaryBitmap image) throws NotFoundException {\n return decodeMultiple(image, null);\n }\n\n @Override\n public Result[] decodeMultiple(BinaryBitmap image, MapEncapsulates logic that can detect one or more QR Codes in an image, even if the QR Code\n * is rotated or skewed, or partially obscured.
\n *\n * @author Sean Owen\n * @author Hannes Erven\n */\npublic final class MultiDetector extends Detector {\n\n private static final DetectorResult[] EMPTY_DETECTOR_RESULTS = new DetectorResult[0];\n\n public MultiDetector(BitMatrix image) {\n super(image);\n }\n\n public DetectorResult[] detectMulti(MapThis class attempts to find finder patterns in a QR Code. Finder patterns are the square\n * markers at three corners of a QR Code.
\n *\n *This class is thread-safe but not reentrant. Each thread must allocate its own object.\n *\n *
In contrast to {@link FinderPatternFinder}, this class will return an array of all possible\n * QR code locations in the image.
\n *\n *Use the TRY_HARDER hint to ask for a more thorough detection.
\n *\n * @author Sean Owen\n * @author Hannes Erven\n */\nfinal class MultiFinderPatternFinder extends FinderPatternFinder {\n\n private static final FinderPatternInfo[] EMPTY_RESULT_ARRAY = new FinderPatternInfo[0];\n private static final FinderPattern[][] EMPTY_FP_2D_ARRAY = new FinderPattern[0][];\n\n // TODO MIN_MODULE_COUNT and MAX_MODULE_COUNT would be great hints to ask the user for\n // since it limits the number of regions to decode\n\n // max. legal count of modules per QR code edge (177)\n private static final float MAX_MODULE_COUNT_PER_EDGE = 180;\n // min. legal count per modules per QR code edge (11)\n private static final float MIN_MODULE_COUNT_PER_EDGE = 9;\n\n /**\n * More or less arbitrary cutoff point for determining if two finder patterns might belong\n * to the same code if they differ less than DIFF_MODSIZE_CUTOFF_PERCENT percent in their\n * estimated modules sizes.\n */\n private static final float DIFF_MODSIZE_CUTOFF_PERCENT = 0.05f;\n\n /**\n * More or less arbitrary cutoff point for determining if two finder patterns might belong\n * to the same code if they differ less than DIFF_MODSIZE_CUTOFF pixels/module in their\n * estimated modules sizes.\n */\n private static final float DIFF_MODSIZE_CUTOFF = 0.5f;\n\n\n /**\n * A comparator that orders FinderPatterns by their estimated module size.\n */\n private static final class ModuleSizeComparator implements ComparatorCreates a finder that will search the image for three finder patterns.
\n *\n * @param image image to search\n */\n MultiFinderPatternFinder(BitMatrix image) {\n super(image);\n }\n\n MultiFinderPatternFinder(BitMatrix image, ResultPointCallback resultPointCallback) {\n super(image, resultPointCallback);\n }\n\n /**\n * @return the 3 best {@link FinderPattern}s from our list of candidates. The \"best\" are\n * those that have been detected at least {@link #CENTER_QUORUM} times, and whose module\n * size differs from the average among those patterns the least\n * @throws NotFoundException if 3 such finder patterns do not exist\n */\n private FinderPattern[][] selectMultipleBestPatterns() throws NotFoundException {\n ListDecodes Codabar barcodes.
\n *\n * @author Bas Vijfwinkel\n * @author David Walker\n */\npublic final class CodaBarReader extends OneDReader {\n\n // These values are critical for determining how permissive the decoding\n // will be. All stripe sizes must be within the window these define, as\n // compared to the average stripe size.\n private static final float MAX_ACCEPTABLE = 2.0f;\n private static final float PADDING = 1.5f;\n\n private static final String ALPHABET_STRING = \"0123456789-$:/.+ABCD\";\n static final char[] ALPHABET = ALPHABET_STRING.toCharArray();\n\n /**\n * These represent the encodings of characters, as patterns of wide and narrow bars. The 7 least-significant bits of\n * each int correspond to the pattern of wide and narrow, with 1s representing \"wide\" and 0s representing narrow.\n */\n static final int[] CHARACTER_ENCODINGS = {\n 0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, // 0-9\n 0x00c, 0x018, 0x045, 0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E, // -$:/.+ABCD\n };\n\n // minimal number of characters that should be present (including start and stop characters)\n // under normal circumstances this should be set to 3, but can be set higher\n // as a last-ditch attempt to reduce false positives.\n private static final int MIN_CHARACTER_LENGTH = 3;\n\n // official start and end patterns\n private static final char[] STARTEND_ENCODING = {'A', 'B', 'C', 'D'};\n // some Codabar generator allow the Codabar string to be closed by every\n // character. This will cause lots of false positives!\n\n // some industries use a checksum standard but this is not part of the original Codabar standard\n // for more information see : http://www.mecsw.com/specs/codabar.html\n\n // Keep some instance variables to avoid reallocations\n private final StringBuilder decodeRowResult;\n private int[] counters;\n private int counterLength;\n\n public CodaBarReader() {\n decodeRowResult = new StringBuilder(20);\n counters = new int[80];\n counterLength = 0;\n }\n\n @Override\n public Result decodeRow(int rowNumber, BitArray row, MapDecodes Code 128 barcodes.
\n *\n * @author Sean Owen\n */\npublic final class Code128Reader extends OneDReader {\n\n static final int[][] CODE_PATTERNS = {\n {2, 1, 2, 2, 2, 2}, // 0\n {2, 2, 2, 1, 2, 2},\n {2, 2, 2, 2, 2, 1},\n {1, 2, 1, 2, 2, 3},\n {1, 2, 1, 3, 2, 2},\n {1, 3, 1, 2, 2, 2}, // 5\n {1, 2, 2, 2, 1, 3},\n {1, 2, 2, 3, 1, 2},\n {1, 3, 2, 2, 1, 2},\n {2, 2, 1, 2, 1, 3},\n {2, 2, 1, 3, 1, 2}, // 10\n {2, 3, 1, 2, 1, 2},\n {1, 1, 2, 2, 3, 2},\n {1, 2, 2, 1, 3, 2},\n {1, 2, 2, 2, 3, 1},\n {1, 1, 3, 2, 2, 2}, // 15\n {1, 2, 3, 1, 2, 2},\n {1, 2, 3, 2, 2, 1},\n {2, 2, 3, 2, 1, 1},\n {2, 2, 1, 1, 3, 2},\n {2, 2, 1, 2, 3, 1}, // 20\n {2, 1, 3, 2, 1, 2},\n {2, 2, 3, 1, 1, 2},\n {3, 1, 2, 1, 3, 1},\n {3, 1, 1, 2, 2, 2},\n {3, 2, 1, 1, 2, 2}, // 25\n {3, 2, 1, 2, 2, 1},\n {3, 1, 2, 2, 1, 2},\n {3, 2, 2, 1, 1, 2},\n {3, 2, 2, 2, 1, 1},\n {2, 1, 2, 1, 2, 3}, // 30\n {2, 1, 2, 3, 2, 1},\n {2, 3, 2, 1, 2, 1},\n {1, 1, 1, 3, 2, 3},\n {1, 3, 1, 1, 2, 3},\n {1, 3, 1, 3, 2, 1}, // 35\n {1, 1, 2, 3, 1, 3},\n {1, 3, 2, 1, 1, 3},\n {1, 3, 2, 3, 1, 1},\n {2, 1, 1, 3, 1, 3},\n {2, 3, 1, 1, 1, 3}, // 40\n {2, 3, 1, 3, 1, 1},\n {1, 1, 2, 1, 3, 3},\n {1, 1, 2, 3, 3, 1},\n {1, 3, 2, 1, 3, 1},\n {1, 1, 3, 1, 2, 3}, // 45\n {1, 1, 3, 3, 2, 1},\n {1, 3, 3, 1, 2, 1},\n {3, 1, 3, 1, 2, 1},\n {2, 1, 1, 3, 3, 1},\n {2, 3, 1, 1, 3, 1}, // 50\n {2, 1, 3, 1, 1, 3},\n {2, 1, 3, 3, 1, 1},\n {2, 1, 3, 1, 3, 1},\n {3, 1, 1, 1, 2, 3},\n {3, 1, 1, 3, 2, 1}, // 55\n {3, 3, 1, 1, 2, 1},\n {3, 1, 2, 1, 1, 3},\n {3, 1, 2, 3, 1, 1},\n {3, 3, 2, 1, 1, 1},\n {3, 1, 4, 1, 1, 1}, // 60\n {2, 2, 1, 4, 1, 1},\n {4, 3, 1, 1, 1, 1},\n {1, 1, 1, 2, 2, 4},\n {1, 1, 1, 4, 2, 2},\n {1, 2, 1, 1, 2, 4}, // 65\n {1, 2, 1, 4, 2, 1},\n {1, 4, 1, 1, 2, 2},\n {1, 4, 1, 2, 2, 1},\n {1, 1, 2, 2, 1, 4},\n {1, 1, 2, 4, 1, 2}, // 70\n {1, 2, 2, 1, 1, 4},\n {1, 2, 2, 4, 1, 1},\n {1, 4, 2, 1, 1, 2},\n {1, 4, 2, 2, 1, 1},\n {2, 4, 1, 2, 1, 1}, // 75\n {2, 2, 1, 1, 1, 4},\n {4, 1, 3, 1, 1, 1},\n {2, 4, 1, 1, 1, 2},\n {1, 3, 4, 1, 1, 1},\n {1, 1, 1, 2, 4, 2}, // 80\n {1, 2, 1, 1, 4, 2},\n {1, 2, 1, 2, 4, 1},\n {1, 1, 4, 2, 1, 2},\n {1, 2, 4, 1, 1, 2},\n {1, 2, 4, 2, 1, 1}, // 85\n {4, 1, 1, 2, 1, 2},\n {4, 2, 1, 1, 1, 2},\n {4, 2, 1, 2, 1, 1},\n {2, 1, 2, 1, 4, 1},\n {2, 1, 4, 1, 2, 1}, // 90\n {4, 1, 2, 1, 2, 1},\n {1, 1, 1, 1, 4, 3},\n {1, 1, 1, 3, 4, 1},\n {1, 3, 1, 1, 4, 1},\n {1, 1, 4, 1, 1, 3}, // 95\n {1, 1, 4, 3, 1, 1},\n {4, 1, 1, 1, 1, 3},\n {4, 1, 1, 3, 1, 1},\n {1, 1, 3, 1, 4, 1},\n {1, 1, 4, 1, 3, 1}, // 100\n {3, 1, 1, 1, 4, 1},\n {4, 1, 1, 1, 3, 1},\n {2, 1, 1, 4, 1, 2},\n {2, 1, 1, 2, 1, 4},\n {2, 1, 1, 2, 3, 2}, // 105\n {2, 3, 3, 1, 1, 1, 2}\n };\n\n private static final float MAX_AVG_VARIANCE = 0.25f;\n private static final float MAX_INDIVIDUAL_VARIANCE = 0.7f;\n\n private static final int CODE_SHIFT = 98;\n\n private static final int CODE_CODE_C = 99;\n private static final int CODE_CODE_B = 100;\n private static final int CODE_CODE_A = 101;\n\n private static final int CODE_FNC_1 = 102;\n private static final int CODE_FNC_2 = 97;\n private static final int CODE_FNC_3 = 96;\n private static final int CODE_FNC_4_A = 101;\n private static final int CODE_FNC_4_B = 100;\n\n private static final int CODE_START_A = 103;\n private static final int CODE_START_B = 104;\n private static final int CODE_START_C = 105;\n private static final int CODE_STOP = 106;\n\n private static int[] findStartPattern(BitArray row) throws NotFoundException {\n int width = row.getSize();\n int rowOffset = row.getNextSet(0);\n\n int counterPosition = 0;\n int[] counters = new int[6];\n int patternStart = rowOffset;\n boolean isWhite = false;\n int patternLength = counters.length;\n\n for (int i = rowOffset; i < width; i++) {\n if (row.get(i) != isWhite) {\n counters[counterPosition]++;\n } else {\n if (counterPosition == patternLength - 1) {\n float bestVariance = MAX_AVG_VARIANCE;\n int bestMatch = -1;\n for (int startCode = CODE_START_A; startCode <= CODE_START_C; startCode++) {\n float variance = patternMatchVariance(counters, CODE_PATTERNS[startCode],\n MAX_INDIVIDUAL_VARIANCE);\n if (variance < bestVariance) {\n bestVariance = variance;\n bestMatch = startCode;\n }\n }\n // Look for whitespace before start pattern, >= 50% of width of start pattern\n if (bestMatch >= 0 &&\n row.isRange(Math.max(0, patternStart - (i - patternStart) / 2), patternStart, false)) {\n return new int[]{patternStart, i, bestMatch};\n }\n patternStart += counters[0] + counters[1];\n System.arraycopy(counters, 2, counters, 0, counterPosition - 1);\n counters[counterPosition - 1] = 0;\n counters[counterPosition] = 0;\n counterPosition--;\n } else {\n counterPosition++;\n }\n counters[counterPosition] = 1;\n isWhite = !isWhite;\n }\n }\n throw NotFoundException.getNotFoundInstance();\n }\n\n private static int decodeCode(BitArray row, int[] counters, int rowOffset)\n throws NotFoundException {\n recordPattern(row, rowOffset, counters);\n float bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept\n int bestMatch = -1;\n for (int d = 0; d < CODE_PATTERNS.length; d++) {\n int[] pattern = CODE_PATTERNS[d];\n float variance = patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE);\n if (variance < bestVariance) {\n bestVariance = variance;\n bestMatch = d;\n }\n }\n // TODO We're overlooking the fact that the STOP pattern has 7 values, not 6.\n if (bestMatch >= 0) {\n return bestMatch;\n } else {\n throw NotFoundException.getNotFoundInstance();\n }\n }\n\n @Override\n public Result decodeRow(int rowNumber, BitArray row, MapDecodes Code 39 barcodes. Supports \"Full ASCII Code 39\" if USE_CODE_39_EXTENDED_MODE is set.
\n *\n * @author Sean Owen\n * @see Code93Reader\n */\npublic final class Code39Reader extends OneDReader {\n\n static final String ALPHABET_STRING = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%\";\n\n /**\n * These represent the encodings of characters, as patterns of wide and narrow bars.\n * The 9 least-significant bits of each int correspond to the pattern of wide and narrow,\n * with 1s representing \"wide\" and 0s representing narrow.\n */\n static final int[] CHARACTER_ENCODINGS = {\n 0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, // 0-9\n 0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, // A-J\n 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, // K-T\n 0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x0A8, // U-$\n 0x0A2, 0x08A, 0x02A // /-%\n };\n\n static final int ASTERISK_ENCODING = 0x094;\n\n private final boolean usingCheckDigit;\n private final boolean extendedMode;\n private final StringBuilder decodeRowResult;\n private final int[] counters;\n\n /**\n * Creates a reader that assumes all encoded data is data, and does not treat the final\n * character as a check digit. It will not decoded \"extended Code 39\" sequences.\n */\n public Code39Reader() {\n this(false);\n }\n\n /**\n * Creates a reader that can be configured to check the last character as a check digit.\n * It will not decoded \"extended Code 39\" sequences.\n *\n * @param usingCheckDigit if true, treat the last data character as a check digit, not\n * data, and verify that the checksum passes.\n */\n public Code39Reader(boolean usingCheckDigit) {\n this(usingCheckDigit, false);\n }\n\n /**\n * Creates a reader that can be configured to check the last character as a check digit,\n * or optionally attempt to decode \"extended Code 39\" sequences that are used to encode\n * the full ASCII character set.\n *\n * @param usingCheckDigit if true, treat the last data character as a check digit, not\n * data, and verify that the checksum passes.\n * @param extendedMode if true, will attempt to decode extended Code 39 sequences in the\n * text.\n */\n public Code39Reader(boolean usingCheckDigit, boolean extendedMode) {\n this.usingCheckDigit = usingCheckDigit;\n this.extendedMode = extendedMode;\n decodeRowResult = new StringBuilder(20);\n counters = new int[9];\n }\n\n @Override\n public Result decodeRow(int rowNumber, BitArray row, MapDecodes Code 93 barcodes.
\n *\n * @author Sean Owen\n * @see Code39Reader\n */\npublic final class Code93Reader extends OneDReader {\n\n // Note that 'abcd' are dummy characters in place of control characters.\n static final String ALPHABET_STRING = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*\";\n private static final char[] ALPHABET = ALPHABET_STRING.toCharArray();\n\n /**\n * These represent the encodings of characters, as patterns of wide and narrow bars.\n * The 9 least-significant bits of each int correspond to the pattern of wide and narrow.\n */\n static final int[] CHARACTER_ENCODINGS = {\n 0x114, 0x148, 0x144, 0x142, 0x128, 0x124, 0x122, 0x150, 0x112, 0x10A, // 0-9\n 0x1A8, 0x1A4, 0x1A2, 0x194, 0x192, 0x18A, 0x168, 0x164, 0x162, 0x134, // A-J\n 0x11A, 0x158, 0x14C, 0x146, 0x12C, 0x116, 0x1B4, 0x1B2, 0x1AC, 0x1A6, // K-T\n 0x196, 0x19A, 0x16C, 0x166, 0x136, 0x13A, // U-Z\n 0x12E, 0x1D4, 0x1D2, 0x1CA, 0x16E, 0x176, 0x1AE, // - - %\n 0x126, 0x1DA, 0x1D6, 0x132, 0x15E, // Control chars? $-*\n };\n static final int ASTERISK_ENCODING = CHARACTER_ENCODINGS[47];\n\n private final StringBuilder decodeRowResult;\n private final int[] counters;\n\n public Code93Reader() {\n decodeRowResult = new StringBuilder(20);\n counters = new int[6];\n }\n\n @Override\n public Result decodeRow(int rowNumber, BitArray row, MapImplements decoding of the EAN-13 format.
\n *\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Sean Owen\n * @author alasdair@google.com (Alasdair Mackintosh)\n */\npublic final class EAN13Reader extends UPCEANReader {\n\n // For an EAN-13 barcode, the first digit is represented by the parities used\n // to encode the next six digits, according to the table below. For example,\n // if the barcode is 5 123456 789012 then the value of the first digit is\n // signified by using odd for '1', even for '2', even for '3', odd for '4',\n // odd for '5', and even for '6'. See http://en.wikipedia.org/wiki/EAN-13\n //\n // Parity of next 6 digits\n // Digit 0 1 2 3 4 5\n // 0 Odd Odd Odd Odd Odd Odd\n // 1 Odd Odd Even Odd Even Even\n // 2 Odd Odd Even Even Odd Even\n // 3 Odd Odd Even Even Even Odd\n // 4 Odd Even Odd Odd Even Even\n // 5 Odd Even Even Odd Odd Even\n // 6 Odd Even Even Even Odd Odd\n // 7 Odd Even Odd Even Odd Even\n // 8 Odd Even Odd Even Even Odd\n // 9 Odd Even Even Odd Even Odd\n //\n // Note that the encoding for '0' uses the same parity as a UPC barcode. Hence\n // a UPC barcode can be converted to an EAN-13 barcode by prepending a 0.\n //\n // The encoding is represented by the following array, which is a bit pattern\n // using Odd = 0 and Even = 1. For example, 5 is represented by:\n //\n // Odd Even Even Odd Odd Even\n // in binary:\n // 0 1 1 0 0 1 == 0x19\n //\n static final int[] FIRST_DIGIT_ENCODINGS = {\n 0x00, 0x0B, 0x0D, 0xE, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A\n };\n\n private final int[] decodeMiddleCounters;\n\n public EAN13Reader() {\n decodeMiddleCounters = new int[4];\n }\n\n @Override\n protected int decodeMiddle(BitArray row,\n int[] startRange,\n StringBuilder resultString) throws NotFoundException {\n int[] counters = decodeMiddleCounters;\n counters[0] = 0;\n counters[1] = 0;\n counters[2] = 0;\n counters[3] = 0;\n int end = row.getSize();\n int rowOffset = startRange[1];\n\n int lgPatternFound = 0;\n\n for (int x = 0; x < 6 && rowOffset < end; x++) {\n int bestMatch = decodeDigit(row, counters, rowOffset, L_AND_G_PATTERNS);\n resultString.append((char) ('0' + bestMatch % 10));\n for (int counter : counters) {\n rowOffset += counter;\n }\n if (bestMatch >= 10) {\n lgPatternFound |= 1 << (5 - x);\n }\n }\n\n determineFirstDigit(resultString, lgPatternFound);\n\n int[] middleRange = findGuardPattern(row, rowOffset, true, MIDDLE_PATTERN);\n rowOffset = middleRange[1];\n\n for (int x = 0; x < 6 && rowOffset < end; x++) {\n int bestMatch = decodeDigit(row, counters, rowOffset, L_PATTERNS);\n resultString.append((char) ('0' + bestMatch));\n for (int counter : counters) {\n rowOffset += counter;\n }\n }\n\n return rowOffset;\n }\n\n @Override\n BarcodeFormat getBarcodeFormat() {\n return BarcodeFormat.EAN_13;\n }\n\n /**\n * Based on pattern of odd-even ('L' and 'G') patterns used to encoded the explicitly-encoded\n * digits in a barcode, determines the implicitly encoded first digit and adds it to the\n * result string.\n *\n * @param resultString string to insert decoded first digit into\n * @param lgPatternFound int whose bits indicates the pattern of odd/even L/G patterns used to\n * encode digits\n * @throws NotFoundException if first digit cannot be determined\n */\n private static void determineFirstDigit(StringBuilder resultString, int lgPatternFound)\n throws NotFoundException {\n for (int d = 0; d < 10; d++) {\n if (lgPatternFound == FIRST_DIGIT_ENCODINGS[d]) {\n resultString.insert(0, (char) ('0' + d));\n return;\n }\n }\n throw NotFoundException.getNotFoundInstance();\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/oned/EAN13Writer.java", "content": "/*\n * Copyright 2009 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.oned;\n\nimport com.google.zxing.BarcodeFormat;\nimport com.google.zxing.EncodeHintType;\nimport com.google.zxing.FormatException;\nimport com.google.zxing.WriterException;\nimport com.google.zxing.common.BitMatrix;\n\nimport java.util.Map;\n\n/**\n * This object renders an EAN13 code as a {@link BitMatrix}.\n *\n * @author aripollak@gmail.com (Ari Pollak)\n */\npublic final class EAN13Writer extends UPCEANWriter {\n\n private static final int CODE_WIDTH = 3 + // start guard\n (7 * 6) + // left bars\n 5 + // middle guard\n (7 * 6) + // right bars\n 3; // end guard\n\n @Override\n public BitMatrix encode(String contents,\n BarcodeFormat format,\n int width,\n int height,\n MapImplements decoding of the EAN-8 format.
\n *\n * @author Sean Owen\n */\npublic final class EAN8Reader extends UPCEANReader {\n\n private final int[] decodeMiddleCounters;\n\n public EAN8Reader() {\n decodeMiddleCounters = new int[4];\n }\n\n @Override\n protected int decodeMiddle(BitArray row,\n int[] startRange,\n StringBuilder result) throws NotFoundException {\n int[] counters = decodeMiddleCounters;\n counters[0] = 0;\n counters[1] = 0;\n counters[2] = 0;\n counters[3] = 0;\n int end = row.getSize();\n int rowOffset = startRange[1];\n\n for (int x = 0; x < 4 && rowOffset < end; x++) {\n int bestMatch = decodeDigit(row, counters, rowOffset, L_PATTERNS);\n result.append((char) ('0' + bestMatch));\n for (int counter : counters) {\n rowOffset += counter;\n }\n }\n\n int[] middleRange = findGuardPattern(row, rowOffset, true, MIDDLE_PATTERN);\n rowOffset = middleRange[1];\n\n for (int x = 0; x < 4 && rowOffset < end; x++) {\n int bestMatch = decodeDigit(row, counters, rowOffset, L_PATTERNS);\n result.append((char) ('0' + bestMatch));\n for (int counter : counters) {\n rowOffset += counter;\n }\n }\n\n return rowOffset;\n }\n\n @Override\n BarcodeFormat getBarcodeFormat() {\n return BarcodeFormat.EAN_8;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/oned/EAN8Writer.java", "content": "/*\n * Copyright 2009 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.oned;\n\nimport com.google.zxing.BarcodeFormat;\nimport com.google.zxing.EncodeHintType;\nimport com.google.zxing.FormatException;\nimport com.google.zxing.WriterException;\nimport com.google.zxing.common.BitMatrix;\n\nimport java.util.Map;\n\n/**\n * This object renders an EAN8 code as a {@link BitMatrix}.\n *\n * @author aripollak@gmail.com (Ari Pollak)\n */\npublic final class EAN8Writer extends UPCEANWriter {\n\n private static final int CODE_WIDTH = 3 + // start guard\n (7 * 4) + // left bars\n 5 + // middle guard\n (7 * 4) + // right bars\n 3; // end guard\n\n @Override\n public BitMatrix encode(String contents,\n BarcodeFormat format,\n int width,\n int height,\n MapImplements decoding of the ITF format, or Interleaved Two of Five.
\n *\n *This Reader will scan ITF barcodes of certain lengths only.\n * At the moment it reads length 6, 8, 10, 12, 14, 16, 18, 20, 24, and 44 as these have appeared \"in the wild\". Not all\n * lengths are scanned, especially shorter ones, to avoid false positives. This in turn is due to a lack of\n * required checksum function.
\n *\n *The checksum is optional and is not applied by this Reader. The consumer of the decoded\n * value will have to apply a checksum if required.
\n *\n *http://en.wikipedia.org/wiki/Interleaved_2_of_5\n * is a great reference for Interleaved 2 of 5 information.
\n *\n * @author kevin.osullivan@sita.aero, SITA Lab.\n */\npublic final class ITFReader extends OneDReader {\n\n private static final float MAX_AVG_VARIANCE = 0.38f;\n private static final float MAX_INDIVIDUAL_VARIANCE = 0.5f;\n\n private static final int W = 3; // Pixel width of a 3x wide line\n private static final int w = 2; // Pixel width of a 2x wide line\n private static final int N = 1; // Pixed width of a narrow line\n\n /** Valid ITF lengths. Anything longer than the largest value is also allowed. */\n private static final int[] DEFAULT_ALLOWED_LENGTHS = {6, 8, 10, 12, 14};\n\n // Stores the actual narrow line width of the image being decoded.\n private int narrowLineWidth = -1;\n\n /**\n * Start/end guard pattern.\n *\n * Note: The end pattern is reversed because the row is reversed before\n * searching for the END_PATTERN\n */\n private static final int[] START_PATTERN = {N, N, N, N};\n private static final int[][] END_PATTERN_REVERSED = {\n {N, N, w}, // 2x\n {N, N, W} // 3x\n };\n\n // See ITFWriter.PATTERNS\n\n /**\n * Patterns of Wide / Narrow lines to indicate each digit\n */\n private static final int[][] PATTERNS = {\n {N, N, w, w, N}, // 0\n {w, N, N, N, w}, // 1\n {N, w, N, N, w}, // 2\n {w, w, N, N, N}, // 3\n {N, N, w, N, w}, // 4\n {w, N, w, N, N}, // 5\n {N, w, w, N, N}, // 6\n {N, N, N, w, w}, // 7\n {w, N, N, w, N}, // 8\n {N, w, N, w, N}, // 9\n {N, N, W, W, N}, // 0\n {W, N, N, N, W}, // 1\n {N, W, N, N, W}, // 2\n {W, W, N, N, N}, // 3\n {N, N, W, N, W}, // 4\n {W, N, W, N, N}, // 5\n {N, W, W, N, N}, // 6\n {N, N, N, W, W}, // 7\n {W, N, N, W, N}, // 8\n {N, W, N, W, N} // 9\n };\n\n @Override\n public Result decodeRow(int rowNumber, BitArray row, MapA reader that can read all available UPC/EAN formats. If a caller wants to try to\n * read all such formats, it is most efficient to use this implementation rather than invoke\n * individual readers.
\n *\n * @author Sean Owen\n */\npublic final class MultiFormatUPCEANReader extends OneDReader {\n\n private static final UPCEANReader[] EMPTY_READER_ARRAY = new UPCEANReader[0];\n\n private final UPCEANReader[] readers;\n\n public MultiFormatUPCEANReader(MapAttempts to decode a one-dimensional barcode format given a single row of\n * an image.
\n *\n * @param rowNumber row number from top of the row\n * @param row the black/white pixel data of the row\n * @param hints decode hints\n * @return {@link Result} containing encoded string and start/end of barcode\n * @throws NotFoundException if no potential barcode is found\n * @throws ChecksumException if a potential barcode is found but does not pass its checksum\n * @throws FormatException if a potential barcode is found but format is invalid\n */\n public abstract Result decodeRow(int rowNumber, BitArray row, MapEncapsulates functionality and implementation that is common to one-dimensional barcodes.
\n *\n * @author dsbnatut@gmail.com (Kazuki Nishiura)\n */\npublic abstract class OneDimensionalCodeWriter implements Writer {\n private static final Pattern NUMERIC = Pattern.compile(\"[0-9]+\");\n\n @Override\n public final BitMatrix encode(String contents, BarcodeFormat format, int width, int height)\n throws WriterException {\n return encode(contents, format, width, height, null);\n }\n\n /**\n * Encode the contents following specified format.\n * {@code width} and {@code height} are required size. This method may return bigger size\n * {@code BitMatrix} when specified size is too small. The user can set both {@code width} and\n * {@code height} to zero to get minimum size barcode. If negative value is set to {@code width}\n * or {@code height}, {@code IllegalArgumentException} is thrown.\n */\n @Override\n public BitMatrix encode(String contents,\n BarcodeFormat format,\n int width,\n int height,\n MapImplements decoding of the UPC-A format.
\n *\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Sean Owen\n */\npublic final class UPCAReader extends UPCEANReader {\n\n private final UPCEANReader ean13Reader = new EAN13Reader();\n\n @Override\n public Result decodeRow(int rowNumber,\n BitArray row,\n int[] startGuardRange,\n MapEncapsulates functionality and implementation that is common to UPC and EAN families\n * of one-dimensional barcodes.
\n *\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Sean Owen\n * @author alasdair@google.com (Alasdair Mackintosh)\n */\npublic abstract class UPCEANReader extends OneDReader {\n\n // These two values are critical for determining how permissive the decoding will be.\n // We've arrived at these values through a lot of trial and error. Setting them any higher\n // lets false positives creep in quickly.\n private static final float MAX_AVG_VARIANCE = 0.48f;\n private static final float MAX_INDIVIDUAL_VARIANCE = 0.7f;\n\n /**\n * Start/end guard pattern.\n */\n static final int[] START_END_PATTERN = {1, 1, 1,};\n\n /**\n * Pattern marking the middle of a UPC/EAN pattern, separating the two halves.\n */\n static final int[] MIDDLE_PATTERN = {1, 1, 1, 1, 1};\n /**\n * end guard pattern.\n */\n static final int[] END_PATTERN = {1, 1, 1, 1, 1, 1};\n /**\n * \"Odd\", or \"L\" patterns used to encode UPC/EAN digits.\n */\n static final int[][] L_PATTERNS = {\n {3, 2, 1, 1}, // 0\n {2, 2, 2, 1}, // 1\n {2, 1, 2, 2}, // 2\n {1, 4, 1, 1}, // 3\n {1, 1, 3, 2}, // 4\n {1, 2, 3, 1}, // 5\n {1, 1, 1, 4}, // 6\n {1, 3, 1, 2}, // 7\n {1, 2, 1, 3}, // 8\n {3, 1, 1, 2} // 9\n };\n\n /**\n * As above but also including the \"even\", or \"G\" patterns used to encode UPC/EAN digits.\n */\n static final int[][] L_AND_G_PATTERNS;\n\n static {\n L_AND_G_PATTERNS = new int[20][];\n System.arraycopy(L_PATTERNS, 0, L_AND_G_PATTERNS, 0, 10);\n for (int i = 10; i < 20; i++) {\n int[] widths = L_PATTERNS[i - 10];\n int[] reversedWidths = new int[widths.length];\n for (int j = 0; j < widths.length; j++) {\n reversedWidths[j] = widths[widths.length - j - 1];\n }\n L_AND_G_PATTERNS[i] = reversedWidths;\n }\n }\n\n private final StringBuilder decodeRowStringBuffer;\n private final UPCEANExtensionSupport extensionReader;\n private final EANManufacturerOrgSupport eanManSupport;\n\n protected UPCEANReader() {\n decodeRowStringBuffer = new StringBuilder(20);\n extensionReader = new UPCEANExtensionSupport();\n eanManSupport = new EANManufacturerOrgSupport();\n }\n\n static int[] findStartGuardPattern(BitArray row) throws NotFoundException {\n boolean foundStart = false;\n int[] startRange = null;\n int nextStart = 0;\n int[] counters = new int[START_END_PATTERN.length];\n while (!foundStart) {\n Arrays.fill(counters, 0, START_END_PATTERN.length, 0);\n startRange = findGuardPattern(row, nextStart, false, START_END_PATTERN, counters);\n int start = startRange[0];\n nextStart = startRange[1];\n // Make sure there is a quiet zone at least as big as the start pattern before the barcode.\n // If this check would run off the left edge of the image, do not accept this barcode,\n // as it is very likely to be a false positive.\n int quietStart = start - (nextStart - start);\n if (quietStart >= 0) {\n foundStart = row.isRange(quietStart, start, false);\n }\n }\n return startRange;\n }\n\n @Override\n public Result decodeRow(int rowNumber, BitArray row, MapLike {@link #decodeRow(int, BitArray, Map)}, but\n * allows caller to inform method about where the UPC/EAN start pattern is\n * found. This allows this to be computed once and reused across many implementations.
\n *\n * @param rowNumber row index into the image\n * @param row encoding of the row of the barcode image\n * @param startGuardRange start/end column where the opening start pattern was found\n * @param hints optional hints that influence decoding\n * @return {@link Result} encapsulating the result of decoding a barcode in the row\n * @throws NotFoundException if no potential barcode is found\n * @throws ChecksumException if a potential barcode is found but does not pass its checksum\n * @throws FormatException if a potential barcode is found but format is invalid\n */\n public Result decodeRow(int rowNumber,\n BitArray row,\n int[] startGuardRange,\n MapEncapsulates functionality and implementation that is common to UPC and EAN families\n * of one-dimensional barcodes.
\n *\n * @author aripollak@gmail.com (Ari Pollak)\n * @author dsbnatut@gmail.com (Kazuki Nishiura)\n */\npublic abstract class UPCEANWriter extends OneDimensionalCodeWriter {\n\n @Override\n public int getDefaultMargin() {\n // Use a different default more appropriate for UPC/EAN\n return 9;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/oned/UPCEReader.java", "content": "/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.oned;\n\nimport com.google.zxing.BarcodeFormat;\nimport com.google.zxing.FormatException;\nimport com.google.zxing.NotFoundException;\nimport com.google.zxing.common.BitArray;\n\n/**\n *Implements decoding of the UPC-E format.
\n *This is a great reference for\n * UPC-E information.
\n *\n * @author Sean Owen\n */\npublic final class UPCEReader extends UPCEANReader {\n\n /**\n * The pattern that marks the middle, and end, of a UPC-E pattern.\n * There is no \"second half\" to a UPC-E barcode.\n */\n private static final int[] MIDDLE_END_PATTERN = {1, 1, 1, 1, 1, 1};\n\n // For an UPC-E barcode, the final digit is represented by the parities used\n // to encode the middle six digits, according to the table below.\n //\n // Parity of next 6 digits\n // Digit 0 1 2 3 4 5\n // 0 Even Even Even Odd Odd Odd\n // 1 Even Even Odd Even Odd Odd\n // 2 Even Even Odd Odd Even Odd\n // 3 Even Even Odd Odd Odd Even\n // 4 Even Odd Even Even Odd Odd\n // 5 Even Odd Odd Even Even Odd\n // 6 Even Odd Odd Odd Even Even\n // 7 Even Odd Even Odd Even Odd\n // 8 Even Odd Even Odd Odd Even\n // 9 Even Odd Odd Even Odd Even\n //\n // The encoding is represented by the following array, which is a bit pattern\n // using Odd = 0 and Even = 1. For example, 5 is represented by:\n //\n // Odd Even Even Odd Odd Even\n // in binary:\n // 0 1 1 0 0 1 == 0x19\n //\n\n /**\n * See {@link #L_AND_G_PATTERNS}; these values similarly represent patterns of\n * even-odd parity encodings of digits that imply both the number system (0 or 1)\n * used, and the check digit.\n */\n static final int[][] NUMSYS_AND_CHECK_DIGIT_PATTERNS = {\n {0x38, 0x34, 0x32, 0x31, 0x2C, 0x26, 0x23, 0x2A, 0x29, 0x25},\n {0x07, 0x0B, 0x0D, 0x0E, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A}\n };\n\n private final int[] decodeMiddleCounters;\n\n public UPCEReader() {\n decodeMiddleCounters = new int[4];\n }\n\n @Override\n protected int decodeMiddle(BitArray row, int[] startRange, StringBuilder result)\n throws NotFoundException {\n int[] counters = decodeMiddleCounters;\n counters[0] = 0;\n counters[1] = 0;\n counters[2] = 0;\n counters[3] = 0;\n int end = row.getSize();\n int rowOffset = startRange[1];\n\n int lgPatternFound = 0;\n\n for (int x = 0; x < 6 && rowOffset < end; x++) {\n int bestMatch = decodeDigit(row, counters, rowOffset, L_AND_G_PATTERNS);\n result.append((char) ('0' + bestMatch % 10));\n for (int counter : counters) {\n rowOffset += counter;\n }\n if (bestMatch >= 10) {\n lgPatternFound |= 1 << (5 - x);\n }\n }\n\n determineNumSysAndCheckDigit(result, lgPatternFound);\n\n return rowOffset;\n }\n\n @Override\n protected int[] decodeEnd(BitArray row, int endStart) throws NotFoundException {\n return findGuardPattern(row, endStart, true, MIDDLE_END_PATTERN);\n }\n\n @Override\n protected boolean checkChecksum(String s) throws FormatException {\n return super.checkChecksum(convertUPCEtoUPCA(s));\n }\n\n private static void determineNumSysAndCheckDigit(StringBuilder resultString, int lgPatternFound)\n throws NotFoundException {\n\n for (int numSys = 0; numSys <= 1; numSys++) {\n for (int d = 0; d < 10; d++) {\n if (lgPatternFound == NUMSYS_AND_CHECK_DIGIT_PATTERNS[numSys][d]) {\n resultString.insert(0, (char) ('0' + numSys));\n resultString.append((char) ('0' + d));\n return;\n }\n }\n }\n throw NotFoundException.getNotFoundInstance();\n }\n\n @Override\n BarcodeFormat getBarcodeFormat() {\n return BarcodeFormat.UPC_E;\n }\n\n /**\n * Expands a UPC-E value back into its full, equivalent UPC-A code value.\n *\n * @param upce UPC-E code as string of digits\n * @return equivalent UPC-A code as string of digits\n */\n public static String convertUPCEtoUPCA(String upce) {\n char[] upceChars = new char[6];\n upce.getChars(1, 7, upceChars, 0);\n StringBuilder result = new StringBuilder(12);\n result.append(upce.charAt(0));\n char lastChar = upceChars[5];\n switch (lastChar) {\n case '0':\n case '1':\n case '2':\n result.append(upceChars, 0, 2);\n result.append(lastChar);\n result.append(\"0000\");\n result.append(upceChars, 2, 3);\n break;\n case '3':\n result.append(upceChars, 0, 3);\n result.append(\"00000\");\n result.append(upceChars, 3, 2);\n break;\n case '4':\n result.append(upceChars, 0, 4);\n result.append(\"00000\");\n result.append(upceChars[4]);\n break;\n default:\n result.append(upceChars, 0, 5);\n result.append(\"0000\");\n result.append(lastChar);\n break;\n }\n // Only append check digit in conversion if supplied\n if (upce.length() >= 8) {\n result.append(upce.charAt(7));\n }\n return result.toString();\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/oned/UPCEWriter.java", "content": "/*\n * Copyright 2009 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.oned;\n\nimport java.util.Map;\n\nimport com.google.zxing.BarcodeFormat;\nimport com.google.zxing.EncodeHintType;\nimport com.google.zxing.FormatException;\nimport com.google.zxing.WriterException;\nimport com.google.zxing.common.BitMatrix;\n\n/**\n * This object renders an UPC-E code as a {@link BitMatrix}.\n *\n * @author 0979097955s@gmail.com (RX)\n */\npublic final class UPCEWriter extends UPCEANWriter {\n\n private static final int CODE_WIDTH = 3 + // start guard\n (7 * 6) + // bars\n 6; // end guard\n\n @Override\n public BitMatrix encode(String contents,\n BarcodeFormat format,\n int width,\n int height,\n MapThis class contains the methods for decoding the PDF417 codewords.
\n *\n * @author SITA Lab (kevin.osullivan@sita.aero)\n * @author Guenther Grau\n */\nfinal class DecodedBitStreamParser {\n\n private enum Mode {\n ALPHA,\n LOWER,\n MIXED,\n PUNCT,\n ALPHA_SHIFT,\n PUNCT_SHIFT\n }\n\n private static final int TEXT_COMPACTION_MODE_LATCH = 900;\n private static final int BYTE_COMPACTION_MODE_LATCH = 901;\n private static final int NUMERIC_COMPACTION_MODE_LATCH = 902;\n private static final int BYTE_COMPACTION_MODE_LATCH_6 = 924;\n private static final int ECI_USER_DEFINED = 925;\n private static final int ECI_GENERAL_PURPOSE = 926;\n private static final int ECI_CHARSET = 927;\n private static final int BEGIN_MACRO_PDF417_CONTROL_BLOCK = 928;\n private static final int BEGIN_MACRO_PDF417_OPTIONAL_FIELD = 923;\n private static final int MACRO_PDF417_TERMINATOR = 922;\n private static final int MODE_SHIFT_TO_BYTE_COMPACTION_MODE = 913;\n private static final int MAX_NUMERIC_CODEWORDS = 15;\n\n private static final int MACRO_PDF417_OPTIONAL_FIELD_FILE_NAME = 0;\n private static final int MACRO_PDF417_OPTIONAL_FIELD_SEGMENT_COUNT = 1;\n private static final int MACRO_PDF417_OPTIONAL_FIELD_TIME_STAMP = 2;\n private static final int MACRO_PDF417_OPTIONAL_FIELD_SENDER = 3;\n private static final int MACRO_PDF417_OPTIONAL_FIELD_ADDRESSEE = 4;\n private static final int MACRO_PDF417_OPTIONAL_FIELD_FILE_SIZE = 5;\n private static final int MACRO_PDF417_OPTIONAL_FIELD_CHECKSUM = 6;\n\n private static final int PL = 25;\n private static final int LL = 27;\n private static final int AS = 27;\n private static final int ML = 28;\n private static final int AL = 28;\n private static final int PS = 29;\n private static final int PAL = 29;\n\n private static final char[] PUNCT_CHARS =\n \";<>@[\\\\]_`~!\\r\\t,:\\n-.$/\\\"|*()?{}'\".toCharArray();\n\n private static final char[] MIXED_CHARS =\n \"0123456789&\\r\\t,:#-.$/+%*=^\".toCharArray();\n\n /**\n * Table containing values for the exponent of 900.\n * This is used in the numeric compaction decode algorithm.\n */\n private static final BigInteger[] EXP900;\n\n static {\n EXP900 = new BigInteger[16];\n EXP900[0] = BigInteger.ONE;\n BigInteger nineHundred = BigInteger.valueOf(900);\n EXP900[1] = nineHundred;\n for (int i = 2; i < EXP900.length; i++) {\n EXP900[i] = EXP900[i - 1].multiply(nineHundred);\n }\n }\n\n private static final int NUMBER_OF_SEQUENCE_CODEWORDS = 2;\n\n private DecodedBitStreamParser() {\n }\n\n static DecoderResult decode(int[] codewords, String ecLevel) throws FormatException {\n StringBuilder result = new StringBuilder(codewords.length * 2);\n Charset encoding = StandardCharsets.ISO_8859_1;\n // Get compaction mode\n int codeIndex = 1;\n int code = codewords[codeIndex++];\n PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata();\n while (codeIndex < codewords[0]) {\n switch (code) {\n case TEXT_COMPACTION_MODE_LATCH:\n codeIndex = textCompaction(codewords, codeIndex, result);\n break;\n case BYTE_COMPACTION_MODE_LATCH:\n case BYTE_COMPACTION_MODE_LATCH_6:\n codeIndex = byteCompaction(code, codewords, encoding, codeIndex, result);\n break;\n case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:\n result.append((char) codewords[codeIndex++]);\n break;\n case NUMERIC_COMPACTION_MODE_LATCH:\n codeIndex = numericCompaction(codewords, codeIndex, result);\n break;\n case ECI_CHARSET:\n CharacterSetECI charsetECI =\n CharacterSetECI.getCharacterSetECIByValue(codewords[codeIndex++]);\n encoding = Charset.forName(charsetECI.name());\n break;\n case ECI_GENERAL_PURPOSE:\n // Can't do anything with generic ECI; skip its 2 characters\n codeIndex += 2;\n break;\n case ECI_USER_DEFINED:\n // Can't do anything with user ECI; skip its 1 character\n codeIndex++;\n break;\n case BEGIN_MACRO_PDF417_CONTROL_BLOCK:\n codeIndex = decodeMacroBlock(codewords, codeIndex, resultMetadata);\n break;\n case BEGIN_MACRO_PDF417_OPTIONAL_FIELD:\n case MACRO_PDF417_TERMINATOR:\n // Should not see these outside a macro block\n throw FormatException.getFormatInstance();\n default:\n // Default to text compaction. During testing numerous barcodes\n // appeared to be missing the starting mode. In these cases defaulting\n // to text compaction seems to work.\n codeIndex--;\n codeIndex = textCompaction(codewords, codeIndex, result);\n break;\n }\n if (codeIndex < codewords.length) {\n code = codewords[codeIndex++];\n } else {\n throw FormatException.getFormatInstance();\n }\n }\n if (result.length() == 0) {\n throw FormatException.getFormatInstance();\n }\n DecoderResult decoderResult = new DecoderResult(null, result.toString(), null, ecLevel);\n decoderResult.setOther(resultMetadata);\n return decoderResult;\n }\n\n @SuppressWarnings(\"deprecation\")\n static int decodeMacroBlock(int[] codewords, int codeIndex, PDF417ResultMetadata resultMetadata)\n throws FormatException {\n if (codeIndex + NUMBER_OF_SEQUENCE_CODEWORDS > codewords[0]) {\n // we must have at least two bytes left for the segment index\n throw FormatException.getFormatInstance();\n }\n int[] segmentIndexArray = new int[NUMBER_OF_SEQUENCE_CODEWORDS];\n for (int i = 0; i < NUMBER_OF_SEQUENCE_CODEWORDS; i++, codeIndex++) {\n segmentIndexArray[i] = codewords[codeIndex];\n }\n resultMetadata.setSegmentIndex(Integer.parseInt(decodeBase900toBase10(segmentIndexArray,\n NUMBER_OF_SEQUENCE_CODEWORDS)));\n\n StringBuilder fileId = new StringBuilder();\n codeIndex = textCompaction(codewords, codeIndex, fileId);\n resultMetadata.setFileId(fileId.toString());\n\n int optionalFieldsStart = -1;\n if (codewords[codeIndex] == BEGIN_MACRO_PDF417_OPTIONAL_FIELD) {\n optionalFieldsStart = codeIndex + 1;\n }\n\n while (codeIndex < codewords[0]) {\n switch (codewords[codeIndex]) {\n case BEGIN_MACRO_PDF417_OPTIONAL_FIELD:\n codeIndex++;\n switch (codewords[codeIndex]) {\n case MACRO_PDF417_OPTIONAL_FIELD_FILE_NAME:\n StringBuilder fileName = new StringBuilder();\n codeIndex = textCompaction(codewords, codeIndex + 1, fileName);\n resultMetadata.setFileName(fileName.toString());\n break;\n case MACRO_PDF417_OPTIONAL_FIELD_SENDER:\n StringBuilder sender = new StringBuilder();\n codeIndex = textCompaction(codewords, codeIndex + 1, sender);\n resultMetadata.setSender(sender.toString());\n break;\n case MACRO_PDF417_OPTIONAL_FIELD_ADDRESSEE:\n StringBuilder addressee = new StringBuilder();\n codeIndex = textCompaction(codewords, codeIndex + 1, addressee);\n resultMetadata.setAddressee(addressee.toString());\n break;\n case MACRO_PDF417_OPTIONAL_FIELD_SEGMENT_COUNT:\n StringBuilder segmentCount = new StringBuilder();\n codeIndex = numericCompaction(codewords, codeIndex + 1, segmentCount);\n resultMetadata.setSegmentCount(Integer.parseInt(segmentCount.toString()));\n break;\n case MACRO_PDF417_OPTIONAL_FIELD_TIME_STAMP:\n StringBuilder timestamp = new StringBuilder();\n codeIndex = numericCompaction(codewords, codeIndex + 1, timestamp);\n resultMetadata.setTimestamp(Long.parseLong(timestamp.toString()));\n break;\n case MACRO_PDF417_OPTIONAL_FIELD_CHECKSUM:\n StringBuilder checksum = new StringBuilder();\n codeIndex = numericCompaction(codewords, codeIndex + 1, checksum);\n resultMetadata.setChecksum(Integer.parseInt(checksum.toString()));\n break;\n case MACRO_PDF417_OPTIONAL_FIELD_FILE_SIZE:\n StringBuilder fileSize = new StringBuilder();\n codeIndex = numericCompaction(codewords, codeIndex + 1, fileSize);\n resultMetadata.setFileSize(Long.parseLong(fileSize.toString()));\n break;\n default:\n throw FormatException.getFormatInstance();\n }\n break;\n case MACRO_PDF417_TERMINATOR:\n codeIndex++;\n resultMetadata.setLastSegment(true);\n break;\n default:\n throw FormatException.getFormatInstance();\n }\n }\n\n // copy optional fields to additional options\n if (optionalFieldsStart != -1) {\n int optionalFieldsLength = codeIndex - optionalFieldsStart;\n if (resultMetadata.isLastSegment()) {\n // do not include terminator\n optionalFieldsLength--;\n }\n resultMetadata.setOptionalData(Arrays.copyOfRange(codewords, optionalFieldsStart, optionalFieldsStart + optionalFieldsLength));\n }\n\n return codeIndex;\n }\n\n /**\n * Text Compaction mode (see 5.4.1.5) permits all printable ASCII characters to be\n * encoded, i.e. values 32 - 126 inclusive in accordance with ISO/IEC 646 (IRV), as\n * well as selected control characters.\n *\n * @param codewords The array of codewords (data + error)\n * @param codeIndex The current index into the codeword array.\n * @param result The decoded data is appended to the result.\n * @return The next index into the codeword array.\n */\n private static int textCompaction(int[] codewords, int codeIndex, StringBuilder result) {\n // 2 character per codeword\n int[] textCompactionData = new int[(codewords[0] - codeIndex) * 2];\n // Used to hold the byte compaction value if there is a mode shift\n int[] byteCompactionData = new int[(codewords[0] - codeIndex) * 2];\n\n int index = 0;\n boolean end = false;\n while ((codeIndex < codewords[0]) && !end) {\n int code = codewords[codeIndex++];\n if (code < TEXT_COMPACTION_MODE_LATCH) {\n textCompactionData[index] = code / 30;\n textCompactionData[index + 1] = code % 30;\n index += 2;\n } else {\n switch (code) {\n case TEXT_COMPACTION_MODE_LATCH:\n // reinitialize text compaction mode to alpha sub mode\n textCompactionData[index++] = TEXT_COMPACTION_MODE_LATCH;\n break;\n case BYTE_COMPACTION_MODE_LATCH:\n case BYTE_COMPACTION_MODE_LATCH_6:\n case NUMERIC_COMPACTION_MODE_LATCH:\n case BEGIN_MACRO_PDF417_CONTROL_BLOCK:\n case BEGIN_MACRO_PDF417_OPTIONAL_FIELD:\n case MACRO_PDF417_TERMINATOR:\n codeIndex--;\n end = true;\n break;\n case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:\n // The Mode Shift codeword 913 shall cause a temporary\n // switch from Text Compaction mode to Byte Compaction mode.\n // This switch shall be in effect for only the next codeword,\n // after which the mode shall revert to the prevailing sub-mode\n // of the Text Compaction mode. Codeword 913 is only available\n // in Text Compaction mode; its use is described in 5.4.2.4.\n textCompactionData[index] = MODE_SHIFT_TO_BYTE_COMPACTION_MODE;\n code = codewords[codeIndex++];\n byteCompactionData[index] = code;\n index++;\n break;\n }\n }\n }\n decodeTextCompaction(textCompactionData, byteCompactionData, index, result);\n return codeIndex;\n }\n\n /**\n * The Text Compaction mode includes all the printable ASCII characters\n * (i.e. values from 32 to 126) and three ASCII control characters: HT or tab\n * (ASCII value 9), LF or line feed (ASCII value 10), and CR or carriage\n * return (ASCII value 13). The Text Compaction mode also includes various latch\n * and shift characters which are used exclusively within the mode. The Text\n * Compaction mode encodes up to 2 characters per codeword. The compaction rules\n * for converting data into PDF417 codewords are defined in 5.4.2.2. The sub-mode\n * switches are defined in 5.4.2.3.\n *\n * @param textCompactionData The text compaction data.\n * @param byteCompactionData The byte compaction data if there\n * was a mode shift.\n * @param length The size of the text compaction and byte compaction data.\n * @param result The decoded data is appended to the result.\n */\n private static void decodeTextCompaction(int[] textCompactionData,\n int[] byteCompactionData,\n int length,\n StringBuilder result) {\n // Beginning from an initial state of the Alpha sub-mode\n // The default compaction mode for PDF417 in effect at the start of each symbol shall always be Text\n // Compaction mode Alpha sub-mode (uppercase alphabetic). A latch codeword from another mode to the Text\n // Compaction mode shall always switch to the Text Compaction Alpha sub-mode.\n Mode subMode = Mode.ALPHA;\n Mode priorToShiftMode = Mode.ALPHA;\n int i = 0;\n while (i < length) {\n int subModeCh = textCompactionData[i];\n char ch = 0;\n switch (subMode) {\n case ALPHA:\n // Alpha (uppercase alphabetic)\n if (subModeCh < 26) {\n // Upper case Alpha Character\n ch = (char) ('A' + subModeCh);\n } else {\n switch (subModeCh) {\n case 26:\n ch = ' ';\n break;\n case LL:\n subMode = Mode.LOWER;\n break;\n case ML:\n subMode = Mode.MIXED;\n break;\n case PS:\n // Shift to punctuation\n priorToShiftMode = subMode;\n subMode = Mode.PUNCT_SHIFT;\n break;\n case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:\n result.append((char) byteCompactionData[i]);\n break;\n case TEXT_COMPACTION_MODE_LATCH:\n subMode = Mode.ALPHA;\n break;\n }\n }\n break;\n\n case LOWER:\n // Lower (lowercase alphabetic)\n if (subModeCh < 26) {\n ch = (char) ('a' + subModeCh);\n } else {\n switch (subModeCh) {\n case 26:\n ch = ' ';\n break;\n case AS:\n // Shift to alpha\n priorToShiftMode = subMode;\n subMode = Mode.ALPHA_SHIFT;\n break;\n case ML:\n subMode = Mode.MIXED;\n break;\n case PS:\n // Shift to punctuation\n priorToShiftMode = subMode;\n subMode = Mode.PUNCT_SHIFT;\n break;\n case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:\n // TODO Does this need to use the current character encoding? See other occurrences below\n result.append((char) byteCompactionData[i]);\n break;\n case TEXT_COMPACTION_MODE_LATCH:\n subMode = Mode.ALPHA;\n break;\n }\n }\n break;\n\n case MIXED:\n // Mixed (numeric and some punctuation)\n if (subModeCh < PL) {\n ch = MIXED_CHARS[subModeCh];\n } else {\n switch (subModeCh) {\n case PL:\n subMode = Mode.PUNCT;\n break;\n case 26:\n ch = ' ';\n break;\n case LL:\n subMode = Mode.LOWER;\n break;\n case AL:\n subMode = Mode.ALPHA;\n break;\n case PS:\n // Shift to punctuation\n priorToShiftMode = subMode;\n subMode = Mode.PUNCT_SHIFT;\n break;\n case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:\n result.append((char) byteCompactionData[i]);\n break;\n case TEXT_COMPACTION_MODE_LATCH:\n subMode = Mode.ALPHA;\n break;\n }\n }\n break;\n\n case PUNCT:\n // Punctuation\n if (subModeCh < PAL) {\n ch = PUNCT_CHARS[subModeCh];\n } else {\n switch (subModeCh) {\n case PAL:\n subMode = Mode.ALPHA;\n break;\n case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:\n result.append((char) byteCompactionData[i]);\n break;\n case TEXT_COMPACTION_MODE_LATCH:\n subMode = Mode.ALPHA;\n break;\n }\n }\n break;\n\n case ALPHA_SHIFT:\n // Restore sub-mode\n subMode = priorToShiftMode;\n if (subModeCh < 26) {\n ch = (char) ('A' + subModeCh);\n } else {\n switch (subModeCh) {\n case 26:\n ch = ' ';\n break;\n case TEXT_COMPACTION_MODE_LATCH:\n subMode = Mode.ALPHA;\n break;\n }\n }\n break;\n\n case PUNCT_SHIFT:\n // Restore sub-mode\n subMode = priorToShiftMode;\n if (subModeCh < PAL) {\n ch = PUNCT_CHARS[subModeCh];\n } else {\n switch (subModeCh) {\n case PAL:\n subMode = Mode.ALPHA;\n break;\n case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:\n // PS before Shift-to-Byte is used as a padding character,\n // see 5.4.2.4 of the specification\n result.append((char) byteCompactionData[i]);\n break;\n case TEXT_COMPACTION_MODE_LATCH:\n subMode = Mode.ALPHA;\n break;\n }\n }\n break;\n }\n if (ch != 0) {\n // Append decoded character to result\n result.append(ch);\n }\n i++;\n }\n }\n\n /**\n * Byte Compaction mode (see 5.4.3) permits all 256 possible 8-bit byte values to be encoded.\n * This includes all ASCII characters value 0 to 127 inclusive and provides for international\n * character set support.\n *\n * @param mode The byte compaction mode i.e. 901 or 924\n * @param codewords The array of codewords (data + error)\n * @param encoding Currently active character encoding\n * @param codeIndex The current index into the codeword array.\n * @param result The decoded data is appended to the result.\n * @return The next index into the codeword array.\n */\n private static int byteCompaction(int mode,\n int[] codewords,\n Charset encoding,\n int codeIndex,\n StringBuilder result) {\n ByteArrayOutputStream decodedBytes = new ByteArrayOutputStream();\n int count = 0;\n long value = 0;\n boolean end = false;\n\n switch (mode) {\n case BYTE_COMPACTION_MODE_LATCH:\n // Total number of Byte Compaction characters to be encoded\n // is not a multiple of 6\n\n int[] byteCompactedCodewords = new int[6];\n int nextCode = codewords[codeIndex++];\n while ((codeIndex < codewords[0]) && !end) {\n byteCompactedCodewords[count++] = nextCode;\n // Base 900\n value = 900 * value + nextCode;\n nextCode = codewords[codeIndex++];\n // perhaps it should be ok to check only nextCode >= TEXT_COMPACTION_MODE_LATCH\n switch (nextCode) {\n case TEXT_COMPACTION_MODE_LATCH:\n case BYTE_COMPACTION_MODE_LATCH:\n case NUMERIC_COMPACTION_MODE_LATCH:\n case BYTE_COMPACTION_MODE_LATCH_6:\n case BEGIN_MACRO_PDF417_CONTROL_BLOCK:\n case BEGIN_MACRO_PDF417_OPTIONAL_FIELD:\n case MACRO_PDF417_TERMINATOR:\n codeIndex--;\n end = true;\n break;\n default:\n if ((count % 5 == 0) && (count > 0)) {\n // Decode every 5 codewords\n // Convert to Base 256\n for (int j = 0; j < 6; ++j) {\n decodedBytes.write((byte) (value >> (8 * (5 - j))));\n }\n value = 0;\n count = 0;\n }\n break;\n }\n }\n\n // if the end of all codewords is reached the last codeword needs to be added\n if (codeIndex == codewords[0] && nextCode < TEXT_COMPACTION_MODE_LATCH) {\n byteCompactedCodewords[count++] = nextCode;\n }\n\n // If Byte Compaction mode is invoked with codeword 901,\n // the last group of codewords is interpreted directly\n // as one byte per codeword, without compaction.\n for (int i = 0; i < count; i++) {\n decodedBytes.write((byte) byteCompactedCodewords[i]);\n }\n\n break;\n\n case BYTE_COMPACTION_MODE_LATCH_6:\n // Total number of Byte Compaction characters to be encoded\n // is an integer multiple of 6\n while (codeIndex < codewords[0] && !end) {\n int code = codewords[codeIndex++];\n if (code < TEXT_COMPACTION_MODE_LATCH) {\n count++;\n // Base 900\n value = 900 * value + code;\n } else {\n switch (code) {\n case TEXT_COMPACTION_MODE_LATCH:\n case BYTE_COMPACTION_MODE_LATCH:\n case NUMERIC_COMPACTION_MODE_LATCH:\n case BYTE_COMPACTION_MODE_LATCH_6:\n case BEGIN_MACRO_PDF417_CONTROL_BLOCK:\n case BEGIN_MACRO_PDF417_OPTIONAL_FIELD:\n case MACRO_PDF417_TERMINATOR:\n codeIndex--;\n end = true;\n break;\n }\n }\n if ((count % 5 == 0) && (count > 0)) {\n // Decode every 5 codewords\n // Convert to Base 256\n for (int j = 0; j < 6; ++j) {\n decodedBytes.write((byte) (value >> (8 * (5 - j))));\n }\n value = 0;\n count = 0;\n }\n }\n break;\n }\n result.append(new String(decodedBytes.toByteArray(), encoding));\n return codeIndex;\n }\n\n /**\n * Numeric Compaction mode (see 5.4.4) permits efficient encoding of numeric data strings.\n *\n * @param codewords The array of codewords (data + error)\n * @param codeIndex The current index into the codeword array.\n * @param result The decoded data is appended to the result.\n * @return The next index into the codeword array.\n */\n private static int numericCompaction(int[] codewords, int codeIndex, StringBuilder result) throws FormatException {\n int count = 0;\n boolean end = false;\n\n int[] numericCodewords = new int[MAX_NUMERIC_CODEWORDS];\n\n while (codeIndex < codewords[0] && !end) {\n int code = codewords[codeIndex++];\n if (codeIndex == codewords[0]) {\n end = true;\n }\n if (code < TEXT_COMPACTION_MODE_LATCH) {\n numericCodewords[count] = code;\n count++;\n } else {\n switch (code) {\n case TEXT_COMPACTION_MODE_LATCH:\n case BYTE_COMPACTION_MODE_LATCH:\n case BYTE_COMPACTION_MODE_LATCH_6:\n case BEGIN_MACRO_PDF417_CONTROL_BLOCK:\n case BEGIN_MACRO_PDF417_OPTIONAL_FIELD:\n case MACRO_PDF417_TERMINATOR:\n codeIndex--;\n end = true;\n break;\n }\n }\n if ((count % MAX_NUMERIC_CODEWORDS == 0 || code == NUMERIC_COMPACTION_MODE_LATCH || end) && count > 0) {\n // Re-invoking Numeric Compaction mode (by using codeword 902\n // while in Numeric Compaction mode) serves to terminate the\n // current Numeric Compaction mode grouping as described in 5.4.4.2,\n // and then to start a new one grouping.\n result.append(decodeBase900toBase10(numericCodewords, count));\n count = 0;\n }\n }\n return codeIndex;\n }\n\n /**\n * Convert a list of Numeric Compacted codewords from Base 900 to Base 10.\n *\n * @param codewords The array of codewords\n * @param count The number of codewords\n * @return The decoded string representing the Numeric data.\n */\n /*\n EXAMPLE\n Encode the fifteen digit numeric string 000213298174000\n Prefix the numeric string with a 1 and set the initial value of\n t = 1 000 213 298 174 000\n Calculate codeword 0\n d0 = 1 000 213 298 174 000 mod 900 = 200\n\n t = 1 000 213 298 174 000 div 900 = 1 111 348 109 082\n Calculate codeword 1\n d1 = 1 111 348 109 082 mod 900 = 282\n\n t = 1 111 348 109 082 div 900 = 1 234 831 232\n Calculate codeword 2\n d2 = 1 234 831 232 mod 900 = 632\n\n t = 1 234 831 232 div 900 = 1 372 034\n Calculate codeword 3\n d3 = 1 372 034 mod 900 = 434\n\n t = 1 372 034 div 900 = 1 524\n Calculate codeword 4\n d4 = 1 524 mod 900 = 624\n\n t = 1 524 div 900 = 1\n Calculate codeword 5\n d5 = 1 mod 900 = 1\n t = 1 div 900 = 0\n Codeword sequence is: 1, 624, 434, 632, 282, 200\n\n Decode the above codewords involves\n 1 x 900 power of 5 + 624 x 900 power of 4 + 434 x 900 power of 3 +\n 632 x 900 power of 2 + 282 x 900 power of 1 + 200 x 900 power of 0 = 1000213298174000\n\n Remove leading 1 => Result is 000213298174000\n */\n private static String decodeBase900toBase10(int[] codewords, int count) throws FormatException {\n BigInteger result = BigInteger.ZERO;\n for (int i = 0; i < count; i++) {\n result = result.add(EXP900[count - i - 1].multiply(BigInteger.valueOf(codewords[i])));\n }\n String resultString = result.toString();\n if (resultString.charAt(0) != '1') {\n throw FormatException.getFormatInstance();\n }\n return resultString.substring(1);\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/pdf417/decoder/DetectionResult.java", "content": "/*\n * Copyright 2013 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.pdf417.decoder;\n\nimport com.google.zxing.pdf417.PDF417Common;\n\nimport java.util.Formatter;\n\n/**\n * @author Guenther Grau\n */\nfinal class DetectionResult {\n\n private static final int ADJUST_ROW_NUMBER_SKIP = 2;\n\n private final BarcodeMetadata barcodeMetadata;\n private final DetectionResultColumn[] detectionResultColumns;\n private BoundingBox boundingBox;\n private final int barcodeColumnCount;\n\n DetectionResult(BarcodeMetadata barcodeMetadata, BoundingBox boundingBox) {\n this.barcodeMetadata = barcodeMetadata;\n this.barcodeColumnCount = barcodeMetadata.getColumnCount();\n this.boundingBox = boundingBox;\n detectionResultColumns = new DetectionResultColumn[barcodeColumnCount + 2];\n }\n\n DetectionResultColumn[] getDetectionResultColumns() {\n adjustIndicatorColumnRowNumbers(detectionResultColumns[0]);\n adjustIndicatorColumnRowNumbers(detectionResultColumns[barcodeColumnCount + 1]);\n int unadjustedCodewordCount = PDF417Common.MAX_CODEWORDS_IN_BARCODE;\n int previousUnadjustedCount;\n do {\n previousUnadjustedCount = unadjustedCodewordCount;\n unadjustedCodewordCount = adjustRowNumbers();\n } while (unadjustedCodewordCount > 0 && unadjustedCodewordCount < previousUnadjustedCount);\n return detectionResultColumns;\n }\n\n private void adjustIndicatorColumnRowNumbers(DetectionResultColumn detectionResultColumn) {\n if (detectionResultColumn != null) {\n ((DetectionResultRowIndicatorColumn) detectionResultColumn)\n .adjustCompleteIndicatorColumnRowNumbers(barcodeMetadata);\n }\n }\n\n // TODO ensure that no detected codewords with unknown row number are left\n // we should be able to estimate the row height and use it as a hint for the row number\n // we should also fill the rows top to bottom and bottom to top\n /**\n * @return number of codewords which don't have a valid row number. Note that the count is not accurate as codewords\n * will be counted several times. It just serves as an indicator to see when we can stop adjusting row numbers\n */\n private int adjustRowNumbers() {\n int unadjustedCount = adjustRowNumbersByRow();\n if (unadjustedCount == 0) {\n return 0;\n }\n for (int barcodeColumn = 1; barcodeColumn < barcodeColumnCount + 1; barcodeColumn++) {\n Codeword[] codewords = detectionResultColumns[barcodeColumn].getCodewords();\n for (int codewordsRow = 0; codewordsRow < codewords.length; codewordsRow++) {\n if (codewords[codewordsRow] == null) {\n continue;\n }\n if (!codewords[codewordsRow].hasValidRowNumber()) {\n adjustRowNumbers(barcodeColumn, codewordsRow, codewords);\n }\n }\n }\n return unadjustedCount;\n }\n\n private int adjustRowNumbersByRow() {\n adjustRowNumbersFromBothRI();\n // TODO we should only do full row adjustments if row numbers of left and right row indicator column match.\n // Maybe it's even better to calculated the height (in codeword rows) and divide it by the number of barcode\n // rows. This, together with the LRI and RRI row numbers should allow us to get a good estimate where a row\n // number starts and ends.\n int unadjustedCount = adjustRowNumbersFromLRI();\n return unadjustedCount + adjustRowNumbersFromRRI();\n }\n\n private void adjustRowNumbersFromBothRI() {\n if (detectionResultColumns[0] == null || detectionResultColumns[barcodeColumnCount + 1] == null) {\n return;\n }\n Codeword[] LRIcodewords = detectionResultColumns[0].getCodewords();\n Codeword[] RRIcodewords = detectionResultColumns[barcodeColumnCount + 1].getCodewords();\n for (int codewordsRow = 0; codewordsRow < LRIcodewords.length; codewordsRow++) {\n if (LRIcodewords[codewordsRow] != null &&\n RRIcodewords[codewordsRow] != null &&\n LRIcodewords[codewordsRow].getRowNumber() == RRIcodewords[codewordsRow].getRowNumber()) {\n for (int barcodeColumn = 1; barcodeColumn <= barcodeColumnCount; barcodeColumn++) {\n Codeword codeword = detectionResultColumns[barcodeColumn].getCodewords()[codewordsRow];\n if (codeword == null) {\n continue;\n }\n codeword.setRowNumber(LRIcodewords[codewordsRow].getRowNumber());\n if (!codeword.hasValidRowNumber()) {\n detectionResultColumns[barcodeColumn].getCodewords()[codewordsRow] = null;\n }\n }\n }\n }\n }\n\n private int adjustRowNumbersFromRRI() {\n if (detectionResultColumns[barcodeColumnCount + 1] == null) {\n return 0;\n }\n int unadjustedCount = 0;\n Codeword[] codewords = detectionResultColumns[barcodeColumnCount + 1].getCodewords();\n for (int codewordsRow = 0; codewordsRow < codewords.length; codewordsRow++) {\n if (codewords[codewordsRow] == null) {\n continue;\n }\n int rowIndicatorRowNumber = codewords[codewordsRow].getRowNumber();\n int invalidRowCounts = 0;\n for (int barcodeColumn = barcodeColumnCount + 1; barcodeColumn > 0 && invalidRowCounts < ADJUST_ROW_NUMBER_SKIP; barcodeColumn--) {\n Codeword codeword = detectionResultColumns[barcodeColumn].getCodewords()[codewordsRow];\n if (codeword != null) {\n invalidRowCounts = adjustRowNumberIfValid(rowIndicatorRowNumber, invalidRowCounts, codeword);\n if (!codeword.hasValidRowNumber()) {\n unadjustedCount++;\n }\n }\n }\n }\n return unadjustedCount;\n }\n\n private int adjustRowNumbersFromLRI() {\n if (detectionResultColumns[0] == null) {\n return 0;\n }\n int unadjustedCount = 0;\n Codeword[] codewords = detectionResultColumns[0].getCodewords();\n for (int codewordsRow = 0; codewordsRow < codewords.length; codewordsRow++) {\n if (codewords[codewordsRow] == null) {\n continue;\n }\n int rowIndicatorRowNumber = codewords[codewordsRow].getRowNumber();\n int invalidRowCounts = 0;\n for (int barcodeColumn = 1; barcodeColumn < barcodeColumnCount + 1 && invalidRowCounts < ADJUST_ROW_NUMBER_SKIP; barcodeColumn++) {\n Codeword codeword = detectionResultColumns[barcodeColumn].getCodewords()[codewordsRow];\n if (codeword != null) {\n invalidRowCounts = adjustRowNumberIfValid(rowIndicatorRowNumber, invalidRowCounts, codeword);\n if (!codeword.hasValidRowNumber()) {\n unadjustedCount++;\n }\n }\n }\n }\n return unadjustedCount;\n }\n\n private static int adjustRowNumberIfValid(int rowIndicatorRowNumber, int invalidRowCounts, Codeword codeword) {\n if (codeword == null) {\n return invalidRowCounts;\n }\n if (!codeword.hasValidRowNumber()) {\n if (codeword.isValidRowNumber(rowIndicatorRowNumber)) {\n codeword.setRowNumber(rowIndicatorRowNumber);\n invalidRowCounts = 0;\n } else {\n ++invalidRowCounts;\n }\n }\n return invalidRowCounts;\n }\n\n private void adjustRowNumbers(int barcodeColumn, int codewordsRow, Codeword[] codewords) {\n Codeword codeword = codewords[codewordsRow];\n Codeword[] previousColumnCodewords = detectionResultColumns[barcodeColumn - 1].getCodewords();\n Codeword[] nextColumnCodewords = previousColumnCodewords;\n if (detectionResultColumns[barcodeColumn + 1] != null) {\n nextColumnCodewords = detectionResultColumns[barcodeColumn + 1].getCodewords();\n }\n\n Codeword[] otherCodewords = new Codeword[14];\n\n otherCodewords[2] = previousColumnCodewords[codewordsRow];\n otherCodewords[3] = nextColumnCodewords[codewordsRow];\n\n if (codewordsRow > 0) {\n otherCodewords[0] = codewords[codewordsRow - 1];\n otherCodewords[4] = previousColumnCodewords[codewordsRow - 1];\n otherCodewords[5] = nextColumnCodewords[codewordsRow - 1];\n }\n if (codewordsRow > 1) {\n otherCodewords[8] = codewords[codewordsRow - 2];\n otherCodewords[10] = previousColumnCodewords[codewordsRow - 2];\n otherCodewords[11] = nextColumnCodewords[codewordsRow - 2];\n }\n if (codewordsRow < codewords.length - 1) {\n otherCodewords[1] = codewords[codewordsRow + 1];\n otherCodewords[6] = previousColumnCodewords[codewordsRow + 1];\n otherCodewords[7] = nextColumnCodewords[codewordsRow + 1];\n }\n if (codewordsRow < codewords.length - 2) {\n otherCodewords[9] = codewords[codewordsRow + 2];\n otherCodewords[12] = previousColumnCodewords[codewordsRow + 2];\n otherCodewords[13] = nextColumnCodewords[codewordsRow + 2];\n }\n for (Codeword otherCodeword : otherCodewords) {\n if (adjustRowNumber(codeword, otherCodeword)) {\n return;\n }\n }\n }\n\n /**\n * @return true, if row number was adjusted, false otherwise\n */\n private static boolean adjustRowNumber(Codeword codeword, Codeword otherCodeword) {\n if (otherCodeword == null) {\n return false;\n }\n if (otherCodeword.hasValidRowNumber() && otherCodeword.getBucket() == codeword.getBucket()) {\n codeword.setRowNumber(otherCodeword.getRowNumber());\n return true;\n }\n return false;\n }\n\n int getBarcodeColumnCount() {\n return barcodeColumnCount;\n }\n\n int getBarcodeRowCount() {\n return barcodeMetadata.getRowCount();\n }\n\n int getBarcodeECLevel() {\n return barcodeMetadata.getErrorCorrectionLevel();\n }\n\n void setBoundingBox(BoundingBox boundingBox) {\n this.boundingBox = boundingBox;\n }\n\n BoundingBox getBoundingBox() {\n return boundingBox;\n }\n\n void setDetectionResultColumn(int barcodeColumn, DetectionResultColumn detectionResultColumn) {\n detectionResultColumns[barcodeColumn] = detectionResultColumn;\n }\n\n DetectionResultColumn getDetectionResultColumn(int barcodeColumn) {\n return detectionResultColumns[barcodeColumn];\n }\n\n @Override\n public String toString() {\n DetectionResultColumn rowIndicatorColumn = detectionResultColumns[0];\n if (rowIndicatorColumn == null) {\n rowIndicatorColumn = detectionResultColumns[barcodeColumnCount + 1];\n }\n try (Formatter formatter = new Formatter()) {\n for (int codewordsRow = 0; codewordsRow < rowIndicatorColumn.getCodewords().length; codewordsRow++) {\n formatter.format(\"CW %3d:\", codewordsRow);\n for (int barcodeColumn = 0; barcodeColumn < barcodeColumnCount + 2; barcodeColumn++) {\n if (detectionResultColumns[barcodeColumn] == null) {\n formatter.format(\" | \");\n continue;\n }\n Codeword codeword = detectionResultColumns[barcodeColumn].getCodewords()[codewordsRow];\n if (codeword == null) {\n formatter.format(\" | \");\n continue;\n }\n formatter.format(\" %3d|%3d\", codeword.getRowNumber(), codeword.getValue());\n }\n formatter.format(\"%n\");\n }\n return formatter.toString();\n }\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/pdf417/decoder/DetectionResultColumn.java", "content": "/*\n * Copyright 2013 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.pdf417.decoder;\n\nimport java.util.Formatter;\n\n/**\n * @author Guenther Grau\n */\nclass DetectionResultColumn {\n\n private static final int MAX_NEARBY_DISTANCE = 5;\n\n private final BoundingBox boundingBox;\n private final Codeword[] codewords;\n\n DetectionResultColumn(BoundingBox boundingBox) {\n this.boundingBox = new BoundingBox(boundingBox);\n codewords = new Codeword[boundingBox.getMaxY() - boundingBox.getMinY() + 1];\n }\n\n final Codeword getCodewordNearby(int imageRow) {\n Codeword codeword = getCodeword(imageRow);\n if (codeword != null) {\n return codeword;\n }\n for (int i = 1; i < MAX_NEARBY_DISTANCE; i++) {\n int nearImageRow = imageRowToCodewordIndex(imageRow) - i;\n if (nearImageRow >= 0) {\n codeword = codewords[nearImageRow];\n if (codeword != null) {\n return codeword;\n }\n }\n nearImageRow = imageRowToCodewordIndex(imageRow) + i;\n if (nearImageRow < codewords.length) {\n codeword = codewords[nearImageRow];\n if (codeword != null) {\n return codeword;\n }\n }\n }\n return null;\n }\n\n final int imageRowToCodewordIndex(int imageRow) {\n return imageRow - boundingBox.getMinY();\n }\n\n final void setCodeword(int imageRow, Codeword codeword) {\n codewords[imageRowToCodewordIndex(imageRow)] = codeword;\n }\n\n final Codeword getCodeword(int imageRow) {\n return codewords[imageRowToCodewordIndex(imageRow)];\n }\n\n final BoundingBox getBoundingBox() {\n return boundingBox;\n }\n\n final Codeword[] getCodewords() {\n return codewords;\n }\n\n @Override\n public String toString() {\n try (Formatter formatter = new Formatter()) {\n int row = 0;\n for (Codeword codeword : codewords) {\n if (codeword == null) {\n formatter.format(\"%3d: | %n\", row++);\n continue;\n }\n formatter.format(\"%3d: %3d|%3d%n\", row++, codeword.getRowNumber(), codeword.getValue());\n }\n return formatter.toString();\n }\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/pdf417/decoder/DetectionResultRowIndicatorColumn.java", "content": "/*\n * Copyright 2013 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.pdf417.decoder;\n\nimport com.google.zxing.ResultPoint;\nimport com.google.zxing.pdf417.PDF417Common;\n\n/**\n * @author Guenther Grau\n */\nfinal class DetectionResultRowIndicatorColumn extends DetectionResultColumn {\n\n private final boolean isLeft;\n\n DetectionResultRowIndicatorColumn(BoundingBox boundingBox, boolean isLeft) {\n super(boundingBox);\n this.isLeft = isLeft;\n }\n\n private void setRowNumbers() {\n for (Codeword codeword : getCodewords()) {\n if (codeword != null) {\n codeword.setRowNumberAsRowIndicatorColumn();\n }\n }\n }\n\n // TODO implement properly\n // TODO maybe we should add missing codewords to store the correct row number to make\n // finding row numbers for other columns easier\n // use row height count to make detection of invalid row numbers more reliable\n void adjustCompleteIndicatorColumnRowNumbers(BarcodeMetadata barcodeMetadata) {\n Codeword[] codewords = getCodewords();\n setRowNumbers();\n removeIncorrectCodewords(codewords, barcodeMetadata);\n BoundingBox boundingBox = getBoundingBox();\n ResultPoint top = isLeft ? boundingBox.getTopLeft() : boundingBox.getTopRight();\n ResultPoint bottom = isLeft ? boundingBox.getBottomLeft() : boundingBox.getBottomRight();\n int firstRow = imageRowToCodewordIndex((int) top.getY());\n int lastRow = imageRowToCodewordIndex((int) bottom.getY());\n // We need to be careful using the average row height. Barcode could be skewed so that we have smaller and\n // taller rows\n //float averageRowHeight = (lastRow - firstRow) / (float) barcodeMetadata.getRowCount();\n int barcodeRow = -1;\n int maxRowHeight = 1;\n int currentRowHeight = 0;\n for (int codewordsRow = firstRow; codewordsRow < lastRow; codewordsRow++) {\n if (codewords[codewordsRow] == null) {\n continue;\n }\n Codeword codeword = codewords[codewordsRow];\n\n // float expectedRowNumber = (codewordsRow - firstRow) / averageRowHeight;\n // if (Math.abs(codeword.getRowNumber() - expectedRowNumber) > 2) {\n // SimpleLog.log(LEVEL.WARNING,\n // \"Removing codeword, rowNumberSkew too high, codeword[\" + codewordsRow + \"]: Expected Row: \" +\n // expectedRowNumber + \", RealRow: \" + codeword.getRowNumber() + \", value: \" + codeword.getValue());\n // codewords[codewordsRow] = null;\n // }\n\n int rowDifference = codeword.getRowNumber() - barcodeRow;\n\n // TODO improve handling with case where first row indicator doesn't start with 0\n\n if (rowDifference == 0) {\n currentRowHeight++;\n } else if (rowDifference == 1) {\n maxRowHeight = Math.max(maxRowHeight, currentRowHeight);\n currentRowHeight = 1;\n barcodeRow = codeword.getRowNumber();\n } else if (rowDifference < 0 ||\n codeword.getRowNumber() >= barcodeMetadata.getRowCount() ||\n rowDifference > codewordsRow) {\n codewords[codewordsRow] = null;\n } else {\n int checkedRows;\n if (maxRowHeight > 2) {\n checkedRows = (maxRowHeight - 2) * rowDifference;\n } else {\n checkedRows = rowDifference;\n }\n boolean closePreviousCodewordFound = checkedRows >= codewordsRow;\n for (int i = 1; i <= checkedRows && !closePreviousCodewordFound; i++) {\n // there must be (height * rowDifference) number of codewords missing. For now we assume height = 1.\n // This should hopefully get rid of most problems already.\n closePreviousCodewordFound = codewords[codewordsRow - i] != null;\n }\n if (closePreviousCodewordFound) {\n codewords[codewordsRow] = null;\n } else {\n barcodeRow = codeword.getRowNumber();\n currentRowHeight = 1;\n }\n }\n }\n //return (int) (averageRowHeight + 0.5);\n }\n\n int[] getRowHeights() {\n BarcodeMetadata barcodeMetadata = getBarcodeMetadata();\n if (barcodeMetadata == null) {\n return null;\n }\n adjustIncompleteIndicatorColumnRowNumbers(barcodeMetadata);\n int[] result = new int[barcodeMetadata.getRowCount()];\n for (Codeword codeword : getCodewords()) {\n if (codeword != null) {\n int rowNumber = codeword.getRowNumber();\n if (rowNumber >= result.length) {\n // We have more rows than the barcode metadata allows for, ignore them.\n continue;\n }\n result[rowNumber]++;\n } // else throw exception?\n }\n return result;\n }\n\n // TODO maybe we should add missing codewords to store the correct row number to make\n // finding row numbers for other columns easier\n // use row height count to make detection of invalid row numbers more reliable\n private void adjustIncompleteIndicatorColumnRowNumbers(BarcodeMetadata barcodeMetadata) {\n BoundingBox boundingBox = getBoundingBox();\n ResultPoint top = isLeft ? boundingBox.getTopLeft() : boundingBox.getTopRight();\n ResultPoint bottom = isLeft ? boundingBox.getBottomLeft() : boundingBox.getBottomRight();\n int firstRow = imageRowToCodewordIndex((int) top.getY());\n int lastRow = imageRowToCodewordIndex((int) bottom.getY());\n //float averageRowHeight = (lastRow - firstRow) / (float) barcodeMetadata.getRowCount();\n Codeword[] codewords = getCodewords();\n int barcodeRow = -1;\n int maxRowHeight = 1;\n int currentRowHeight = 0;\n for (int codewordsRow = firstRow; codewordsRow < lastRow; codewordsRow++) {\n if (codewords[codewordsRow] == null) {\n continue;\n }\n Codeword codeword = codewords[codewordsRow];\n\n codeword.setRowNumberAsRowIndicatorColumn();\n\n int rowDifference = codeword.getRowNumber() - barcodeRow;\n\n // TODO improve handling with case where first row indicator doesn't start with 0\n\n if (rowDifference == 0) {\n currentRowHeight++;\n } else if (rowDifference == 1) {\n maxRowHeight = Math.max(maxRowHeight, currentRowHeight);\n currentRowHeight = 1;\n barcodeRow = codeword.getRowNumber();\n } else if (codeword.getRowNumber() >= barcodeMetadata.getRowCount()) {\n codewords[codewordsRow] = null;\n } else {\n barcodeRow = codeword.getRowNumber();\n currentRowHeight = 1;\n }\n }\n //return (int) (averageRowHeight + 0.5);\n }\n\n BarcodeMetadata getBarcodeMetadata() {\n Codeword[] codewords = getCodewords();\n BarcodeValue barcodeColumnCount = new BarcodeValue();\n BarcodeValue barcodeRowCountUpperPart = new BarcodeValue();\n BarcodeValue barcodeRowCountLowerPart = new BarcodeValue();\n BarcodeValue barcodeECLevel = new BarcodeValue();\n for (Codeword codeword : codewords) {\n if (codeword == null) {\n continue;\n }\n codeword.setRowNumberAsRowIndicatorColumn();\n int rowIndicatorValue = codeword.getValue() % 30;\n int codewordRowNumber = codeword.getRowNumber();\n if (!isLeft) {\n codewordRowNumber += 2;\n }\n switch (codewordRowNumber % 3) {\n case 0:\n barcodeRowCountUpperPart.setValue(rowIndicatorValue * 3 + 1);\n break;\n case 1:\n barcodeECLevel.setValue(rowIndicatorValue / 3);\n barcodeRowCountLowerPart.setValue(rowIndicatorValue % 3);\n break;\n case 2:\n barcodeColumnCount.setValue(rowIndicatorValue + 1);\n break;\n }\n }\n // Maybe we should check if we have ambiguous values?\n if ((barcodeColumnCount.getValue().length == 0) ||\n (barcodeRowCountUpperPart.getValue().length == 0) ||\n (barcodeRowCountLowerPart.getValue().length == 0) ||\n (barcodeECLevel.getValue().length == 0) ||\n barcodeColumnCount.getValue()[0] < 1 ||\n barcodeRowCountUpperPart.getValue()[0] + barcodeRowCountLowerPart.getValue()[0] < PDF417Common.MIN_ROWS_IN_BARCODE ||\n barcodeRowCountUpperPart.getValue()[0] + barcodeRowCountLowerPart.getValue()[0] > PDF417Common.MAX_ROWS_IN_BARCODE) {\n return null;\n }\n BarcodeMetadata barcodeMetadata = new BarcodeMetadata(barcodeColumnCount.getValue()[0],\n barcodeRowCountUpperPart.getValue()[0], barcodeRowCountLowerPart.getValue()[0], barcodeECLevel.getValue()[0]);\n removeIncorrectCodewords(codewords, barcodeMetadata);\n return barcodeMetadata;\n }\n\n private void removeIncorrectCodewords(Codeword[] codewords, BarcodeMetadata barcodeMetadata) {\n // Remove codewords which do not match the metadata\n // TODO Maybe we should keep the incorrect codewords for the start and end positions?\n for (int codewordRow = 0; codewordRow < codewords.length; codewordRow++) {\n Codeword codeword = codewords[codewordRow];\n if (codewords[codewordRow] == null) {\n continue;\n }\n int rowIndicatorValue = codeword.getValue() % 30;\n int codewordRowNumber = codeword.getRowNumber();\n if (codewordRowNumber > barcodeMetadata.getRowCount()) {\n codewords[codewordRow] = null;\n continue;\n }\n if (!isLeft) {\n codewordRowNumber += 2;\n }\n switch (codewordRowNumber % 3) {\n case 0:\n if (rowIndicatorValue * 3 + 1 != barcodeMetadata.getRowCountUpperPart()) {\n codewords[codewordRow] = null;\n }\n break;\n case 1:\n if (rowIndicatorValue / 3 != barcodeMetadata.getErrorCorrectionLevel() ||\n rowIndicatorValue % 3 != barcodeMetadata.getRowCountLowerPart()) {\n codewords[codewordRow] = null;\n }\n break;\n case 2:\n if (rowIndicatorValue + 1 != barcodeMetadata.getColumnCount()) {\n codewords[codewordRow] = null;\n }\n break;\n }\n }\n }\n\n boolean isLeft() {\n return isLeft;\n }\n\n @Override\n public String toString() {\n return \"IsLeft: \" + isLeft + '\\n' + super.toString();\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/pdf417/decoder/PDF417CodewordDecoder.java", "content": "/*\n * Copyright 2013 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.pdf417.decoder;\n\nimport com.google.zxing.common.detector.MathUtils;\nimport com.google.zxing.pdf417.PDF417Common;\n\n/**\n * @author Guenther Grau\n * @author creatale GmbH (christoph.schulz@creatale.de)\n */\nfinal class PDF417CodewordDecoder {\n\n private static final float[][] RATIOS_TABLE =\n new float[PDF417Common.SYMBOL_TABLE.length][PDF417Common.BARS_IN_MODULE];\n\n static {\n // Pre-computes the symbol ratio table.\n for (int i = 0; i < PDF417Common.SYMBOL_TABLE.length; i++) {\n int currentSymbol = PDF417Common.SYMBOL_TABLE[i];\n int currentBit = currentSymbol & 0x1;\n for (int j = 0; j < PDF417Common.BARS_IN_MODULE; j++) {\n float size = 0.0f;\n while ((currentSymbol & 0x1) == currentBit) {\n size += 1.0f;\n currentSymbol >>= 1;\n }\n currentBit = currentSymbol & 0x1;\n RATIOS_TABLE[i][PDF417Common.BARS_IN_MODULE - j - 1] = size / PDF417Common.MODULES_IN_CODEWORD;\n }\n }\n }\n\n private PDF417CodewordDecoder() {\n }\n\n static int getDecodedValue(int[] moduleBitCount) {\n int decodedValue = getDecodedCodewordValue(sampleBitCounts(moduleBitCount));\n if (decodedValue != -1) {\n return decodedValue;\n }\n return getClosestDecodedValue(moduleBitCount);\n }\n\n private static int[] sampleBitCounts(int[] moduleBitCount) {\n float bitCountSum = MathUtils.sum(moduleBitCount);\n int[] result = new int[PDF417Common.BARS_IN_MODULE];\n int bitCountIndex = 0;\n int sumPreviousBits = 0;\n for (int i = 0; i < PDF417Common.MODULES_IN_CODEWORD; i++) {\n float sampleIndex = \n bitCountSum / (2 * PDF417Common.MODULES_IN_CODEWORD) +\n (i * bitCountSum) / PDF417Common.MODULES_IN_CODEWORD;\n if (sumPreviousBits + moduleBitCount[bitCountIndex] <= sampleIndex) {\n sumPreviousBits += moduleBitCount[bitCountIndex];\n bitCountIndex++;\n }\n result[bitCountIndex]++;\n }\n return result;\n }\n\n private static int getDecodedCodewordValue(int[] moduleBitCount) {\n int decodedValue = getBitValue(moduleBitCount);\n return PDF417Common.getCodeword(decodedValue) == -1 ? -1 : decodedValue;\n }\n\n private static int getBitValue(int[] moduleBitCount) {\n long result = 0;\n for (int i = 0; i < moduleBitCount.length; i++) {\n for (int bit = 0; bit < moduleBitCount[i]; bit++) {\n result = (result << 1) | (i % 2 == 0 ? 1 : 0);\n }\n }\n return (int) result;\n }\n\n private static int getClosestDecodedValue(int[] moduleBitCount) {\n int bitCountSum = MathUtils.sum(moduleBitCount);\n float[] bitCountRatios = new float[PDF417Common.BARS_IN_MODULE];\n if (bitCountSum > 1) {\n for (int i = 0; i < bitCountRatios.length; i++) {\n bitCountRatios[i] = moduleBitCount[i] / (float) bitCountSum;\n }\n }\n float bestMatchError = Float.MAX_VALUE;\n int bestMatch = -1;\n for (int j = 0; j < RATIOS_TABLE.length; j++) {\n float error = 0.0f;\n float[] ratioTableRow = RATIOS_TABLE[j];\n for (int k = 0; k < PDF417Common.BARS_IN_MODULE; k++) {\n float diff = ratioTableRow[k] - bitCountRatios[k];\n error += diff * diff;\n if (error >= bestMatchError) {\n break;\n }\n }\n if (error < bestMatchError) {\n bestMatchError = error;\n bestMatch = PDF417Common.SYMBOL_TABLE[j];\n }\n }\n return bestMatch;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/pdf417/decoder/PDF417ScanningDecoder.java", "content": "/*\n * Copyright 2013 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.pdf417.decoder;\n\nimport com.google.zxing.ChecksumException;\nimport com.google.zxing.FormatException;\nimport com.google.zxing.NotFoundException;\nimport com.google.zxing.ResultPoint;\nimport com.google.zxing.common.BitMatrix;\nimport com.google.zxing.common.DecoderResult;\nimport com.google.zxing.common.detector.MathUtils;\nimport com.google.zxing.pdf417.PDF417Common;\nimport com.google.zxing.pdf417.decoder.ec.ErrorCorrection;\n\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.Formatter;\nimport java.util.List;\n\n/**\n * @author Guenther Grau\n */\npublic final class PDF417ScanningDecoder {\n\n private static final int CODEWORD_SKEW_SIZE = 2;\n\n private static final int MAX_ERRORS = 3;\n private static final int MAX_EC_CODEWORDS = 512;\n private static final ErrorCorrection errorCorrection = new ErrorCorrection();\n\n private PDF417ScanningDecoder() {\n }\n\n // TODO don't pass in minCodewordWidth and maxCodewordWidth, pass in barcode columns for start and stop pattern\n // columns. That way width can be deducted from the pattern column.\n // This approach also allows to detect more details about the barcode, e.g. if a bar type (white or black) is wider\n // than it should be. This can happen if the scanner used a bad blackpoint.\n public static DecoderResult decode(BitMatrix image,\n ResultPoint imageTopLeft,\n ResultPoint imageBottomLeft,\n ResultPoint imageTopRight,\n ResultPoint imageBottomRight,\n int minCodewordWidth,\n int maxCodewordWidth) throws NotFoundException, FormatException, ChecksumException {\n BoundingBox boundingBox = new BoundingBox(image, imageTopLeft, imageBottomLeft, imageTopRight, imageBottomRight);\n DetectionResultRowIndicatorColumn leftRowIndicatorColumn = null;\n DetectionResultRowIndicatorColumn rightRowIndicatorColumn = null;\n DetectionResult detectionResult;\n for (boolean firstPass = true; ; firstPass = false) {\n if (imageTopLeft != null) {\n leftRowIndicatorColumn = getRowIndicatorColumn(image, boundingBox, imageTopLeft, true, minCodewordWidth,\n maxCodewordWidth);\n }\n if (imageTopRight != null) {\n rightRowIndicatorColumn = getRowIndicatorColumn(image, boundingBox, imageTopRight, false, minCodewordWidth,\n maxCodewordWidth);\n }\n detectionResult = merge(leftRowIndicatorColumn, rightRowIndicatorColumn);\n if (detectionResult == null) {\n throw NotFoundException.getNotFoundInstance();\n }\n BoundingBox resultBox = detectionResult.getBoundingBox();\n if (firstPass && resultBox != null &&\n (resultBox.getMinY() < boundingBox.getMinY() || resultBox.getMaxY() > boundingBox.getMaxY())) {\n boundingBox = resultBox;\n } else {\n break;\n }\n }\n detectionResult.setBoundingBox(boundingBox);\n int maxBarcodeColumn = detectionResult.getBarcodeColumnCount() + 1;\n detectionResult.setDetectionResultColumn(0, leftRowIndicatorColumn);\n detectionResult.setDetectionResultColumn(maxBarcodeColumn, rightRowIndicatorColumn);\n\n boolean leftToRight = leftRowIndicatorColumn != null;\n for (int barcodeColumnCount = 1; barcodeColumnCount <= maxBarcodeColumn; barcodeColumnCount++) {\n int barcodeColumn = leftToRight ? barcodeColumnCount : maxBarcodeColumn - barcodeColumnCount;\n if (detectionResult.getDetectionResultColumn(barcodeColumn) != null) {\n // This will be the case for the opposite row indicator column, which doesn't need to be decoded again.\n continue;\n }\n DetectionResultColumn detectionResultColumn;\n if (barcodeColumn == 0 || barcodeColumn == maxBarcodeColumn) {\n detectionResultColumn = new DetectionResultRowIndicatorColumn(boundingBox, barcodeColumn == 0);\n } else {\n detectionResultColumn = new DetectionResultColumn(boundingBox);\n }\n detectionResult.setDetectionResultColumn(barcodeColumn, detectionResultColumn);\n int startColumn = -1;\n int previousStartColumn = startColumn;\n // TODO start at a row for which we know the start position, then detect upwards and downwards from there.\n for (int imageRow = boundingBox.getMinY(); imageRow <= boundingBox.getMaxY(); imageRow++) {\n startColumn = getStartColumn(detectionResult, barcodeColumn, imageRow, leftToRight);\n if (startColumn < 0 || startColumn > boundingBox.getMaxX()) {\n if (previousStartColumn == -1) {\n continue;\n }\n startColumn = previousStartColumn;\n }\n Codeword codeword = detectCodeword(image, boundingBox.getMinX(), boundingBox.getMaxX(), leftToRight,\n startColumn, imageRow, minCodewordWidth, maxCodewordWidth);\n if (codeword != null) {\n detectionResultColumn.setCodeword(imageRow, codeword);\n previousStartColumn = startColumn;\n minCodewordWidth = Math.min(minCodewordWidth, codeword.getWidth());\n maxCodewordWidth = Math.max(maxCodewordWidth, codeword.getWidth());\n }\n }\n }\n return createDecoderResult(detectionResult);\n }\n\n private static DetectionResult merge(DetectionResultRowIndicatorColumn leftRowIndicatorColumn,\n DetectionResultRowIndicatorColumn rightRowIndicatorColumn)\n throws NotFoundException {\n if (leftRowIndicatorColumn == null && rightRowIndicatorColumn == null) {\n return null;\n }\n BarcodeMetadata barcodeMetadata = getBarcodeMetadata(leftRowIndicatorColumn, rightRowIndicatorColumn);\n if (barcodeMetadata == null) {\n return null;\n }\n BoundingBox boundingBox = BoundingBox.merge(adjustBoundingBox(leftRowIndicatorColumn),\n adjustBoundingBox(rightRowIndicatorColumn));\n return new DetectionResult(barcodeMetadata, boundingBox);\n }\n\n private static BoundingBox adjustBoundingBox(DetectionResultRowIndicatorColumn rowIndicatorColumn)\n throws NotFoundException {\n if (rowIndicatorColumn == null) {\n return null;\n }\n int[] rowHeights = rowIndicatorColumn.getRowHeights();\n if (rowHeights == null) {\n return null;\n }\n int maxRowHeight = getMax(rowHeights);\n int missingStartRows = 0;\n for (int rowHeight : rowHeights) {\n missingStartRows += maxRowHeight - rowHeight;\n if (rowHeight > 0) {\n break;\n }\n }\n Codeword[] codewords = rowIndicatorColumn.getCodewords();\n for (int row = 0; missingStartRows > 0 && codewords[row] == null; row++) {\n missingStartRows--;\n }\n int missingEndRows = 0;\n for (int row = rowHeights.length - 1; row >= 0; row--) {\n missingEndRows += maxRowHeight - rowHeights[row];\n if (rowHeights[row] > 0) {\n break;\n }\n }\n for (int row = codewords.length - 1; missingEndRows > 0 && codewords[row] == null; row--) {\n missingEndRows--;\n }\n return rowIndicatorColumn.getBoundingBox().addMissingRows(missingStartRows, missingEndRows,\n rowIndicatorColumn.isLeft());\n }\n\n private static int getMax(int[] values) {\n int maxValue = -1;\n for (int value : values) {\n maxValue = Math.max(maxValue, value);\n }\n return maxValue;\n }\n\n private static BarcodeMetadata getBarcodeMetadata(DetectionResultRowIndicatorColumn leftRowIndicatorColumn,\n DetectionResultRowIndicatorColumn rightRowIndicatorColumn) {\n BarcodeMetadata leftBarcodeMetadata;\n if (leftRowIndicatorColumn == null ||\n (leftBarcodeMetadata = leftRowIndicatorColumn.getBarcodeMetadata()) == null) {\n return rightRowIndicatorColumn == null ? null : rightRowIndicatorColumn.getBarcodeMetadata();\n }\n BarcodeMetadata rightBarcodeMetadata;\n if (rightRowIndicatorColumn == null ||\n (rightBarcodeMetadata = rightRowIndicatorColumn.getBarcodeMetadata()) == null) {\n return leftBarcodeMetadata;\n }\n\n if (leftBarcodeMetadata.getColumnCount() != rightBarcodeMetadata.getColumnCount() &&\n leftBarcodeMetadata.getErrorCorrectionLevel() != rightBarcodeMetadata.getErrorCorrectionLevel() &&\n leftBarcodeMetadata.getRowCount() != rightBarcodeMetadata.getRowCount()) {\n return null;\n }\n return leftBarcodeMetadata;\n }\n\n private static DetectionResultRowIndicatorColumn getRowIndicatorColumn(BitMatrix image,\n BoundingBox boundingBox,\n ResultPoint startPoint,\n boolean leftToRight,\n int minCodewordWidth,\n int maxCodewordWidth) {\n DetectionResultRowIndicatorColumn rowIndicatorColumn = new DetectionResultRowIndicatorColumn(boundingBox,\n leftToRight);\n for (int i = 0; i < 2; i++) {\n int increment = i == 0 ? 1 : -1;\n int startColumn = (int) startPoint.getX();\n for (int imageRow = (int) startPoint.getY(); imageRow <= boundingBox.getMaxY() &&\n imageRow >= boundingBox.getMinY(); imageRow += increment) {\n Codeword codeword = detectCodeword(image, 0, image.getWidth(), leftToRight, startColumn, imageRow,\n minCodewordWidth, maxCodewordWidth);\n if (codeword != null) {\n rowIndicatorColumn.setCodeword(imageRow, codeword);\n if (leftToRight) {\n startColumn = codeword.getStartX();\n } else {\n startColumn = codeword.getEndX();\n }\n }\n }\n }\n return rowIndicatorColumn;\n }\n\n private static void adjustCodewordCount(DetectionResult detectionResult, BarcodeValue[][] barcodeMatrix)\n throws NotFoundException {\n BarcodeValue barcodeMatrix01 = barcodeMatrix[0][1];\n int[] numberOfCodewords = barcodeMatrix01.getValue();\n int calculatedNumberOfCodewords = detectionResult.getBarcodeColumnCount() *\n detectionResult.getBarcodeRowCount() -\n getNumberOfECCodeWords(detectionResult.getBarcodeECLevel());\n if (numberOfCodewords.length == 0) {\n if (calculatedNumberOfCodewords < 1 || calculatedNumberOfCodewords > PDF417Common.MAX_CODEWORDS_IN_BARCODE) {\n throw NotFoundException.getNotFoundInstance();\n }\n barcodeMatrix01.setValue(calculatedNumberOfCodewords);\n } else if (numberOfCodewords[0] != calculatedNumberOfCodewords) {\n // The calculated one is more reliable as it is derived from the row indicator columns\n barcodeMatrix01.setValue(calculatedNumberOfCodewords);\n }\n }\n\n private static DecoderResult createDecoderResult(DetectionResult detectionResult) throws FormatException,\n ChecksumException, NotFoundException {\n BarcodeValue[][] barcodeMatrix = createBarcodeMatrix(detectionResult);\n adjustCodewordCount(detectionResult, barcodeMatrix);\n CollectionGiven data and error-correction codewords received, possibly corrupted by errors, attempts to\n * correct the errors in-place.
\n *\n * @param codewords data and error correction codewords\n * @param erasures positions of any known erasures\n * @param numECCodewords number of error correction codewords that are available in codewords\n * @throws ChecksumException if error correction fails\n */\n private static int correctErrors(int[] codewords, int[] erasures, int numECCodewords) throws ChecksumException {\n if (erasures != null &&\n erasures.length > numECCodewords / 2 + MAX_ERRORS ||\n numECCodewords < 0 ||\n numECCodewords > MAX_EC_CODEWORDS) {\n // Too many errors or EC Codewords is corrupted\n throw ChecksumException.getChecksumInstance();\n }\n return errorCorrection.decode(codewords, numECCodewords, erasures);\n }\n\n /**\n * Verify that all is OK with the codeword array.\n */\n private static void verifyCodewordCount(int[] codewords, int numECCodewords) throws FormatException {\n if (codewords.length < 4) {\n // Codeword array size should be at least 4 allowing for\n // Count CW, At least one Data CW, Error Correction CW, Error Correction CW\n throw FormatException.getFormatInstance();\n }\n // The first codeword, the Symbol Length Descriptor, shall always encode the total number of data\n // codewords in the symbol, including the Symbol Length Descriptor itself, data codewords and pad\n // codewords, but excluding the number of error correction codewords.\n int numberOfCodewords = codewords[0];\n if (numberOfCodewords > codewords.length) {\n throw FormatException.getFormatInstance();\n }\n if (numberOfCodewords == 0) {\n // Reset to the length of the array - 8 (Allow for at least level 3 Error Correction (8 Error Codewords)\n if (numECCodewords < codewords.length) {\n codewords[0] = codewords.length - numECCodewords;\n } else {\n throw FormatException.getFormatInstance();\n }\n }\n }\n\n private static int[] getBitCountForCodeword(int codeword) {\n int[] result = new int[8];\n int previousValue = 0;\n int i = result.length - 1;\n while (true) {\n if ((codeword & 0x1) != previousValue) {\n previousValue = codeword & 0x1;\n i--;\n if (i < 0) {\n break;\n }\n }\n result[i]++;\n codeword >>= 1;\n }\n return result;\n }\n\n private static int getCodewordBucketNumber(int codeword) {\n return getCodewordBucketNumber(getBitCountForCodeword(codeword));\n }\n\n private static int getCodewordBucketNumber(int[] moduleBitCount) {\n return (moduleBitCount[0] - moduleBitCount[2] + moduleBitCount[4] - moduleBitCount[6] + 9) % 9;\n }\n\n public static String toString(BarcodeValue[][] barcodeMatrix) {\n try (Formatter formatter = new Formatter()) {\n for (int row = 0; row < barcodeMatrix.length; row++) {\n formatter.format(\"Row %2d: \", row);\n for (int column = 0; column < barcodeMatrix[row].length; column++) {\n BarcodeValue barcodeValue = barcodeMatrix[row][column];\n if (barcodeValue.getValue().length == 0) {\n formatter.format(\" \", (Object[]) null);\n } else {\n formatter.format(\"%4d(%2d)\", barcodeValue.getValue()[0],\n barcodeValue.getConfidence(barcodeValue.getValue()[0]));\n }\n }\n formatter.format(\"%n\");\n }\n return formatter.toString();\n }\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/pdf417/decoder/ec/ErrorCorrection.java", "content": "/*\n * Copyright 2012 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.pdf417.decoder.ec;\n\nimport com.google.zxing.ChecksumException;\n\n/**\n *PDF417 error correction implementation.
\n *\n *This example\n * is quite useful in understanding the algorithm.
\n *\n * @author Sean Owen\n * @see com.google.zxing.common.reedsolomon.ReedSolomonDecoder\n */\npublic final class ErrorCorrection {\n\n private final ModulusGF field;\n\n public ErrorCorrection() {\n this.field = ModulusGF.PDF417_GF;\n }\n\n /**\n * @param received received codewords\n * @param numECCodewords number of those codewords used for EC\n * @param erasures location of erasures\n * @return number of errors\n * @throws ChecksumException if errors cannot be corrected, maybe because of too many errors\n */\n public int decode(int[] received,\n int numECCodewords,\n int[] erasures) throws ChecksumException {\n\n ModulusPoly poly = new ModulusPoly(field, received);\n int[] S = new int[numECCodewords];\n boolean error = false;\n for (int i = numECCodewords; i > 0; i--) {\n int eval = poly.evaluateAt(field.exp(i));\n S[numECCodewords - i] = eval;\n if (eval != 0) {\n error = true;\n }\n }\n\n if (!error) {\n return 0;\n }\n\n ModulusPoly knownErrors = field.getOne();\n if (erasures != null) {\n for (int erasure : erasures) {\n int b = field.exp(received.length - 1 - erasure);\n // Add (1 - bx) term:\n ModulusPoly term = new ModulusPoly(field, new int[]{field.subtract(0, b), 1});\n knownErrors = knownErrors.multiply(term);\n }\n }\n\n ModulusPoly syndrome = new ModulusPoly(field, S);\n //syndrome = syndrome.multiply(knownErrors);\n\n ModulusPoly[] sigmaOmega =\n runEuclideanAlgorithm(field.buildMonomial(numECCodewords, 1), syndrome, numECCodewords);\n ModulusPoly sigma = sigmaOmega[0];\n ModulusPoly omega = sigmaOmega[1];\n\n //sigma = sigma.multiply(knownErrors);\n\n int[] errorLocations = findErrorLocations(sigma);\n int[] errorMagnitudes = findErrorMagnitudes(omega, sigma, errorLocations);\n\n for (int i = 0; i < errorLocations.length; i++) {\n int position = received.length - 1 - field.log(errorLocations[i]);\n if (position < 0) {\n throw ChecksumException.getChecksumInstance();\n }\n received[position] = field.subtract(received[position], errorMagnitudes[i]);\n }\n return errorLocations.length;\n }\n\n private ModulusPoly[] runEuclideanAlgorithm(ModulusPoly a, ModulusPoly b, int R)\n throws ChecksumException {\n // Assume a's degree is >= b's\n if (a.getDegree() < b.getDegree()) {\n ModulusPoly temp = a;\n a = b;\n b = temp;\n }\n\n ModulusPoly rLast = a;\n ModulusPoly r = b;\n ModulusPoly tLast = field.getZero();\n ModulusPoly t = field.getOne();\n\n // Run Euclidean algorithm until r's degree is less than R/2\n while (r.getDegree() >= R / 2) {\n ModulusPoly rLastLast = rLast;\n ModulusPoly tLastLast = tLast;\n rLast = r;\n tLast = t;\n\n // Divide rLastLast by rLast, with quotient in q and remainder in r\n if (rLast.isZero()) {\n // Oops, Euclidean algorithm already terminated?\n throw ChecksumException.getChecksumInstance();\n }\n r = rLastLast;\n ModulusPoly q = field.getZero();\n int denominatorLeadingTerm = rLast.getCoefficient(rLast.getDegree());\n int dltInverse = field.inverse(denominatorLeadingTerm);\n while (r.getDegree() >= rLast.getDegree() && !r.isZero()) {\n int degreeDiff = r.getDegree() - rLast.getDegree();\n int scale = field.multiply(r.getCoefficient(r.getDegree()), dltInverse);\n q = q.add(field.buildMonomial(degreeDiff, scale));\n r = r.subtract(rLast.multiplyByMonomial(degreeDiff, scale));\n }\n\n t = q.multiply(tLast).subtract(tLastLast).negative();\n }\n\n int sigmaTildeAtZero = t.getCoefficient(0);\n if (sigmaTildeAtZero == 0) {\n throw ChecksumException.getChecksumInstance();\n }\n\n int inverse = field.inverse(sigmaTildeAtZero);\n ModulusPoly sigma = t.multiply(inverse);\n ModulusPoly omega = r.multiply(inverse);\n return new ModulusPoly[]{sigma, omega};\n }\n\n private int[] findErrorLocations(ModulusPoly errorLocator) throws ChecksumException {\n // This is a direct application of Chien's search\n int numErrors = errorLocator.getDegree();\n int[] result = new int[numErrors];\n int e = 0;\n for (int i = 1; i < field.getSize() && e < numErrors; i++) {\n if (errorLocator.evaluateAt(i) == 0) {\n result[e] = field.inverse(i);\n e++;\n }\n }\n if (e != numErrors) {\n throw ChecksumException.getChecksumInstance();\n }\n return result;\n }\n\n private int[] findErrorMagnitudes(ModulusPoly errorEvaluator,\n ModulusPoly errorLocator,\n int[] errorLocations) {\n int errorLocatorDegree = errorLocator.getDegree();\n int[] formalDerivativeCoefficients = new int[errorLocatorDegree];\n for (int i = 1; i <= errorLocatorDegree; i++) {\n formalDerivativeCoefficients[errorLocatorDegree - i] =\n field.multiply(i, errorLocator.getCoefficient(i));\n }\n ModulusPoly formalDerivative = new ModulusPoly(field, formalDerivativeCoefficients);\n\n // This is directly applying Forney's Formula\n int s = errorLocations.length;\n int[] result = new int[s];\n for (int i = 0; i < s; i++) {\n int xiInverse = field.inverse(errorLocations[i]);\n int numerator = field.subtract(0, errorEvaluator.evaluateAt(xiInverse));\n int denominator = field.inverse(formalDerivative.evaluateAt(xiInverse));\n result[i] = field.multiply(numerator, denominator);\n }\n return result;\n }\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/pdf417/decoder/ec/ModulusGF.java", "content": "/*\n * Copyright 2012 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.pdf417.decoder.ec;\n\nimport com.google.zxing.pdf417.PDF417Common;\n\n/**\n *A field based on powers of a generator integer, modulo some modulus.
\n *\n * @author Sean Owen\n * @see com.google.zxing.common.reedsolomon.GenericGF\n */\npublic final class ModulusGF {\n\n public static final ModulusGF PDF417_GF = new ModulusGF(PDF417Common.NUMBER_OF_CODEWORDS, 3);\n\n private final int[] expTable;\n private final int[] logTable;\n private final ModulusPoly zero;\n private final ModulusPoly one;\n private final int modulus;\n\n private ModulusGF(int modulus, int generator) {\n this.modulus = modulus;\n expTable = new int[modulus];\n logTable = new int[modulus];\n int x = 1;\n for (int i = 0; i < modulus; i++) {\n expTable[i] = x;\n x = (x * generator) % modulus;\n }\n for (int i = 0; i < modulus - 1; i++) {\n logTable[expTable[i]] = i;\n }\n // logTable[0] == 0 but this should never be used\n zero = new ModulusPoly(this, new int[]{0});\n one = new ModulusPoly(this, new int[]{1});\n }\n\n\n ModulusPoly getZero() {\n return zero;\n }\n\n ModulusPoly getOne() {\n return one;\n }\n\n ModulusPoly buildMonomial(int degree, int coefficient) {\n if (degree < 0) {\n throw new IllegalArgumentException();\n }\n if (coefficient == 0) {\n return zero;\n }\n int[] coefficients = new int[degree + 1];\n coefficients[0] = coefficient;\n return new ModulusPoly(this, coefficients);\n }\n\n int add(int a, int b) {\n return (a + b) % modulus;\n }\n\n int subtract(int a, int b) {\n return (modulus + a - b) % modulus;\n }\n\n int exp(int a) {\n return expTable[a];\n }\n\n int log(int a) {\n if (a == 0) {\n throw new IllegalArgumentException();\n }\n return logTable[a];\n }\n\n int inverse(int a) {\n if (a == 0) {\n throw new ArithmeticException();\n }\n return expTable[modulus - logTable[a] - 1];\n }\n\n int multiply(int a, int b) {\n if (a == 0 || b == 0) {\n return 0;\n }\n return expTable[(logTable[a] + logTable[b]) % (modulus - 1)];\n }\n\n int getSize() {\n return modulus;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/pdf417/decoder/ec/ModulusPoly.java", "content": "/*\n * Copyright 2012 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.pdf417.decoder.ec;\n\n/**\n * @author Sean Owen\n * @see com.google.zxing.common.reedsolomon.GenericGFPoly\n */\nfinal class ModulusPoly {\n\n private final ModulusGF field;\n private final int[] coefficients;\n\n ModulusPoly(ModulusGF field, int[] coefficients) {\n if (coefficients.length == 0) {\n throw new IllegalArgumentException();\n }\n this.field = field;\n int coefficientsLength = coefficients.length;\n if (coefficientsLength > 1 && coefficients[0] == 0) {\n // Leading term must be non-zero for anything except the constant polynomial \"0\"\n int firstNonZero = 1;\n while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) {\n firstNonZero++;\n }\n if (firstNonZero == coefficientsLength) {\n this.coefficients = new int[]{0};\n } else {\n this.coefficients = new int[coefficientsLength - firstNonZero];\n System.arraycopy(coefficients,\n firstNonZero,\n this.coefficients,\n 0,\n this.coefficients.length);\n }\n } else {\n this.coefficients = coefficients;\n }\n }\n\n int[] getCoefficients() {\n return coefficients;\n }\n\n /**\n * @return degree of this polynomial\n */\n int getDegree() {\n return coefficients.length - 1;\n }\n\n /**\n * @return true iff this polynomial is the monomial \"0\"\n */\n boolean isZero() {\n return coefficients[0] == 0;\n }\n\n /**\n * @return coefficient of x^degree term in this polynomial\n */\n int getCoefficient(int degree) {\n return coefficients[coefficients.length - 1 - degree];\n }\n\n /**\n * @return evaluation of this polynomial at a given point\n */\n int evaluateAt(int a) {\n if (a == 0) {\n // Just return the x^0 coefficient\n return getCoefficient(0);\n }\n if (a == 1) {\n // Just the sum of the coefficients\n int result = 0;\n for (int coefficient : coefficients) {\n result = field.add(result, coefficient);\n }\n return result;\n }\n int result = coefficients[0];\n int size = coefficients.length;\n for (int i = 1; i < size; i++) {\n result = field.add(field.multiply(a, result), coefficients[i]);\n }\n return result;\n }\n\n ModulusPoly add(ModulusPoly other) {\n if (!field.equals(other.field)) {\n throw new IllegalArgumentException(\"ModulusPolys do not have same ModulusGF field\");\n }\n if (isZero()) {\n return other;\n }\n if (other.isZero()) {\n return this;\n }\n\n int[] smallerCoefficients = this.coefficients;\n int[] largerCoefficients = other.coefficients;\n if (smallerCoefficients.length > largerCoefficients.length) {\n int[] temp = smallerCoefficients;\n smallerCoefficients = largerCoefficients;\n largerCoefficients = temp;\n }\n int[] sumDiff = new int[largerCoefficients.length];\n int lengthDiff = largerCoefficients.length - smallerCoefficients.length;\n // Copy high-order terms only found in higher-degree polynomial's coefficients\n System.arraycopy(largerCoefficients, 0, sumDiff, 0, lengthDiff);\n\n for (int i = lengthDiff; i < largerCoefficients.length; i++) {\n sumDiff[i] = field.add(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);\n }\n\n return new ModulusPoly(field, sumDiff);\n }\n\n ModulusPoly subtract(ModulusPoly other) {\n if (!field.equals(other.field)) {\n throw new IllegalArgumentException(\"ModulusPolys do not have same ModulusGF field\");\n }\n if (other.isZero()) {\n return this;\n }\n return add(other.negative());\n }\n\n ModulusPoly multiply(ModulusPoly other) {\n if (!field.equals(other.field)) {\n throw new IllegalArgumentException(\"ModulusPolys do not have same ModulusGF field\");\n }\n if (isZero() || other.isZero()) {\n return field.getZero();\n }\n int[] aCoefficients = this.coefficients;\n int aLength = aCoefficients.length;\n int[] bCoefficients = other.coefficients;\n int bLength = bCoefficients.length;\n int[] product = new int[aLength + bLength - 1];\n for (int i = 0; i < aLength; i++) {\n int aCoeff = aCoefficients[i];\n for (int j = 0; j < bLength; j++) {\n product[i + j] = field.add(product[i + j], field.multiply(aCoeff, bCoefficients[j]));\n }\n }\n return new ModulusPoly(field, product);\n }\n\n ModulusPoly negative() {\n int size = coefficients.length;\n int[] negativeCoefficients = new int[size];\n for (int i = 0; i < size; i++) {\n negativeCoefficients[i] = field.subtract(0, coefficients[i]);\n }\n return new ModulusPoly(field, negativeCoefficients);\n }\n\n ModulusPoly multiply(int scalar) {\n if (scalar == 0) {\n return field.getZero();\n }\n if (scalar == 1) {\n return this;\n }\n int size = coefficients.length;\n int[] product = new int[size];\n for (int i = 0; i < size; i++) {\n product[i] = field.multiply(coefficients[i], scalar);\n }\n return new ModulusPoly(field, product);\n }\n\n ModulusPoly multiplyByMonomial(int degree, int coefficient) {\n if (degree < 0) {\n throw new IllegalArgumentException();\n }\n if (coefficient == 0) {\n return field.getZero();\n }\n int size = coefficients.length;\n int[] product = new int[size + degree];\n for (int i = 0; i < size; i++) {\n product[i] = field.multiply(coefficients[i], coefficient);\n }\n return new ModulusPoly(field, product);\n }\n\n /*\n ModulusPoly[] divide(ModulusPoly other) {\n if (!field.equals(other.field)) {\n throw new IllegalArgumentException(\"ModulusPolys do not have same ModulusGF field\");\n }\n if (other.isZero()) {\n throw new IllegalArgumentException(\"Divide by 0\");\n }\n\n ModulusPoly quotient = field.getZero();\n ModulusPoly remainder = this;\n\n int denominatorLeadingTerm = other.getCoefficient(other.getDegree());\n int inverseDenominatorLeadingTerm = field.inverse(denominatorLeadingTerm);\n\n while (remainder.getDegree() >= other.getDegree() && !remainder.isZero()) {\n int degreeDifference = remainder.getDegree() - other.getDegree();\n int scale = field.multiply(remainder.getCoefficient(remainder.getDegree()), inverseDenominatorLeadingTerm);\n ModulusPoly term = other.multiplyByMonomial(degreeDifference, scale);\n ModulusPoly iterationQuotient = field.buildMonomial(degreeDifference, scale);\n quotient = quotient.add(iterationQuotient);\n remainder = remainder.subtract(term);\n }\n\n return new ModulusPoly[] { quotient, remainder };\n }\n */\n\n @Override\n public String toString() {\n StringBuilder result = new StringBuilder(8 * getDegree());\n for (int degree = getDegree(); degree >= 0; degree--) {\n int coefficient = getCoefficient(degree);\n if (coefficient != 0) {\n if (coefficient < 0) {\n result.append(\" - \");\n coefficient = -coefficient;\n } else {\n if (result.length() > 0) {\n result.append(\" + \");\n }\n }\n if (degree == 0 || coefficient != 1) {\n result.append(coefficient);\n }\n if (degree != 0) {\n if (degree == 1) {\n result.append('x');\n } else {\n result.append(\"x^\");\n result.append(degree);\n }\n }\n }\n }\n return result.toString();\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/pdf417/detector/Detector.java", "content": "/*\n * Copyright 2009 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.pdf417.detector;\n\nimport com.google.zxing.BinaryBitmap;\nimport com.google.zxing.DecodeHintType;\nimport com.google.zxing.NotFoundException;\nimport com.google.zxing.ResultPoint;\nimport com.google.zxing.common.BitMatrix;\n\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\nimport java.util.Map;\n\n/**\n *Encapsulates logic that can detect a PDF417 Code in an image, even if the\n * PDF417 Code is rotated or skewed, or partially obscured.
\n *\n * @author SITA Lab (kevin.osullivan@sita.aero)\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Guenther Grau\n */\npublic final class Detector {\n\n private static final int[] INDEXES_START_PATTERN = {0, 4, 1, 5};\n private static final int[] INDEXES_STOP_PATTERN = {6, 2, 7, 3};\n private static final float MAX_AVG_VARIANCE = 0.42f;\n private static final float MAX_INDIVIDUAL_VARIANCE = 0.8f;\n\n // B S B S B S B S Bar/Space pattern\n // 11111111 0 1 0 1 0 1 000\n private static final int[] START_PATTERN = {8, 1, 1, 1, 1, 1, 1, 3};\n // 1111111 0 1 000 1 0 1 00 1\n private static final int[] STOP_PATTERN = {7, 1, 1, 3, 1, 1, 1, 2, 1};\n private static final int MAX_PIXEL_DRIFT = 3;\n private static final int MAX_PATTERN_DRIFT = 5;\n // if we set the value too low, then we don't detect the correct height of the bar if the start patterns are damaged.\n // if we set the value too high, then we might detect the start pattern from a neighbor barcode.\n private static final int SKIPPED_ROW_COUNT_MAX = 25;\n // A PDF471 barcode should have at least 3 rows, with each row being >= 3 times the module width. Therefore it should be at least\n // 9 pixels tall. To be conservative, we use about half the size to ensure we don't miss it.\n private static final int ROW_STEP = 5;\n private static final int BARCODE_MIN_HEIGHT = 10;\n\n private Detector() {\n }\n\n /**\n *Detects a PDF417 Code in an image. Only checks 0 and 180 degree rotations.
\n *\n * @param image barcode image to decode\n * @param hints optional hints to detector\n * @param multiple if true, then the image is searched for multiple codes. If false, then at most one code will\n * be found and returned\n * @return {@link PDF417DetectorResult} encapsulating results of detecting a PDF417 code\n * @throws NotFoundException if no PDF417 Code can be found\n */\n public static PDF417DetectorResult detect(BinaryBitmap image, MapReads format information from one of its two locations within the QR Code.
\n *\n * @return {@link FormatInformation} encapsulating the QR Code's format info\n * @throws FormatException if both format information locations cannot be parsed as\n * the valid encoding of format information\n */\n FormatInformation readFormatInformation() throws FormatException {\n\n if (parsedFormatInfo != null) {\n return parsedFormatInfo;\n }\n\n // Read top-left format info bits\n int formatInfoBits1 = 0;\n for (int i = 0; i < 6; i++) {\n formatInfoBits1 = copyBit(i, 8, formatInfoBits1);\n }\n // .. and skip a bit in the timing pattern ...\n formatInfoBits1 = copyBit(7, 8, formatInfoBits1);\n formatInfoBits1 = copyBit(8, 8, formatInfoBits1);\n formatInfoBits1 = copyBit(8, 7, formatInfoBits1);\n // .. and skip a bit in the timing pattern ...\n for (int j = 5; j >= 0; j--) {\n formatInfoBits1 = copyBit(8, j, formatInfoBits1);\n }\n\n // Read the top-right/bottom-left pattern too\n int dimension = bitMatrix.getHeight();\n int formatInfoBits2 = 0;\n int jMin = dimension - 7;\n for (int j = dimension - 1; j >= jMin; j--) {\n formatInfoBits2 = copyBit(8, j, formatInfoBits2);\n }\n for (int i = dimension - 8; i < dimension; i++) {\n formatInfoBits2 = copyBit(i, 8, formatInfoBits2);\n }\n\n parsedFormatInfo = FormatInformation.decodeFormatInformation(formatInfoBits1, formatInfoBits2);\n if (parsedFormatInfo != null) {\n return parsedFormatInfo;\n }\n throw FormatException.getFormatInstance();\n }\n\n /**\n *Reads version information from one of its two locations within the QR Code.
\n *\n * @return {@link Version} encapsulating the QR Code's version\n * @throws FormatException if both version information locations cannot be parsed as\n * the valid encoding of version information\n */\n Version readVersion() throws FormatException {\n\n if (parsedVersion != null) {\n return parsedVersion;\n }\n\n int dimension = bitMatrix.getHeight();\n\n int provisionalVersion = (dimension - 17) / 4;\n if (provisionalVersion <= 6) {\n return Version.getVersionForNumber(provisionalVersion);\n }\n\n // Read top-right version info: 3 wide by 6 tall\n int versionBits = 0;\n int ijMin = dimension - 11;\n for (int j = 5; j >= 0; j--) {\n for (int i = dimension - 9; i >= ijMin; i--) {\n versionBits = copyBit(i, j, versionBits);\n }\n }\n\n Version theParsedVersion = Version.decodeVersionInformation(versionBits);\n if (theParsedVersion != null && theParsedVersion.getDimensionForVersion() == dimension) {\n parsedVersion = theParsedVersion;\n return theParsedVersion;\n }\n\n // Hmm, failed. Try bottom left: 6 wide by 3 tall\n versionBits = 0;\n for (int i = 5; i >= 0; i--) {\n for (int j = dimension - 9; j >= ijMin; j--) {\n versionBits = copyBit(i, j, versionBits);\n }\n }\n\n theParsedVersion = Version.decodeVersionInformation(versionBits);\n if (theParsedVersion != null && theParsedVersion.getDimensionForVersion() == dimension) {\n parsedVersion = theParsedVersion;\n return theParsedVersion;\n }\n throw FormatException.getFormatInstance();\n }\n\n private int copyBit(int i, int j, int versionBits) {\n boolean bit = mirror ? bitMatrix.get(j, i) : bitMatrix.get(i, j);\n return bit ? (versionBits << 1) | 0x1 : versionBits << 1;\n }\n\n /**\n *Reads the bits in the {@link BitMatrix} representing the finder pattern in the\n * correct order in order to reconstruct the codewords bytes contained within the\n * QR Code.
\n *\n * @return bytes encoded within the QR Code\n * @throws FormatException if the exact number of bytes expected is not read\n */\n byte[] readCodewords() throws FormatException {\n\n FormatInformation formatInfo = readFormatInformation();\n Version version = readVersion();\n\n // Get the data mask for the format used in this QR Code. This will exclude\n // some bits from reading as we wind through the bit matrix.\n DataMask dataMask = DataMask.values()[formatInfo.getDataMask()];\n int dimension = bitMatrix.getHeight();\n dataMask.unmaskBitMatrix(bitMatrix, dimension);\n\n BitMatrix functionPattern = version.buildFunctionPattern();\n\n boolean readingUp = true;\n byte[] result = new byte[version.getTotalCodewords()];\n int resultOffset = 0;\n int currentByte = 0;\n int bitsRead = 0;\n // Read columns in pairs, from right to left\n for (int j = dimension - 1; j > 0; j -= 2) {\n if (j == 6) {\n // Skip whole column with vertical alignment pattern;\n // saves time and makes the other code proceed more cleanly\n j--;\n }\n // Read alternatingly from bottom to top then top to bottom\n for (int count = 0; count < dimension; count++) {\n int i = readingUp ? dimension - 1 - count : count;\n for (int col = 0; col < 2; col++) {\n // Ignore bits covered by the function pattern\n if (!functionPattern.get(j - col, i)) {\n // Read a bit\n bitsRead++;\n currentByte <<= 1;\n if (bitMatrix.get(j - col, i)) {\n currentByte |= 1;\n }\n // If we've made a whole byte, save it off\n if (bitsRead == 8) {\n result[resultOffset++] = (byte) currentByte;\n bitsRead = 0;\n currentByte = 0;\n }\n }\n }\n }\n readingUp ^= true; // readingUp = !readingUp; // switch directions\n }\n if (resultOffset != version.getTotalCodewords()) {\n throw FormatException.getFormatInstance();\n }\n return result;\n }\n\n /**\n * Revert the mask removal done while reading the code words. The bit matrix should revert to its original state.\n */\n void remask() {\n if (parsedFormatInfo == null) {\n return; // We have no format information, and have no data mask\n }\n DataMask dataMask = DataMask.values()[parsedFormatInfo.getDataMask()];\n int dimension = bitMatrix.getHeight();\n dataMask.unmaskBitMatrix(bitMatrix, dimension);\n }\n\n /**\n * Prepare the parser for a mirrored operation.\n * This flag has effect only on the {@link #readFormatInformation()} and the\n * {@link #readVersion()}. Before proceeding with {@link #readCodewords()} the\n * {@link #mirror()} method should be called.\n *\n * @param mirror Whether to read version and format information mirrored.\n */\n void setMirror(boolean mirror) {\n parsedVersion = null;\n parsedFormatInfo = null;\n this.mirror = mirror;\n }\n\n /** Mirror the bit matrix in order to attempt a second reading. */\n void mirror() {\n for (int x = 0; x < bitMatrix.getWidth(); x++) {\n for (int y = x + 1; y < bitMatrix.getHeight(); y++) {\n if (bitMatrix.get(x, y) != bitMatrix.get(y, x)) {\n bitMatrix.flip(y, x);\n bitMatrix.flip(x, y);\n }\n }\n }\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/decoder/DataBlock.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.decoder;\n\n/**\n *Encapsulates a block of data within a QR Code. QR Codes may split their data into\n * multiple blocks, each of which is a unit of data and error-correction codewords. Each\n * is represented by an instance of this class.
\n *\n * @author Sean Owen\n */\nfinal class DataBlock {\n\n private final int numDataCodewords;\n private final byte[] codewords;\n\n private DataBlock(int numDataCodewords, byte[] codewords) {\n this.numDataCodewords = numDataCodewords;\n this.codewords = codewords;\n }\n\n /**\n *When QR Codes use multiple data blocks, they are actually interleaved.\n * That is, the first byte of data block 1 to n is written, then the second bytes, and so on. This\n * method will separate the data into original blocks.
\n *\n * @param rawCodewords bytes as read directly from the QR Code\n * @param version version of the QR Code\n * @param ecLevel error-correction level of the QR Code\n * @return DataBlocks containing original bytes, \"de-interleaved\" from representation in the\n * QR Code\n */\n static DataBlock[] getDataBlocks(byte[] rawCodewords,\n Version version,\n ErrorCorrectionLevel ecLevel) {\n\n if (rawCodewords.length != version.getTotalCodewords()) {\n throw new IllegalArgumentException();\n }\n\n // Figure out the number and size of data blocks used by this version and\n // error correction level\n Version.ECBlocks ecBlocks = version.getECBlocksForLevel(ecLevel);\n\n // First count the total number of data blocks\n int totalBlocks = 0;\n Version.ECB[] ecBlockArray = ecBlocks.getECBlocks();\n for (Version.ECB ecBlock : ecBlockArray) {\n totalBlocks += ecBlock.getCount();\n }\n\n // Now establish DataBlocks of the appropriate size and number of data codewords\n DataBlock[] result = new DataBlock[totalBlocks];\n int numResultBlocks = 0;\n for (Version.ECB ecBlock : ecBlockArray) {\n for (int i = 0; i < ecBlock.getCount(); i++) {\n int numDataCodewords = ecBlock.getDataCodewords();\n int numBlockCodewords = ecBlocks.getECCodewordsPerBlock() + numDataCodewords;\n result[numResultBlocks++] = new DataBlock(numDataCodewords, new byte[numBlockCodewords]);\n }\n }\n\n // All blocks have the same amount of data, except that the last n\n // (where n may be 0) have 1 more byte. Figure out where these start.\n int shorterBlocksTotalCodewords = result[0].codewords.length;\n int longerBlocksStartAt = result.length - 1;\n while (longerBlocksStartAt >= 0) {\n int numCodewords = result[longerBlocksStartAt].codewords.length;\n if (numCodewords == shorterBlocksTotalCodewords) {\n break;\n }\n longerBlocksStartAt--;\n }\n longerBlocksStartAt++;\n\n int shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks.getECCodewordsPerBlock();\n // The last elements of result may be 1 element longer;\n // first fill out as many elements as all of them have\n int rawCodewordsOffset = 0;\n for (int i = 0; i < shorterBlocksNumDataCodewords; i++) {\n for (int j = 0; j < numResultBlocks; j++) {\n result[j].codewords[i] = rawCodewords[rawCodewordsOffset++];\n }\n }\n // Fill out the last data block in the longer ones\n for (int j = longerBlocksStartAt; j < numResultBlocks; j++) {\n result[j].codewords[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++];\n }\n // Now add in error correction blocks\n int max = result[0].codewords.length;\n for (int i = shorterBlocksNumDataCodewords; i < max; i++) {\n for (int j = 0; j < numResultBlocks; j++) {\n int iOffset = j < longerBlocksStartAt ? i : i + 1;\n result[j].codewords[iOffset] = rawCodewords[rawCodewordsOffset++];\n }\n }\n return result;\n }\n\n int getNumDataCodewords() {\n return numDataCodewords;\n }\n\n byte[] getCodewords() {\n return codewords;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/decoder/DataMask.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.decoder;\n\nimport com.google.zxing.common.BitMatrix;\n\n/**\n *Encapsulates data masks for the data bits in a QR code, per ISO 18004:2006 6.8. Implementations\n * of this class can un-mask a raw BitMatrix. For simplicity, they will unmask the entire BitMatrix,\n * including areas used for finder patterns, timing patterns, etc. These areas should be unused\n * after the point they are unmasked anyway.
\n *\n *Note that the diagram in section 6.8.1 is misleading since it indicates that i is column position\n * and j is row position. In fact, as the text says, i is row position and j is column position.
\n *\n * @author Sean Owen\n */\nenum DataMask {\n\n // See ISO 18004:2006 6.8.1\n\n /**\n * 000: mask bits for which (x + y) mod 2 == 0\n */\n DATA_MASK_000() {\n @Override\n boolean isMasked(int i, int j) {\n return ((i + j) & 0x01) == 0;\n }\n },\n\n /**\n * 001: mask bits for which x mod 2 == 0\n */\n DATA_MASK_001() {\n @Override\n boolean isMasked(int i, int j) {\n return (i & 0x01) == 0;\n }\n },\n\n /**\n * 010: mask bits for which y mod 3 == 0\n */\n DATA_MASK_010() {\n @Override\n boolean isMasked(int i, int j) {\n return j % 3 == 0;\n }\n },\n\n /**\n * 011: mask bits for which (x + y) mod 3 == 0\n */\n DATA_MASK_011() {\n @Override\n boolean isMasked(int i, int j) {\n return (i + j) % 3 == 0;\n }\n },\n\n /**\n * 100: mask bits for which (x/2 + y/3) mod 2 == 0\n */\n DATA_MASK_100() {\n @Override\n boolean isMasked(int i, int j) {\n return (((i / 2) + (j / 3)) & 0x01) == 0;\n }\n },\n\n /**\n * 101: mask bits for which xy mod 2 + xy mod 3 == 0\n * equivalently, such that xy mod 6 == 0\n */\n DATA_MASK_101() {\n @Override\n boolean isMasked(int i, int j) {\n return (i * j) % 6 == 0;\n }\n },\n\n /**\n * 110: mask bits for which (xy mod 2 + xy mod 3) mod 2 == 0\n * equivalently, such that xy mod 6 < 3\n */\n DATA_MASK_110() {\n @Override\n boolean isMasked(int i, int j) {\n return ((i * j) % 6) < 3;\n }\n },\n\n /**\n * 111: mask bits for which ((x+y)mod 2 + xy mod 3) mod 2 == 0\n * equivalently, such that (x + y + xy mod 3) mod 2 == 0\n */\n DATA_MASK_111() {\n @Override\n boolean isMasked(int i, int j) {\n return ((i + j + ((i * j) % 3)) & 0x01) == 0;\n }\n };\n\n // End of enum constants.\n\n\n /**\n *Implementations of this method reverse the data masking process applied to a QR Code and\n * make its bits ready to read.
\n *\n * @param bits representation of QR Code bits\n * @param dimension dimension of QR Code, represented by bits, being unmasked\n */\n final void unmaskBitMatrix(BitMatrix bits, int dimension) {\n for (int i = 0; i < dimension; i++) {\n for (int j = 0; j < dimension; j++) {\n if (isMasked(i, j)) {\n bits.flip(j, i);\n }\n }\n }\n }\n\n abstract boolean isMasked(int i, int j);\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/decoder/DecodedBitStreamParser.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.decoder;\n\nimport com.google.zxing.DecodeHintType;\nimport com.google.zxing.FormatException;\nimport com.google.zxing.common.BitSource;\nimport com.google.zxing.common.CharacterSetECI;\nimport com.google.zxing.common.DecoderResult;\nimport com.google.zxing.common.StringUtils;\n\nimport java.io.UnsupportedEncodingException;\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.List;\nimport java.util.Map;\n\n/**\n *QR Codes can encode text as bits in one of several modes, and can use multiple modes\n * in one QR Code. This class decodes the bits back into text.
\n *\n *See ISO 18004:2006, 6.4.3 - 6.4.7
\n *\n * @author Sean Owen\n */\nfinal class DecodedBitStreamParser {\n\n /**\n * See ISO 18004:2006, 6.4.4 Table 5\n */\n private static final char[] ALPHANUMERIC_CHARS =\n \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:\".toCharArray();\n private static final int GB2312_SUBSET = 1;\n\n private DecodedBitStreamParser() {\n }\n\n static DecoderResult decode(byte[] bytes,\n Version version,\n ErrorCorrectionLevel ecLevel,\n MapThe main class which implements QR Code decoding -- as opposed to locating and extracting\n * the QR Code from an image.
\n *\n * @author Sean Owen\n */\npublic final class Decoder {\n\n private final ReedSolomonDecoder rsDecoder;\n\n public Decoder() {\n rsDecoder = new ReedSolomonDecoder(GenericGF.QR_CODE_FIELD_256);\n }\n\n public DecoderResult decode(boolean[][] image) throws ChecksumException, FormatException {\n return decode(image, null);\n }\n\n /**\n *Convenience method that can decode a QR Code represented as a 2D array of booleans.\n * \"true\" is taken to mean a black module.
\n *\n * @param image booleans representing white/black QR Code modules\n * @param hints decoding hints that should be used to influence decoding\n * @return text and bytes encoded within the QR Code\n * @throws FormatException if the QR Code cannot be decoded\n * @throws ChecksumException if error correction fails\n */\n public DecoderResult decode(boolean[][] image, MapDecodes a QR Code represented as a {@link BitMatrix}. A 1 or \"true\" is taken to mean a black module.
\n *\n * @param bits booleans representing white/black QR Code modules\n * @param hints decoding hints that should be used to influence decoding\n * @return text and bytes encoded within the QR Code\n * @throws FormatException if the QR Code cannot be decoded\n * @throws ChecksumException if error correction fails\n */\n public DecoderResult decode(BitMatrix bits, MapGiven data and error-correction codewords received, possibly corrupted by errors, attempts to\n * correct the errors in-place using Reed-Solomon error correction.
\n *\n * @param codewordBytes data and error correction codewords\n * @param numDataCodewords number of codewords that are data bytes\n * @throws ChecksumException if error correction fails\n */\n private void correctErrors(byte[] codewordBytes, int numDataCodewords) throws ChecksumException {\n int numCodewords = codewordBytes.length;\n // First read into an array of ints\n int[] codewordsInts = new int[numCodewords];\n for (int i = 0; i < numCodewords; i++) {\n codewordsInts[i] = codewordBytes[i] & 0xFF;\n }\n try {\n rsDecoder.decode(codewordsInts, codewordBytes.length - numDataCodewords);\n } catch (ReedSolomonException ignored) {\n throw ChecksumException.getChecksumInstance();\n }\n // Copy back into array of bytes -- only need to worry about the bytes that were data\n // We don't care about errors in the error-correction codewords\n for (int i = 0; i < numDataCodewords; i++) {\n codewordBytes[i] = (byte) codewordsInts[i];\n }\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/decoder/ErrorCorrectionLevel.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.decoder;\n\n/**\n *See ISO 18004:2006, 6.5.1. This enum encapsulates the four error correction levels\n * defined by the QR code standard.
\n *\n * @author Sean Owen\n */\npublic enum ErrorCorrectionLevel {\n\n /** L = ~7% correction */\n L(0x01),\n /** M = ~15% correction */\n M(0x00),\n /** Q = ~25% correction */\n Q(0x03),\n /** H = ~30% correction */\n H(0x02);\n\n private static final ErrorCorrectionLevel[] FOR_BITS = {M, L, H, Q};\n\n private final int bits;\n\n ErrorCorrectionLevel(int bits) {\n this.bits = bits;\n }\n\n public int getBits() {\n return bits;\n }\n\n /**\n * @param bits int containing the two bits encoding a QR Code's error correction level\n * @return ErrorCorrectionLevel representing the encoded error correction level\n */\n public static ErrorCorrectionLevel forBits(int bits) {\n if (bits < 0 || bits >= FOR_BITS.length) {\n throw new IllegalArgumentException();\n }\n return FOR_BITS[bits];\n }\n\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/decoder/FormatInformation.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.decoder;\n\n/**\n *Encapsulates a QR Code's format information, including the data mask used and\n * error correction level.
\n *\n * @author Sean Owen\n * @see DataMask\n * @see ErrorCorrectionLevel\n */\nfinal class FormatInformation {\n\n private static final int FORMAT_INFO_MASK_QR = 0x5412;\n\n /**\n * See ISO 18004:2006, Annex C, Table C.1\n */\n private static final int[][] FORMAT_INFO_DECODE_LOOKUP = {\n {0x5412, 0x00},\n {0x5125, 0x01},\n {0x5E7C, 0x02},\n {0x5B4B, 0x03},\n {0x45F9, 0x04},\n {0x40CE, 0x05},\n {0x4F97, 0x06},\n {0x4AA0, 0x07},\n {0x77C4, 0x08},\n {0x72F3, 0x09},\n {0x7DAA, 0x0A},\n {0x789D, 0x0B},\n {0x662F, 0x0C},\n {0x6318, 0x0D},\n {0x6C41, 0x0E},\n {0x6976, 0x0F},\n {0x1689, 0x10},\n {0x13BE, 0x11},\n {0x1CE7, 0x12},\n {0x19D0, 0x13},\n {0x0762, 0x14},\n {0x0255, 0x15},\n {0x0D0C, 0x16},\n {0x083B, 0x17},\n {0x355F, 0x18},\n {0x3068, 0x19},\n {0x3F31, 0x1A},\n {0x3A06, 0x1B},\n {0x24B4, 0x1C},\n {0x2183, 0x1D},\n {0x2EDA, 0x1E},\n {0x2BED, 0x1F},\n };\n\n private final ErrorCorrectionLevel errorCorrectionLevel;\n private final byte dataMask;\n\n private FormatInformation(int formatInfo) {\n // Bits 3,4\n errorCorrectionLevel = ErrorCorrectionLevel.forBits((formatInfo >> 3) & 0x03);\n // Bottom 3 bits\n dataMask = (byte) (formatInfo & 0x07);\n }\n\n static int numBitsDiffering(int a, int b) {\n return Integer.bitCount(a ^ b);\n }\n\n /**\n * @param maskedFormatInfo1 format info indicator, with mask still applied\n * @param maskedFormatInfo2 second copy of same info; both are checked at the same time\n * to establish best match\n * @return information about the format it specifies, or {@code null}\n * if doesn't seem to match any known pattern\n */\n static FormatInformation decodeFormatInformation(int maskedFormatInfo1, int maskedFormatInfo2) {\n FormatInformation formatInfo = doDecodeFormatInformation(maskedFormatInfo1, maskedFormatInfo2);\n if (formatInfo != null) {\n return formatInfo;\n }\n // Should return null, but, some QR codes apparently\n // do not mask this info. Try again by actually masking the pattern\n // first\n return doDecodeFormatInformation(maskedFormatInfo1 ^ FORMAT_INFO_MASK_QR,\n maskedFormatInfo2 ^ FORMAT_INFO_MASK_QR);\n }\n\n private static FormatInformation doDecodeFormatInformation(int maskedFormatInfo1, int maskedFormatInfo2) {\n // Find the int in FORMAT_INFO_DECODE_LOOKUP with fewest bits differing\n int bestDifference = Integer.MAX_VALUE;\n int bestFormatInfo = 0;\n for (int[] decodeInfo : FORMAT_INFO_DECODE_LOOKUP) {\n int targetInfo = decodeInfo[0];\n if (targetInfo == maskedFormatInfo1 || targetInfo == maskedFormatInfo2) {\n // Found an exact match\n return new FormatInformation(decodeInfo[1]);\n }\n int bitsDifference = numBitsDiffering(maskedFormatInfo1, targetInfo);\n if (bitsDifference < bestDifference) {\n bestFormatInfo = decodeInfo[1];\n bestDifference = bitsDifference;\n }\n if (maskedFormatInfo1 != maskedFormatInfo2) {\n // also try the other option\n bitsDifference = numBitsDiffering(maskedFormatInfo2, targetInfo);\n if (bitsDifference < bestDifference) {\n bestFormatInfo = decodeInfo[1];\n bestDifference = bitsDifference;\n }\n }\n }\n // Hamming distance of the 32 masked codes is 7, by construction, so <= 3 bits\n // differing means we found a match\n if (bestDifference <= 3) {\n return new FormatInformation(bestFormatInfo);\n }\n return null;\n }\n\n ErrorCorrectionLevel getErrorCorrectionLevel() {\n return errorCorrectionLevel;\n }\n\n byte getDataMask() {\n return dataMask;\n }\n\n @Override\n public int hashCode() {\n return (errorCorrectionLevel.ordinal() << 3) | dataMask;\n }\n\n @Override\n public boolean equals(Object o) {\n if (!(o instanceof FormatInformation)) {\n return false;\n }\n FormatInformation other = (FormatInformation) o;\n return this.errorCorrectionLevel == other.errorCorrectionLevel &&\n this.dataMask == other.dataMask;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/decoder/Mode.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.decoder;\n\n/**\n *See ISO 18004:2006, 6.4.1, Tables 2 and 3. This enum encapsulates the various modes in which\n * data can be encoded to bits in the QR code standard.
\n *\n * @author Sean Owen\n */\npublic enum Mode {\n\n TERMINATOR(new int[]{0, 0, 0}, 0x00), // Not really a mode...\n NUMERIC(new int[]{10, 12, 14}, 0x01),\n ALPHANUMERIC(new int[]{9, 11, 13}, 0x02),\n STRUCTURED_APPEND(new int[]{0, 0, 0}, 0x03), // Not supported\n BYTE(new int[]{8, 16, 16}, 0x04),\n ECI(new int[]{0, 0, 0}, 0x07), // character counts don't apply\n KANJI(new int[]{8, 10, 12}, 0x08),\n FNC1_FIRST_POSITION(new int[]{0, 0, 0}, 0x05),\n FNC1_SECOND_POSITION(new int[]{0, 0, 0}, 0x09),\n /** See GBT 18284-2000; \"Hanzi\" is a transliteration of this mode name. */\n HANZI(new int[]{8, 10, 12}, 0x0D);\n\n private final int[] characterCountBitsForVersions;\n private final int bits;\n\n Mode(int[] characterCountBitsForVersions, int bits) {\n this.characterCountBitsForVersions = characterCountBitsForVersions;\n this.bits = bits;\n }\n\n /**\n * @param bits four bits encoding a QR Code data mode\n * @return Mode encoded by these bits\n * @throws IllegalArgumentException if bits do not correspond to a known mode\n */\n public static Mode forBits(int bits) {\n switch (bits) {\n case 0x0:\n return TERMINATOR;\n case 0x1:\n return NUMERIC;\n case 0x2:\n return ALPHANUMERIC;\n case 0x3:\n return STRUCTURED_APPEND;\n case 0x4:\n return BYTE;\n case 0x5:\n return FNC1_FIRST_POSITION;\n case 0x7:\n return ECI;\n case 0x8:\n return KANJI;\n case 0x9:\n return FNC1_SECOND_POSITION;\n case 0xD:\n // 0xD is defined in GBT 18284-2000, may not be supported in foreign country\n return HANZI;\n default:\n throw new IllegalArgumentException();\n }\n }\n\n /**\n * @param version version in question\n * @return number of bits used, in this QR Code symbol {@link Version}, to encode the\n * count of characters that will follow encoded in this Mode\n */\n public int getCharacterCountBits(Version version) {\n int number = version.getVersionNumber();\n int offset;\n if (number <= 9) {\n offset = 0;\n } else if (number <= 26) {\n offset = 1;\n } else {\n offset = 2;\n }\n return characterCountBitsForVersions[offset];\n }\n\n public int getBits() {\n return bits;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/decoder/QRCodeDecoderMetaData.java", "content": "/*\n * Copyright 2013 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.decoder;\n\nimport com.google.zxing.ResultPoint;\n\n/**\n * Meta-data container for QR Code decoding. Instances of this class may be used to convey information back to the\n * decoding caller. Callers are expected to process this.\n *\n * @see com.google.zxing.common.DecoderResult#getOther()\n */\npublic final class QRCodeDecoderMetaData {\n\n private final boolean mirrored;\n\n QRCodeDecoderMetaData(boolean mirrored) {\n this.mirrored = mirrored;\n }\n\n /**\n * @return true if the QR Code was mirrored.\n */\n public boolean isMirrored() {\n return mirrored;\n }\n\n /**\n * Apply the result points' order correction due to mirroring.\n *\n * @param points Array of points to apply mirror correction to.\n */\n public void applyMirroredCorrection(ResultPoint[] points) {\n if (!mirrored || points == null || points.length < 3) {\n return;\n }\n ResultPoint bottomLeft = points[0];\n points[0] = points[2];\n points[2] = bottomLeft;\n // No need to 'fix' top-left and alignment pattern.\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/decoder/Version.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.decoder;\n\nimport com.google.zxing.FormatException;\nimport com.google.zxing.common.BitMatrix;\n\n/**\n * See ISO 18004:2006 Annex D\n *\n * @author Sean Owen\n */\npublic final class Version {\n\n /**\n * See ISO 18004:2006 Annex D.\n * Element i represents the raw version bits that specify version i + 7\n */\n private static final int[] VERSION_DECODE_INFO = {\n 0x07C94, 0x085BC, 0x09A99, 0x0A4D3, 0x0BBF6,\n 0x0C762, 0x0D847, 0x0E60D, 0x0F928, 0x10B78,\n 0x1145D, 0x12A17, 0x13532, 0x149A6, 0x15683,\n 0x168C9, 0x177EC, 0x18EC4, 0x191E1, 0x1AFAB,\n 0x1B08E, 0x1CC1A, 0x1D33F, 0x1ED75, 0x1F250,\n 0x209D5, 0x216F0, 0x228BA, 0x2379F, 0x24B0B,\n 0x2542E, 0x26A64, 0x27541, 0x28C69\n };\n\n private static final Version[] VERSIONS = buildVersions();\n\n private final int versionNumber;\n private final int[] alignmentPatternCenters;\n private final ECBlocks[] ecBlocks;\n private final int totalCodewords;\n\n private Version(int versionNumber,\n int[] alignmentPatternCenters,\n ECBlocks... ecBlocks) {\n this.versionNumber = versionNumber;\n this.alignmentPatternCenters = alignmentPatternCenters;\n this.ecBlocks = ecBlocks;\n int total = 0;\n int ecCodewords = ecBlocks[0].getECCodewordsPerBlock();\n ECB[] ecbArray = ecBlocks[0].getECBlocks();\n for (ECB ecBlock : ecbArray) {\n total += ecBlock.getCount() * (ecBlock.getDataCodewords() + ecCodewords);\n }\n this.totalCodewords = total;\n }\n\n public int getVersionNumber() {\n return versionNumber;\n }\n\n public int[] getAlignmentPatternCenters() {\n return alignmentPatternCenters;\n }\n\n public int getTotalCodewords() {\n return totalCodewords;\n }\n\n public int getDimensionForVersion() {\n return 17 + 4 * versionNumber;\n }\n\n public ECBlocks getECBlocksForLevel(ErrorCorrectionLevel ecLevel) {\n return ecBlocks[ecLevel.ordinal()];\n }\n\n /**\n *Deduces version information purely from QR Code dimensions.
\n *\n * @param dimension dimension in modules\n * @return Version for a QR Code of that dimension\n * @throws FormatException if dimension is not 1 mod 4\n */\n public static Version getProvisionalVersionForDimension(int dimension) throws FormatException {\n if (dimension % 4 != 1) {\n throw FormatException.getFormatInstance();\n }\n try {\n return getVersionForNumber((dimension - 17) / 4);\n } catch (IllegalArgumentException ignored) {\n throw FormatException.getFormatInstance();\n }\n }\n\n public static Version getVersionForNumber(int versionNumber) {\n if (versionNumber < 1 || versionNumber > 40) {\n throw new IllegalArgumentException();\n }\n return VERSIONS[versionNumber - 1];\n }\n\n static Version decodeVersionInformation(int versionBits) {\n int bestDifference = Integer.MAX_VALUE;\n int bestVersion = 0;\n for (int i = 0; i < VERSION_DECODE_INFO.length; i++) {\n int targetVersion = VERSION_DECODE_INFO[i];\n // Do the version info bits match exactly? done.\n if (targetVersion == versionBits) {\n return getVersionForNumber(i + 7);\n }\n // Otherwise see if this is the closest to a real version info bit string\n // we have seen so far\n int bitsDifference = FormatInformation.numBitsDiffering(versionBits, targetVersion);\n if (bitsDifference < bestDifference) {\n bestVersion = i + 7;\n bestDifference = bitsDifference;\n }\n }\n // We can tolerate up to 3 bits of error since no two version info codewords will\n // differ in less than 8 bits.\n if (bestDifference <= 3) {\n return getVersionForNumber(bestVersion);\n }\n // If we didn't find a close enough match, fail\n return null;\n }\n\n /**\n * See ISO 18004:2006 Annex E\n */\n BitMatrix buildFunctionPattern() {\n int dimension = getDimensionForVersion();\n BitMatrix bitMatrix = new BitMatrix(dimension);\n\n // Top left finder pattern + separator + format\n bitMatrix.setRegion(0, 0, 9, 9);\n // Top right finder pattern + separator + format\n bitMatrix.setRegion(dimension - 8, 0, 8, 9);\n // Bottom left finder pattern + separator + format\n bitMatrix.setRegion(0, dimension - 8, 9, 8);\n\n // Alignment patterns\n int max = alignmentPatternCenters.length;\n for (int x = 0; x < max; x++) {\n int i = alignmentPatternCenters[x] - 2;\n for (int y = 0; y < max; y++) {\n if ((x == 0 && (y == 0 || y == max - 1)) || (x == max - 1 && y == 0)) {\n // No alignment patterns near the three finder patterns\n continue;\n }\n bitMatrix.setRegion(alignmentPatternCenters[y] - 2, i, 5, 5);\n }\n }\n\n // Vertical timing pattern\n bitMatrix.setRegion(6, 9, 1, dimension - 17);\n // Horizontal timing pattern\n bitMatrix.setRegion(9, 6, dimension - 17, 1);\n\n if (versionNumber > 6) {\n // Version info, top right\n bitMatrix.setRegion(dimension - 11, 0, 3, 6);\n // Version info, bottom left\n bitMatrix.setRegion(0, dimension - 11, 6, 3);\n }\n\n return bitMatrix;\n }\n\n /**\n *Encapsulates a set of error-correction blocks in one symbol version. Most versions will\n * use blocks of differing sizes within one version, so, this encapsulates the parameters for\n * each set of blocks. It also holds the number of error-correction codewords per block since it\n * will be the same across all blocks within one version.
\n */\n public static final class ECBlocks {\n private final int ecCodewordsPerBlock;\n private final ECB[] ecBlocks;\n\n ECBlocks(int ecCodewordsPerBlock, ECB... ecBlocks) {\n this.ecCodewordsPerBlock = ecCodewordsPerBlock;\n this.ecBlocks = ecBlocks;\n }\n\n public int getECCodewordsPerBlock() {\n return ecCodewordsPerBlock;\n }\n\n public int getNumBlocks() {\n int total = 0;\n for (ECB ecBlock : ecBlocks) {\n total += ecBlock.getCount();\n }\n return total;\n }\n\n public int getTotalECCodewords() {\n return ecCodewordsPerBlock * getNumBlocks();\n }\n\n public ECB[] getECBlocks() {\n return ecBlocks;\n }\n }\n\n /**\n *Encapsulates the parameters for one error-correction block in one symbol version.\n * This includes the number of data codewords, and the number of times a block with these\n * parameters is used consecutively in the QR code version's format.
\n */\n public static final class ECB {\n private final int count;\n private final int dataCodewords;\n\n ECB(int count, int dataCodewords) {\n this.count = count;\n this.dataCodewords = dataCodewords;\n }\n\n public int getCount() {\n return count;\n }\n\n public int getDataCodewords() {\n return dataCodewords;\n }\n }\n\n @Override\n public String toString() {\n return String.valueOf(versionNumber);\n }\n\n /**\n * See ISO 18004:2006 6.5.1 Table 9\n */\n private static Version[] buildVersions() {\n return new Version[]{\n new Version(1, new int[]{},\n new ECBlocks(7, new ECB(1, 19)),\n new ECBlocks(10, new ECB(1, 16)),\n new ECBlocks(13, new ECB(1, 13)),\n new ECBlocks(17, new ECB(1, 9))),\n new Version(2, new int[]{6, 18},\n new ECBlocks(10, new ECB(1, 34)),\n new ECBlocks(16, new ECB(1, 28)),\n new ECBlocks(22, new ECB(1, 22)),\n new ECBlocks(28, new ECB(1, 16))),\n new Version(3, new int[]{6, 22},\n new ECBlocks(15, new ECB(1, 55)),\n new ECBlocks(26, new ECB(1, 44)),\n new ECBlocks(18, new ECB(2, 17)),\n new ECBlocks(22, new ECB(2, 13))),\n new Version(4, new int[]{6, 26},\n new ECBlocks(20, new ECB(1, 80)),\n new ECBlocks(18, new ECB(2, 32)),\n new ECBlocks(26, new ECB(2, 24)),\n new ECBlocks(16, new ECB(4, 9))),\n new Version(5, new int[]{6, 30},\n new ECBlocks(26, new ECB(1, 108)),\n new ECBlocks(24, new ECB(2, 43)),\n new ECBlocks(18, new ECB(2, 15),\n new ECB(2, 16)),\n new ECBlocks(22, new ECB(2, 11),\n new ECB(2, 12))),\n new Version(6, new int[]{6, 34},\n new ECBlocks(18, new ECB(2, 68)),\n new ECBlocks(16, new ECB(4, 27)),\n new ECBlocks(24, new ECB(4, 19)),\n new ECBlocks(28, new ECB(4, 15))),\n new Version(7, new int[]{6, 22, 38},\n new ECBlocks(20, new ECB(2, 78)),\n new ECBlocks(18, new ECB(4, 31)),\n new ECBlocks(18, new ECB(2, 14),\n new ECB(4, 15)),\n new ECBlocks(26, new ECB(4, 13),\n new ECB(1, 14))),\n new Version(8, new int[]{6, 24, 42},\n new ECBlocks(24, new ECB(2, 97)),\n new ECBlocks(22, new ECB(2, 38),\n new ECB(2, 39)),\n new ECBlocks(22, new ECB(4, 18),\n new ECB(2, 19)),\n new ECBlocks(26, new ECB(4, 14),\n new ECB(2, 15))),\n new Version(9, new int[]{6, 26, 46},\n new ECBlocks(30, new ECB(2, 116)),\n new ECBlocks(22, new ECB(3, 36),\n new ECB(2, 37)),\n new ECBlocks(20, new ECB(4, 16),\n new ECB(4, 17)),\n new ECBlocks(24, new ECB(4, 12),\n new ECB(4, 13))),\n new Version(10, new int[]{6, 28, 50},\n new ECBlocks(18, new ECB(2, 68),\n new ECB(2, 69)),\n new ECBlocks(26, new ECB(4, 43),\n new ECB(1, 44)),\n new ECBlocks(24, new ECB(6, 19),\n new ECB(2, 20)),\n new ECBlocks(28, new ECB(6, 15),\n new ECB(2, 16))),\n new Version(11, new int[]{6, 30, 54},\n new ECBlocks(20, new ECB(4, 81)),\n new ECBlocks(30, new ECB(1, 50),\n new ECB(4, 51)),\n new ECBlocks(28, new ECB(4, 22),\n new ECB(4, 23)),\n new ECBlocks(24, new ECB(3, 12),\n new ECB(8, 13))),\n new Version(12, new int[]{6, 32, 58},\n new ECBlocks(24, new ECB(2, 92),\n new ECB(2, 93)),\n new ECBlocks(22, new ECB(6, 36),\n new ECB(2, 37)),\n new ECBlocks(26, new ECB(4, 20),\n new ECB(6, 21)),\n new ECBlocks(28, new ECB(7, 14),\n new ECB(4, 15))),\n new Version(13, new int[]{6, 34, 62},\n new ECBlocks(26, new ECB(4, 107)),\n new ECBlocks(22, new ECB(8, 37),\n new ECB(1, 38)),\n new ECBlocks(24, new ECB(8, 20),\n new ECB(4, 21)),\n new ECBlocks(22, new ECB(12, 11),\n new ECB(4, 12))),\n new Version(14, new int[]{6, 26, 46, 66},\n new ECBlocks(30, new ECB(3, 115),\n new ECB(1, 116)),\n new ECBlocks(24, new ECB(4, 40),\n new ECB(5, 41)),\n new ECBlocks(20, new ECB(11, 16),\n new ECB(5, 17)),\n new ECBlocks(24, new ECB(11, 12),\n new ECB(5, 13))),\n new Version(15, new int[]{6, 26, 48, 70},\n new ECBlocks(22, new ECB(5, 87),\n new ECB(1, 88)),\n new ECBlocks(24, new ECB(5, 41),\n new ECB(5, 42)),\n new ECBlocks(30, new ECB(5, 24),\n new ECB(7, 25)),\n new ECBlocks(24, new ECB(11, 12),\n new ECB(7, 13))),\n new Version(16, new int[]{6, 26, 50, 74},\n new ECBlocks(24, new ECB(5, 98),\n new ECB(1, 99)),\n new ECBlocks(28, new ECB(7, 45),\n new ECB(3, 46)),\n new ECBlocks(24, new ECB(15, 19),\n new ECB(2, 20)),\n new ECBlocks(30, new ECB(3, 15),\n new ECB(13, 16))),\n new Version(17, new int[]{6, 30, 54, 78},\n new ECBlocks(28, new ECB(1, 107),\n new ECB(5, 108)),\n new ECBlocks(28, new ECB(10, 46),\n new ECB(1, 47)),\n new ECBlocks(28, new ECB(1, 22),\n new ECB(15, 23)),\n new ECBlocks(28, new ECB(2, 14),\n new ECB(17, 15))),\n new Version(18, new int[]{6, 30, 56, 82},\n new ECBlocks(30, new ECB(5, 120),\n new ECB(1, 121)),\n new ECBlocks(26, new ECB(9, 43),\n new ECB(4, 44)),\n new ECBlocks(28, new ECB(17, 22),\n new ECB(1, 23)),\n new ECBlocks(28, new ECB(2, 14),\n new ECB(19, 15))),\n new Version(19, new int[]{6, 30, 58, 86},\n new ECBlocks(28, new ECB(3, 113),\n new ECB(4, 114)),\n new ECBlocks(26, new ECB(3, 44),\n new ECB(11, 45)),\n new ECBlocks(26, new ECB(17, 21),\n new ECB(4, 22)),\n new ECBlocks(26, new ECB(9, 13),\n new ECB(16, 14))),\n new Version(20, new int[]{6, 34, 62, 90},\n new ECBlocks(28, new ECB(3, 107),\n new ECB(5, 108)),\n new ECBlocks(26, new ECB(3, 41),\n new ECB(13, 42)),\n new ECBlocks(30, new ECB(15, 24),\n new ECB(5, 25)),\n new ECBlocks(28, new ECB(15, 15),\n new ECB(10, 16))),\n new Version(21, new int[]{6, 28, 50, 72, 94},\n new ECBlocks(28, new ECB(4, 116),\n new ECB(4, 117)),\n new ECBlocks(26, new ECB(17, 42)),\n new ECBlocks(28, new ECB(17, 22),\n new ECB(6, 23)),\n new ECBlocks(30, new ECB(19, 16),\n new ECB(6, 17))),\n new Version(22, new int[]{6, 26, 50, 74, 98},\n new ECBlocks(28, new ECB(2, 111),\n new ECB(7, 112)),\n new ECBlocks(28, new ECB(17, 46)),\n new ECBlocks(30, new ECB(7, 24),\n new ECB(16, 25)),\n new ECBlocks(24, new ECB(34, 13))),\n new Version(23, new int[]{6, 30, 54, 78, 102},\n new ECBlocks(30, new ECB(4, 121),\n new ECB(5, 122)),\n new ECBlocks(28, new ECB(4, 47),\n new ECB(14, 48)),\n new ECBlocks(30, new ECB(11, 24),\n new ECB(14, 25)),\n new ECBlocks(30, new ECB(16, 15),\n new ECB(14, 16))),\n new Version(24, new int[]{6, 28, 54, 80, 106},\n new ECBlocks(30, new ECB(6, 117),\n new ECB(4, 118)),\n new ECBlocks(28, new ECB(6, 45),\n new ECB(14, 46)),\n new ECBlocks(30, new ECB(11, 24),\n new ECB(16, 25)),\n new ECBlocks(30, new ECB(30, 16),\n new ECB(2, 17))),\n new Version(25, new int[]{6, 32, 58, 84, 110},\n new ECBlocks(26, new ECB(8, 106),\n new ECB(4, 107)),\n new ECBlocks(28, new ECB(8, 47),\n new ECB(13, 48)),\n new ECBlocks(30, new ECB(7, 24),\n new ECB(22, 25)),\n new ECBlocks(30, new ECB(22, 15),\n new ECB(13, 16))),\n new Version(26, new int[]{6, 30, 58, 86, 114},\n new ECBlocks(28, new ECB(10, 114),\n new ECB(2, 115)),\n new ECBlocks(28, new ECB(19, 46),\n new ECB(4, 47)),\n new ECBlocks(28, new ECB(28, 22),\n new ECB(6, 23)),\n new ECBlocks(30, new ECB(33, 16),\n new ECB(4, 17))),\n new Version(27, new int[]{6, 34, 62, 90, 118},\n new ECBlocks(30, new ECB(8, 122),\n new ECB(4, 123)),\n new ECBlocks(28, new ECB(22, 45),\n new ECB(3, 46)),\n new ECBlocks(30, new ECB(8, 23),\n new ECB(26, 24)),\n new ECBlocks(30, new ECB(12, 15),\n new ECB(28, 16))),\n new Version(28, new int[]{6, 26, 50, 74, 98, 122},\n new ECBlocks(30, new ECB(3, 117),\n new ECB(10, 118)),\n new ECBlocks(28, new ECB(3, 45),\n new ECB(23, 46)),\n new ECBlocks(30, new ECB(4, 24),\n new ECB(31, 25)),\n new ECBlocks(30, new ECB(11, 15),\n new ECB(31, 16))),\n new Version(29, new int[]{6, 30, 54, 78, 102, 126},\n new ECBlocks(30, new ECB(7, 116),\n new ECB(7, 117)),\n new ECBlocks(28, new ECB(21, 45),\n new ECB(7, 46)),\n new ECBlocks(30, new ECB(1, 23),\n new ECB(37, 24)),\n new ECBlocks(30, new ECB(19, 15),\n new ECB(26, 16))),\n new Version(30, new int[]{6, 26, 52, 78, 104, 130},\n new ECBlocks(30, new ECB(5, 115),\n new ECB(10, 116)),\n new ECBlocks(28, new ECB(19, 47),\n new ECB(10, 48)),\n new ECBlocks(30, new ECB(15, 24),\n new ECB(25, 25)),\n new ECBlocks(30, new ECB(23, 15),\n new ECB(25, 16))),\n new Version(31, new int[]{6, 30, 56, 82, 108, 134},\n new ECBlocks(30, new ECB(13, 115),\n new ECB(3, 116)),\n new ECBlocks(28, new ECB(2, 46),\n new ECB(29, 47)),\n new ECBlocks(30, new ECB(42, 24),\n new ECB(1, 25)),\n new ECBlocks(30, new ECB(23, 15),\n new ECB(28, 16))),\n new Version(32, new int[]{6, 34, 60, 86, 112, 138},\n new ECBlocks(30, new ECB(17, 115)),\n new ECBlocks(28, new ECB(10, 46),\n new ECB(23, 47)),\n new ECBlocks(30, new ECB(10, 24),\n new ECB(35, 25)),\n new ECBlocks(30, new ECB(19, 15),\n new ECB(35, 16))),\n new Version(33, new int[]{6, 30, 58, 86, 114, 142},\n new ECBlocks(30, new ECB(17, 115),\n new ECB(1, 116)),\n new ECBlocks(28, new ECB(14, 46),\n new ECB(21, 47)),\n new ECBlocks(30, new ECB(29, 24),\n new ECB(19, 25)),\n new ECBlocks(30, new ECB(11, 15),\n new ECB(46, 16))),\n new Version(34, new int[]{6, 34, 62, 90, 118, 146},\n new ECBlocks(30, new ECB(13, 115),\n new ECB(6, 116)),\n new ECBlocks(28, new ECB(14, 46),\n new ECB(23, 47)),\n new ECBlocks(30, new ECB(44, 24),\n new ECB(7, 25)),\n new ECBlocks(30, new ECB(59, 16),\n new ECB(1, 17))),\n new Version(35, new int[]{6, 30, 54, 78, 102, 126, 150},\n new ECBlocks(30, new ECB(12, 121),\n new ECB(7, 122)),\n new ECBlocks(28, new ECB(12, 47),\n new ECB(26, 48)),\n new ECBlocks(30, new ECB(39, 24),\n new ECB(14, 25)),\n new ECBlocks(30, new ECB(22, 15),\n new ECB(41, 16))),\n new Version(36, new int[]{6, 24, 50, 76, 102, 128, 154},\n new ECBlocks(30, new ECB(6, 121),\n new ECB(14, 122)),\n new ECBlocks(28, new ECB(6, 47),\n new ECB(34, 48)),\n new ECBlocks(30, new ECB(46, 24),\n new ECB(10, 25)),\n new ECBlocks(30, new ECB(2, 15),\n new ECB(64, 16))),\n new Version(37, new int[]{6, 28, 54, 80, 106, 132, 158},\n new ECBlocks(30, new ECB(17, 122),\n new ECB(4, 123)),\n new ECBlocks(28, new ECB(29, 46),\n new ECB(14, 47)),\n new ECBlocks(30, new ECB(49, 24),\n new ECB(10, 25)),\n new ECBlocks(30, new ECB(24, 15),\n new ECB(46, 16))),\n new Version(38, new int[]{6, 32, 58, 84, 110, 136, 162},\n new ECBlocks(30, new ECB(4, 122),\n new ECB(18, 123)),\n new ECBlocks(28, new ECB(13, 46),\n new ECB(32, 47)),\n new ECBlocks(30, new ECB(48, 24),\n new ECB(14, 25)),\n new ECBlocks(30, new ECB(42, 15),\n new ECB(32, 16))),\n new Version(39, new int[]{6, 26, 54, 82, 110, 138, 166},\n new ECBlocks(30, new ECB(20, 117),\n new ECB(4, 118)),\n new ECBlocks(28, new ECB(40, 47),\n new ECB(7, 48)),\n new ECBlocks(30, new ECB(43, 24),\n new ECB(22, 25)),\n new ECBlocks(30, new ECB(10, 15),\n new ECB(67, 16))),\n new Version(40, new int[]{6, 30, 58, 86, 114, 142, 170},\n new ECBlocks(30, new ECB(19, 118),\n new ECB(6, 119)),\n new ECBlocks(28, new ECB(18, 47),\n new ECB(31, 48)),\n new ECBlocks(30, new ECB(34, 24),\n new ECB(34, 25)),\n new ECBlocks(30, new ECB(20, 15),\n new ECB(61, 16)))\n };\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/detector/AlignmentPattern.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.detector;\n\nimport com.google.zxing.ResultPoint;\n\n/**\n *Encapsulates an alignment pattern, which are the smaller square patterns found in\n * all but the simplest QR Codes.
\n *\n * @author Sean Owen\n */\npublic final class AlignmentPattern extends ResultPoint {\n\n private final float estimatedModuleSize;\n\n AlignmentPattern(float posX, float posY, float estimatedModuleSize) {\n super(posX, posY);\n this.estimatedModuleSize = estimatedModuleSize;\n }\n\n /**\n *Determines if this alignment pattern \"about equals\" an alignment pattern at the stated\n * position and size -- meaning, it is at nearly the same center with nearly the same size.
\n */\n boolean aboutEquals(float moduleSize, float i, float j) {\n if (Math.abs(i - getY()) <= moduleSize && Math.abs(j - getX()) <= moduleSize) {\n float moduleSizeDiff = Math.abs(moduleSize - estimatedModuleSize);\n return moduleSizeDiff <= 1.0f || moduleSizeDiff <= estimatedModuleSize;\n }\n return false;\n }\n\n /**\n * Combines this object's current estimate of a finder pattern position and module size\n * with a new estimate. It returns a new {@code FinderPattern} containing an average of the two.\n */\n AlignmentPattern combineEstimate(float i, float j, float newModuleSize) {\n float combinedX = (getX() + j) / 2.0f;\n float combinedY = (getY() + i) / 2.0f;\n float combinedModuleSize = (estimatedModuleSize + newModuleSize) / 2.0f;\n return new AlignmentPattern(combinedX, combinedY, combinedModuleSize);\n }\n\n}" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/detector/AlignmentPatternFinder.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.detector;\n\nimport com.google.zxing.NotFoundException;\nimport com.google.zxing.ResultPointCallback;\nimport com.google.zxing.common.BitMatrix;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\n/**\n *This class attempts to find alignment patterns in a QR Code. Alignment patterns look like finder\n * patterns but are smaller and appear at regular intervals throughout the image.
\n *\n *At the moment this only looks for the bottom-right alignment pattern.
\n *\n *This is mostly a simplified copy of {@link FinderPatternFinder}. It is copied,\n * pasted and stripped down here for maximum performance but does unfortunately duplicate\n * some code.
\n *\n *This class is thread-safe but not reentrant. Each thread must allocate its own object.
\n *\n * @author Sean Owen\n */\nfinal class AlignmentPatternFinder {\n\n private final BitMatrix image;\n private final ListCreates a finder that will look in a portion of the whole image.
\n *\n * @param image image to search\n * @param startX left column from which to start searching\n * @param startY top row from which to start searching\n * @param width width of region to search\n * @param height height of region to search\n * @param moduleSize estimated module size so far\n */\n AlignmentPatternFinder(BitMatrix image,\n int startX,\n int startY,\n int width,\n int height,\n float moduleSize,\n ResultPointCallback resultPointCallback) {\n this.image = image;\n this.possibleCenters = new ArrayList<>(5);\n this.startX = startX;\n this.startY = startY;\n this.width = width;\n this.height = height;\n this.moduleSize = moduleSize;\n this.crossCheckStateCount = new int[3];\n this.resultPointCallback = resultPointCallback;\n }\n\n /**\n *This method attempts to find the bottom-right alignment pattern in the image. It is a bit messy since\n * it's pretty performance-critical and so is written to be fast foremost.
\n *\n * @return {@link AlignmentPattern} if found\n * @throws NotFoundException if not found\n */\n AlignmentPattern find() throws NotFoundException {\n int startX = this.startX;\n int height = this.height;\n int maxJ = startX + width;\n int middleI = startY + (height / 2);\n // We are looking for black/white/black modules in 1:1:1 ratio;\n // this tracks the number of black/white/black modules seen so far\n int[] stateCount = new int[3];\n for (int iGen = 0; iGen < height; iGen++) {\n // Search from middle outwards\n int i = middleI + ((iGen & 0x01) == 0 ? (iGen + 1) / 2 : -((iGen + 1) / 2));\n stateCount[0] = 0;\n stateCount[1] = 0;\n stateCount[2] = 0;\n int j = startX;\n // Burn off leading white pixels before anything else; if we start in the middle of\n // a white run, it doesn't make sense to count its length, since we don't know if the\n // white run continued to the left of the start point\n while (j < maxJ && !image.get(j, i)) {\n j++;\n }\n int currentState = 0;\n while (j < maxJ) {\n if (image.get(j, i)) {\n // Black pixel\n if (currentState == 1) { // Counting black pixels\n stateCount[1]++;\n } else { // Counting white pixels\n if (currentState == 2) { // A winner?\n if (foundPatternCross(stateCount)) { // Yes\n AlignmentPattern confirmed = handlePossibleCenter(stateCount, i, j);\n if (confirmed != null) {\n return confirmed;\n }\n }\n stateCount[0] = stateCount[2];\n stateCount[1] = 1;\n stateCount[2] = 0;\n currentState = 1;\n } else {\n stateCount[++currentState]++;\n }\n }\n } else { // White pixel\n if (currentState == 1) { // Counting black pixels\n currentState++;\n }\n stateCount[currentState]++;\n }\n j++;\n }\n if (foundPatternCross(stateCount)) {\n AlignmentPattern confirmed = handlePossibleCenter(stateCount, i, maxJ);\n if (confirmed != null) {\n return confirmed;\n }\n }\n\n }\n\n // Hmm, nothing we saw was observed and confirmed twice. If we had\n // any guess at all, return it.\n if (!possibleCenters.isEmpty()) {\n return possibleCenters.get(0);\n }\n\n throw NotFoundException.getNotFoundInstance();\n }\n\n /**\n * Given a count of black/white/black pixels just seen and an end position,\n * figures the location of the center of this black/white/black run.\n */\n private static float centerFromEnd(int[] stateCount, int end) {\n return (end - stateCount[2]) - stateCount[1] / 2.0f;\n }\n\n /**\n * @param stateCount count of black/white/black pixels just read\n * @return true iff the proportions of the counts is close enough to the 1/1/1 ratios\n * used by alignment patterns to be considered a match\n */\n private boolean foundPatternCross(int[] stateCount) {\n float moduleSize = this.moduleSize;\n float maxVariance = moduleSize / 2.0f;\n for (int i = 0; i < 3; i++) {\n if (Math.abs(moduleSize - stateCount[i]) >= maxVariance) {\n return false;\n }\n }\n return true;\n }\n\n /**\n *After a horizontal scan finds a potential alignment pattern, this method\n * \"cross-checks\" by scanning down vertically through the center of the possible\n * alignment pattern to see if the same proportion is detected.
\n *\n * @param startI row where an alignment pattern was detected\n * @param centerJ center of the section that appears to cross an alignment pattern\n * @param maxCount maximum reasonable number of modules that should be\n * observed in any reading state, based on the results of the horizontal scan\n * @return vertical center of alignment pattern, or {@link Float#NaN} if not found\n */\n private float crossCheckVertical(int startI, int centerJ, int maxCount,\n int originalStateCountTotal) {\n BitMatrix image = this.image;\n\n int maxI = image.getHeight();\n int[] stateCount = crossCheckStateCount;\n stateCount[0] = 0;\n stateCount[1] = 0;\n stateCount[2] = 0;\n\n // Start counting up from center\n int i = startI;\n while (i >= 0 && image.get(centerJ, i) && stateCount[1] <= maxCount) {\n stateCount[1]++;\n i--;\n }\n // If already too many modules in this state or ran off the edge:\n if (i < 0 || stateCount[1] > maxCount) {\n return Float.NaN;\n }\n while (i >= 0 && !image.get(centerJ, i) && stateCount[0] <= maxCount) {\n stateCount[0]++;\n i--;\n }\n if (stateCount[0] > maxCount) {\n return Float.NaN;\n }\n\n // Now also count down from center\n i = startI + 1;\n while (i < maxI && image.get(centerJ, i) && stateCount[1] <= maxCount) {\n stateCount[1]++;\n i++;\n }\n if (i == maxI || stateCount[1] > maxCount) {\n return Float.NaN;\n }\n while (i < maxI && !image.get(centerJ, i) && stateCount[2] <= maxCount) {\n stateCount[2]++;\n i++;\n }\n if (stateCount[2] > maxCount) {\n return Float.NaN;\n }\n\n int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];\n if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {\n return Float.NaN;\n }\n\n return foundPatternCross(stateCount) ? centerFromEnd(stateCount, i) : Float.NaN;\n }\n\n /**\n *This is called when a horizontal scan finds a possible alignment pattern. It will\n * cross check with a vertical scan, and if successful, will see if this pattern had been\n * found on a previous horizontal scan. If so, we consider it confirmed and conclude we have\n * found the alignment pattern.
\n *\n * @param stateCount reading state module counts from horizontal scan\n * @param i row where alignment pattern may be found\n * @param j end of possible alignment pattern in row\n * @return {@link AlignmentPattern} if we have found the same pattern twice, or null if not\n */\n private AlignmentPattern handlePossibleCenter(int[] stateCount, int i, int j) {\n int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];\n float centerJ = centerFromEnd(stateCount, j);\n float centerI = crossCheckVertical(i, (int) centerJ, 2 * stateCount[1], stateCountTotal);\n if (!Float.isNaN(centerI)) {\n float estimatedModuleSize = (stateCount[0] + stateCount[1] + stateCount[2]) / 3.0f;\n for (AlignmentPattern center : possibleCenters) {\n // Look for about the same center and module size:\n if (center.aboutEquals(estimatedModuleSize, centerI, centerJ)) {\n return center.combineEstimate(centerI, centerJ, estimatedModuleSize);\n }\n }\n // Hadn't found this before; save it\n AlignmentPattern point = new AlignmentPattern(centerJ, centerI, estimatedModuleSize);\n possibleCenters.add(point);\n if (resultPointCallback != null) {\n resultPointCallback.foundPossibleResultPoint(point);\n }\n }\n return null;\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/detector/Detector.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.detector;\n\nimport com.google.zxing.DecodeHintType;\nimport com.google.zxing.FormatException;\nimport com.google.zxing.NotFoundException;\nimport com.google.zxing.ResultPoint;\nimport com.google.zxing.ResultPointCallback;\nimport com.google.zxing.common.BitMatrix;\nimport com.google.zxing.common.DetectorResult;\nimport com.google.zxing.common.GridSampler;\nimport com.google.zxing.common.PerspectiveTransform;\nimport com.google.zxing.common.detector.MathUtils;\nimport com.google.zxing.qrcode.decoder.Version;\n\nimport java.util.Map;\n\n/**\n *Encapsulates logic that can detect a QR Code in an image, even if the QR Code\n * is rotated or skewed, or partially obscured.
\n *\n * @author Sean Owen\n */\npublic class Detector {\n\n private final BitMatrix image;\n private ResultPointCallback resultPointCallback;\n\n public Detector(BitMatrix image) {\n this.image = image;\n }\n\n protected final BitMatrix getImage() {\n return image;\n }\n\n protected final ResultPointCallback getResultPointCallback() {\n return resultPointCallback;\n }\n\n /**\n *Detects a QR Code in an image.
\n *\n * @return {@link DetectorResult} encapsulating results of detecting a QR Code\n * @throws NotFoundException if QR Code cannot be found\n * @throws FormatException if a QR Code cannot be decoded\n */\n public DetectorResult detect() throws NotFoundException, FormatException {\n return detect(null);\n }\n\n /**\n *Detects a QR Code in an image.
\n *\n * @param hints optional hints to detector\n * @return {@link DetectorResult} encapsulating results of detecting a QR Code\n * @throws NotFoundException if QR Code cannot be found\n * @throws FormatException if a QR Code cannot be decoded\n */\n public final DetectorResult detect(MapComputes the dimension (number of modules on a size) of the QR Code based on the position\n * of the finder patterns and estimated module size.
\n */\n private static int computeDimension(ResultPoint topLeft,\n ResultPoint topRight,\n ResultPoint bottomLeft,\n float moduleSize) throws NotFoundException {\n int tltrCentersDimension = MathUtils.round(ResultPoint.distance(topLeft, topRight) / moduleSize);\n int tlblCentersDimension = MathUtils.round(ResultPoint.distance(topLeft, bottomLeft) / moduleSize);\n int dimension = ((tltrCentersDimension + tlblCentersDimension) / 2) + 7;\n switch (dimension & 0x03) { // mod 4\n case 0:\n dimension++;\n break;\n // 1? do nothing\n case 2:\n dimension--;\n break;\n case 3:\n throw NotFoundException.getNotFoundInstance();\n }\n return dimension;\n }\n\n /**\n *Computes an average estimated module size based on estimated derived from the positions\n * of the three finder patterns.
\n *\n * @param topLeft detected top-left finder pattern center\n * @param topRight detected top-right finder pattern center\n * @param bottomLeft detected bottom-left finder pattern center\n * @return estimated module size\n */\n protected final float calculateModuleSize(ResultPoint topLeft,\n ResultPoint topRight,\n ResultPoint bottomLeft) {\n // Take the average\n return (calculateModuleSizeOneWay(topLeft, topRight) +\n calculateModuleSizeOneWay(topLeft, bottomLeft)) / 2.0f;\n }\n\n /**\n *Estimates module size based on two finder patterns -- it uses\n * {@link #sizeOfBlackWhiteBlackRunBothWays(int, int, int, int)} to figure the\n * width of each, measuring along the axis between their centers.
\n */\n private float calculateModuleSizeOneWay(ResultPoint pattern, ResultPoint otherPattern) {\n float moduleSizeEst1 = sizeOfBlackWhiteBlackRunBothWays((int) pattern.getX(),\n (int) pattern.getY(),\n (int) otherPattern.getX(),\n (int) otherPattern.getY());\n float moduleSizeEst2 = sizeOfBlackWhiteBlackRunBothWays((int) otherPattern.getX(),\n (int) otherPattern.getY(),\n (int) pattern.getX(),\n (int) pattern.getY());\n if (Float.isNaN(moduleSizeEst1)) {\n return moduleSizeEst2 / 7.0f;\n }\n if (Float.isNaN(moduleSizeEst2)) {\n return moduleSizeEst1 / 7.0f;\n }\n // Average them, and divide by 7 since we've counted the width of 3 black modules,\n // and 1 white and 1 black module on either side. Ergo, divide sum by 14.\n return (moduleSizeEst1 + moduleSizeEst2) / 14.0f;\n }\n\n /**\n * See {@link #sizeOfBlackWhiteBlackRun(int, int, int, int)}; computes the total width of\n * a finder pattern by looking for a black-white-black run from the center in the direction\n * of another point (another finder pattern center), and in the opposite direction too.\n */\n private float sizeOfBlackWhiteBlackRunBothWays(int fromX, int fromY, int toX, int toY) {\n\n float result = sizeOfBlackWhiteBlackRun(fromX, fromY, toX, toY);\n\n // Now count other way -- don't run off image though of course\n float scale = 1.0f;\n int otherToX = fromX - (toX - fromX);\n if (otherToX < 0) {\n scale = fromX / (float) (fromX - otherToX);\n otherToX = 0;\n } else if (otherToX >= image.getWidth()) {\n scale = (image.getWidth() - 1 - fromX) / (float) (otherToX - fromX);\n otherToX = image.getWidth() - 1;\n }\n int otherToY = (int) (fromY - (toY - fromY) * scale);\n\n scale = 1.0f;\n if (otherToY < 0) {\n scale = fromY / (float) (fromY - otherToY);\n otherToY = 0;\n } else if (otherToY >= image.getHeight()) {\n scale = (image.getHeight() - 1 - fromY) / (float) (otherToY - fromY);\n otherToY = image.getHeight() - 1;\n }\n otherToX = (int) (fromX + (otherToX - fromX) * scale);\n\n result += sizeOfBlackWhiteBlackRun(fromX, fromY, otherToX, otherToY);\n\n // Middle pixel is double-counted this way; subtract 1\n return result - 1.0f;\n }\n\n /**\n *This method traces a line from a point in the image, in the direction towards another point.\n * It begins in a black region, and keeps going until it finds white, then black, then white again.\n * It reports the distance from the start to this point.
\n *\n *This is used when figuring out how wide a finder pattern is, when the finder pattern\n * may be skewed or rotated.
\n */\n private float sizeOfBlackWhiteBlackRun(int fromX, int fromY, int toX, int toY) {\n // Mild variant of Bresenham's algorithm;\n // see http://en.wikipedia.org/wiki/Bresenham's_line_algorithm\n boolean steep = Math.abs(toY - fromY) > Math.abs(toX - fromX);\n if (steep) {\n int temp = fromX;\n fromX = fromY;\n fromY = temp;\n temp = toX;\n toX = toY;\n toY = temp;\n }\n\n int dx = Math.abs(toX - fromX);\n int dy = Math.abs(toY - fromY);\n int error = -dx / 2;\n int xstep = fromX < toX ? 1 : -1;\n int ystep = fromY < toY ? 1 : -1;\n\n // In black pixels, looking for white, first or second time.\n int state = 0;\n // Loop up until x == toX, but not beyond\n int xLimit = toX + xstep;\n for (int x = fromX, y = fromY; x != xLimit; x += xstep) {\n int realX = steep ? y : x;\n int realY = steep ? x : y;\n\n // Does current pixel mean we have moved white to black or vice versa?\n // Scanning black in state 0,2 and white in state 1, so if we find the wrong\n // color, advance to next state or end if we are in state 2 already\n if ((state == 1) == image.get(realX, realY)) {\n if (state == 2) {\n return MathUtils.distance(x, y, fromX, fromY);\n }\n state++;\n }\n\n error += dy;\n if (error > 0) {\n if (y == toY) {\n break;\n }\n y += ystep;\n error -= dx;\n }\n }\n // Found black-white-black; give the benefit of the doubt that the next pixel outside the image\n // is \"white\" so this last point at (toX+xStep,toY) is the right ending. This is really a\n // small approximation; (toX+xStep,toY+yStep) might be really correct. Ignore this.\n if (state == 2) {\n return MathUtils.distance(toX + xstep, toY, fromX, fromY);\n }\n // else we didn't find even black-white-black; no estimate is really possible\n return Float.NaN;\n }\n\n /**\n *Attempts to locate an alignment pattern in a limited region of the image, which is\n * guessed to contain it. This method uses {@link AlignmentPattern}.
\n *\n * @param overallEstModuleSize estimated module size so far\n * @param estAlignmentX x coordinate of center of area probably containing alignment pattern\n * @param estAlignmentY y coordinate of above\n * @param allowanceFactor number of pixels in all directions to search from the center\n * @return {@link AlignmentPattern} if found, or null otherwise\n * @throws NotFoundException if an unexpected error occurs during detection\n */\n protected final AlignmentPattern findAlignmentInRegion(float overallEstModuleSize,\n int estAlignmentX,\n int estAlignmentY,\n float allowanceFactor)\n throws NotFoundException {\n // Look for an alignment pattern (3 modules in size) around where it\n // should be\n int allowance = (int) (allowanceFactor * overallEstModuleSize);\n int alignmentAreaLeftX = Math.max(0, estAlignmentX - allowance);\n int alignmentAreaRightX = Math.min(image.getWidth() - 1, estAlignmentX + allowance);\n if (alignmentAreaRightX - alignmentAreaLeftX < overallEstModuleSize * 3) {\n throw NotFoundException.getNotFoundInstance();\n }\n\n int alignmentAreaTopY = Math.max(0, estAlignmentY - allowance);\n int alignmentAreaBottomY = Math.min(image.getHeight() - 1, estAlignmentY + allowance);\n if (alignmentAreaBottomY - alignmentAreaTopY < overallEstModuleSize * 3) {\n throw NotFoundException.getNotFoundInstance();\n }\n\n AlignmentPatternFinder alignmentFinder =\n new AlignmentPatternFinder(\n image,\n alignmentAreaLeftX,\n alignmentAreaTopY,\n alignmentAreaRightX - alignmentAreaLeftX,\n alignmentAreaBottomY - alignmentAreaTopY,\n overallEstModuleSize,\n resultPointCallback);\n return alignmentFinder.find();\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/detector/FinderPattern.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.detector;\n\nimport com.google.zxing.ResultPoint;\n\n/**\n *Encapsulates a finder pattern, which are the three square patterns found in\n * the corners of QR Codes. It also encapsulates a count of similar finder patterns,\n * as a convenience to the finder's bookkeeping.
\n *\n * @author Sean Owen\n */\npublic final class FinderPattern extends ResultPoint {\n\n private final float estimatedModuleSize;\n private final int count;\n\n FinderPattern(float posX, float posY, float estimatedModuleSize) {\n this(posX, posY, estimatedModuleSize, 1);\n }\n\n private FinderPattern(float posX, float posY, float estimatedModuleSize, int count) {\n super(posX, posY);\n this.estimatedModuleSize = estimatedModuleSize;\n this.count = count;\n }\n\n public float getEstimatedModuleSize() {\n return estimatedModuleSize;\n }\n\n int getCount() {\n return count;\n }\n\n /*\n void incrementCount() {\n this.count++;\n }\n */\n\n /**\n *Determines if this finder pattern \"about equals\" a finder pattern at the stated\n * position and size -- meaning, it is at nearly the same center with nearly the same size.
\n */\n boolean aboutEquals(float moduleSize, float i, float j) {\n if (Math.abs(i - getY()) <= moduleSize && Math.abs(j - getX()) <= moduleSize) {\n float moduleSizeDiff = Math.abs(moduleSize - estimatedModuleSize);\n return moduleSizeDiff <= 1.0f || moduleSizeDiff <= estimatedModuleSize;\n }\n return false;\n }\n\n /**\n * Combines this object's current estimate of a finder pattern position and module size\n * with a new estimate. It returns a new {@code FinderPattern} containing a weighted average\n * based on count.\n */\n FinderPattern combineEstimate(float i, float j, float newModuleSize) {\n int combinedCount = count + 1;\n float combinedX = (count * getX() + j) / combinedCount;\n float combinedY = (count * getY() + i) / combinedCount;\n float combinedModuleSize = (count * estimatedModuleSize + newModuleSize) / combinedCount;\n return new FinderPattern(combinedX, combinedY, combinedModuleSize, combinedCount);\n }\n\n}\n" }, { "path": "scanner/src/main/java/com/google/zxing/qrcode/detector/FinderPatternFinder.java", "content": "/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.google.zxing.qrcode.detector;\n\nimport com.google.zxing.DecodeHintType;\nimport com.google.zxing.NotFoundException;\nimport com.google.zxing.ResultPoint;\nimport com.google.zxing.ResultPointCallback;\nimport com.google.zxing.common.BitMatrix;\n\nimport java.io.Serializable;\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.Comparator;\nimport java.util.List;\nimport java.util.Map;\n\n/**\n *This class attempts to find finder patterns in a QR Code. Finder patterns are the square\n * markers at three corners of a QR Code.
\n *\n *This class is thread-safe but not reentrant. Each thread must allocate its own object.\n *\n * @author Sean Owen\n */\npublic class FinderPatternFinder {\n\n private static final int CENTER_QUORUM = 2;\n protected static final int MIN_SKIP = 3; // 1 pixel/module times 3 modules/center\n protected static final int MAX_MODULES = 97; // support up to version 20 for mobile clients\n\n private final BitMatrix image;\n private final List Creates a finder that will search the image for three finder patterns. After a horizontal scan finds a potential finder pattern, this method\n * \"cross-checks\" by scanning down vertically through the center of the possible\n * finder pattern to see if the same proportion is detected. Like {@link #crossCheckVertical(int, int, int, int)}, and in fact is basically identical,\n * except it reads horizontally instead of vertically. This is used to cross-cross\n * check a vertical cross check and locate the real center of the alignment pattern. This is called when a horizontal scan finds a possible alignment pattern. It will\n * cross check with a vertical scan, and if successful, will, ah, cross-cross-check\n * with another horizontal scan. This is needed primarily to locate the real horizontal\n * center of the pattern in cases of extreme skew.\n * And then we cross-cross-cross check with another diagonal scan. If that succeeds the finder pattern location is added to a list that tracks\n * the number of times each location has been nearly-matched as a finder pattern.\n * Each additional find is more evidence that the location is in fact a finder\n * pattern center\n *\n * @param stateCount reading state module counts from horizontal scan\n * @param i row where finder pattern may be found\n * @param j end of possible finder pattern in row\n * @return true if a finder pattern candidate was found this time\n */\n protected final boolean handlePossibleCenter(int[] stateCount, int i, int j) {\n int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] +\n stateCount[4];\n float centerJ = centerFromEnd(stateCount, j);\n float centerI = crossCheckVertical(i, (int) centerJ, stateCount[2], stateCountTotal);\n if (!Float.isNaN(centerI)) {\n // Re-cross check\n centerJ = crossCheckHorizontal((int) centerJ, (int) centerI, stateCount[2], stateCountTotal);\n if (!Float.isNaN(centerJ) && crossCheckDiagonal((int) centerI, (int) centerJ)) {\n float estimatedModuleSize = stateCountTotal / 7.0f;\n boolean found = false;\n for (int index = 0; index < possibleCenters.size(); index++) {\n FinderPattern center = possibleCenters.get(index);\n // Look for about the same center and module size:\n if (center.aboutEquals(estimatedModuleSize, centerI, centerJ)) {\n possibleCenters.set(index, center.combineEstimate(centerI, centerJ, estimatedModuleSize));\n found = true;\n break;\n }\n }\n if (!found) {\n FinderPattern point = new FinderPattern(centerJ, centerI, estimatedModuleSize);\n possibleCenters.add(point);\n if (resultPointCallback != null) {\n resultPointCallback.foundPossibleResultPoint(point);\n }\n }\n return true;\n }\n }\n return false;\n }\n\n /**\n * @return number of rows we could safely skip during scanning, based on the first\n * two finder patterns that have been located. In some cases their position will\n * allow us to infer that the third pattern must lie below a certain point farther\n * down in the image.\n */\n private int findRowSkip() {\n int max = possibleCenters.size();\n if (max <= 1) {\n return 0;\n }\n ResultPoint firstConfirmedCenter = null;\n for (FinderPattern center : possibleCenters) {\n if (center.getCount() >= CENTER_QUORUM) {\n if (firstConfirmedCenter == null) {\n firstConfirmedCenter = center;\n } else {\n // We have two confirmed centers\n // How far down can we skip before resuming looking for the next\n // pattern? In the worst case, only the difference between the\n // difference in the x / y coordinates of the two centers.\n // This is the case where you find top left last.\n hasSkipped = true;\n return (int) (Math.abs(firstConfirmedCenter.getX() - center.getX()) -\n Math.abs(firstConfirmedCenter.getY() - center.getY())) / 2;\n }\n }\n }\n return 0;\n }\n\n /**\n * @return true iff we have found at least 3 finder patterns that have been detected\n * at least {@link #CENTER_QUORUM} times each, and, the estimated module size of the\n * candidates is \"pretty similar\"\n */\n private boolean haveMultiplyConfirmedCenters() {\n int confirmedCount = 0;\n float totalModuleSize = 0.0f;\n int max = possibleCenters.size();\n for (FinderPattern pattern : possibleCenters) {\n if (pattern.getCount() >= CENTER_QUORUM) {\n confirmedCount++;\n totalModuleSize += pattern.getEstimatedModuleSize();\n }\n }\n if (confirmedCount < 3) {\n return false;\n }\n // OK, we have at least 3 confirmed centers, but, it's possible that one is a \"false positive\"\n // and that we need to keep looking. We detect this by asking if the estimated module sizes\n // vary too much. We arbitrarily say that when the total deviation from average exceeds\n // 5% of the total module size estimates, it's too much.\n float average = totalModuleSize / max;\n float totalDeviation = 0.0f;\n for (FinderPattern pattern : possibleCenters) {\n totalDeviation += Math.abs(pattern.getEstimatedModuleSize() - average);\n }\n return totalDeviation <= 0.05f * totalModuleSize;\n }\n\n /**\n * @return the 3 best {@link FinderPattern}s from our list of candidates. The \"best\" are\n * those that have been detected at least {@link #CENTER_QUORUM} times, and whose module\n * size differs from the average among those patterns the least\n * @throws NotFoundException if 3 such finder patterns do not exist\n */\n private FinderPattern[] selectBestPatterns() throws NotFoundException {\n\n int startSize = possibleCenters.size();\n if (startSize < 3) {\n // Couldn't find enough finder patterns\n throw NotFoundException.getNotFoundInstance();\n }\n\n // Filter outlier possibilities whose module size is too different\n if (startSize > 3) {\n // But we can only afford to do so if we have at least 4 possibilities to choose from\n double totalModuleSize = 0.0;\n double square = 0.0;\n for (FinderPattern center : possibleCenters) {\n float size = center.getEstimatedModuleSize();\n totalModuleSize += size;\n square += size * size;\n }\n double average = totalModuleSize / startSize;\n float stdDev = (float) Math.sqrt(square / startSize - average * average);\n\n Collections.sort(possibleCenters, new FurthestFromAverageComparator((float) average));\n\n float limit = Math.max(0.2f * (float) average, stdDev);\n\n for (int i = 0; i < possibleCenters.size() && possibleCenters.size() > 3; i++) {\n FinderPattern pattern = possibleCenters.get(i);\n if (Math.abs(pattern.getEstimatedModuleSize() - average) > limit) {\n possibleCenters.remove(i);\n i--;\n }\n }\n }\n\n if (possibleCenters.size() > 3) {\n // Throw away all but those first size candidate points we found.\n\n float totalModuleSize = 0.0f;\n for (FinderPattern possibleCenter : possibleCenters) {\n totalModuleSize += possibleCenter.getEstimatedModuleSize();\n }\n\n float average = totalModuleSize / possibleCenters.size();\n\n Collections.sort(possibleCenters, new CenterComparator(average));\n\n possibleCenters.subList(3, possibleCenters.size()).clear();\n }\n\n return new FinderPattern[]{\n possibleCenters.get(0),\n possibleCenters.get(1),\n possibleCenters.get(2)\n };\n }\n\n /**\n * Orders by furthest from average Orders by {@link FinderPattern#getCount()}, descending. Encapsulates information about finder patterns in an image, including the location of\n * the three finder patterns, and their estimated module size.\n * author: Blankj\n * blog : http://blankj.com\n * time : 2017/12/29\n * desc : constants of permission\n *
\n */\n@SuppressLint(\"InlinedApi\")\npublic final class PermissionConstants {\n\n public static final String CALENDAR = Manifest.permission_group.CALENDAR;\n public static final String CAMERA = Manifest.permission_group.CAMERA;\n public static final String CONTACTS = Manifest.permission_group.CONTACTS;\n public static final String LOCATION = Manifest.permission_group.LOCATION;\n public static final String MICROPHONE = Manifest.permission_group.MICROPHONE;\n public static final String PHONE = Manifest.permission_group.PHONE;\n public static final String SENSORS = Manifest.permission_group.SENSORS;\n public static final String SMS = Manifest.permission_group.SMS;\n public static final String STORAGE = Manifest.permission_group.STORAGE;\n\n private static final String[] GROUP_CALENDAR = {\n permission.READ_CALENDAR, permission.WRITE_CALENDAR\n };\n private static final String[] GROUP_CAMERA = {\n permission.CAMERA\n };\n private static final String[] GROUP_CONTACTS = {\n permission.READ_CONTACTS, permission.WRITE_CONTACTS, permission.GET_ACCOUNTS\n };\n private static final String[] GROUP_LOCATION = {\n permission.ACCESS_FINE_LOCATION, permission.ACCESS_COARSE_LOCATION\n };\n private static final String[] GROUP_MICROPHONE = {\n permission.RECORD_AUDIO\n };\n private static final String[] GROUP_PHONE = {\n permission.READ_PHONE_STATE, permission.CALL_PHONE\n , permission.READ_CALL_LOG, permission.WRITE_CALL_LOG,\n permission.ADD_VOICEMAIL, permission.USE_SIP, permission.PROCESS_OUTGOING_CALLS\n };\n private static final String[] GROUP_SENSORS = {\n permission.BODY_SENSORS\n };\n private static final String[] GROUP_SMS = {\n permission.SEND_SMS, permission.RECEIVE_SMS, permission.READ_SMS,\n permission.RECEIVE_WAP_PUSH, permission.RECEIVE_MMS,\n };\n private static final String[] GROUP_STORAGE = {\n permission.READ_EXTERNAL_STORAGE, permission.WRITE_EXTERNAL_STORAGE\n };\n\n @StringDef({CALENDAR, CAMERA, CONTACTS, LOCATION, MICROPHONE, PHONE, SENSORS, SMS, STORAGE,})\n @Retention(RetentionPolicy.SOURCE)\n public @interface Permission {\n }\n\n public static String[] getPermissions(@Permission final String permission) {\n switch (permission) {\n case CALENDAR:\n return GROUP_CALENDAR;\n case CAMERA:\n return GROUP_CAMERA;\n case CONTACTS:\n return GROUP_CONTACTS;\n case LOCATION:\n return GROUP_LOCATION;\n case MICROPHONE:\n return GROUP_MICROPHONE;\n case PHONE:\n return GROUP_PHONE;\n case SENSORS:\n return GROUP_SENSORS;\n case SMS:\n return GROUP_SMS;\n case STORAGE:\n return GROUP_STORAGE;\n }\n return new String[]{permission};\n }\n}\n"
},
{
"path": "scanner/src/main/java/com/nanchen/scanner/utils/PermissionUtils.java",
"content": "package com.nanchen.scanner.utils;\n\nimport android.app.Activity;\nimport android.content.Context;\nimport android.content.Intent;\nimport android.content.pm.PackageManager;\nimport android.graphics.Color;\nimport android.net.Uri;\nimport android.os.Build;\nimport android.os.Bundle;\nimport android.support.annotation.NonNull;\nimport android.support.annotation.Nullable;\nimport android.support.annotation.RequiresApi;\nimport android.support.v4.content.ContextCompat;\nimport android.util.Log;\nimport android.view.MotionEvent;\nimport android.view.WindowManager;\n\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.LinkedHashSet;\nimport java.util.List;\nimport java.util.Set;\n\n\n/**\n * \n * author: Blankj\n * blog : http://blankj.com\n * time : 2017/12/29\n * desc : utils about permission\n *
\n */\npublic final class PermissionUtils {\n\n private static List
{@code false}: no\n */\n public static boolean isGranted(final String... permissions) {\n for (String permission : permissions) {\n if (!isGranted(permission)) {\n return false;\n }\n }\n return true;\n }\n\n private static boolean isGranted(final String permission) {\n return Build.VERSION.SDK_INT < Build.VERSION_CODES.M\n || PackageManager.PERMISSION_GRANTED\n == ContextCompat.checkSelfPermission(mApp, permission);\n }\n\n /**\n * Launch the application's details settings.\n */\n public static void launchAppDetailsSettings() {\n Intent intent = new Intent(\"android.settings.APPLICATION_DETAILS_SETTINGS\");\n intent.setData(Uri.parse(\"package:\" + mApp.getPackageName()));\n mApp.startActivity(intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));\n }\n\n /**\n * Set the permissions.\n *\n * @param permissions The permissions.\n * @return the single {@link PermissionUtils} instance\n */\n public static PermissionUtils permission(Context mContext, @PermissionConstants.Permission final String...\n permissions\n ) {\n mApp = mContext;\n PERMISSIONS = getPermissions();\n return new PermissionUtils(permissions);\n }\n\n private PermissionUtils(final String... permissions) {\n mPermissions = new LinkedHashSet<>();\n for (String permission : permissions) {\n for (String aPermission : PermissionConstants.getPermissions(permission)) {\n if (PERMISSIONS.contains(aPermission)) {\n mPermissions.add(aPermission);\n }\n }\n }\n sInstance = this;\n }\n\n /**\n * Set rationale listener.\n *\n * @param listener The rationale listener.\n * @return the single {@link PermissionUtils} instance\n */\n public PermissionUtils rationale(final OnRationaleListener listener) {\n mOnRationaleListener = listener;\n return this;\n }\n\n /**\n * Set the simple call back.\n *\n * @param callback the simple call back\n * @return the single {@link PermissionUtils} instance\n */\n public PermissionUtils callback(final SimpleCallback callback) {\n mSimpleCallback = callback;\n return this;\n }\n\n /**\n * Set the full call back.\n *\n * @param callback the full call back\n * @return the single {@link PermissionUtils} instance\n */\n public PermissionUtils callback(final FullCallback callback) {\n mFullCallback = callback;\n return this;\n }\n\n /**\n * Set the theme callback.\n *\n * @param callback The theme callback.\n * @return the single {@link PermissionUtils} instance\n */\n public PermissionUtils theme(final ThemeCallback callback) {\n mThemeCallback = callback;\n return this;\n }\n\n /**\n * Start request.\n */\n public void request() {\n mPermissionsGranted = new ArrayList<>();\n mPermissionsRequest = new ArrayList<>();\n if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {\n mPermissionsGranted.addAll(mPermissions);\n requestCallback();\n } else {\n for (String permission : mPermissions) {\n if (isGranted(permission)) {\n mPermissionsGranted.add(permission);\n } else {\n mPermissionsRequest.add(permission);\n }\n }\n if (mPermissionsRequest.isEmpty()) {\n requestCallback();\n } else {\n startPermissionActivity();\n }\n }\n }\n\n @RequiresApi(api = Build.VERSION_CODES.M)\n private void startPermissionActivity() {\n mPermissionsDenied = new ArrayList<>();\n mPermissionsDeniedForever = new ArrayList<>();\n PermissionActivity.start(mApp);\n }\n\n @RequiresApi(api = Build.VERSION_CODES.M)\n private boolean rationale(final Activity activity) {\n boolean isRationale = false;\n if (mOnRationaleListener != null) {\n for (String permission : mPermissionsRequest) {\n if (activity.shouldShowRequestPermissionRationale(permission)) {\n getPermissionsStatus(activity);\n mOnRationaleListener.rationale(new OnRationaleListener.ShouldRequest() {\n @Override\n public void again(boolean again) {\n if (again) {\n startPermissionActivity();\n } else {\n requestCallback();\n }\n }\n });\n isRationale = true;\n break;\n }\n }\n mOnRationaleListener = null;\n }\n return isRationale;\n }\n\n private void getPermissionsStatus(final Activity activity) {\n for (String permission : mPermissionsRequest) {\n if (isGranted(permission)) {\n mPermissionsGranted.add(permission);\n } else {\n mPermissionsDenied.add(permission);\n if (!activity.shouldShowRequestPermissionRationale(permission)) {\n mPermissionsDeniedForever.add(permission);\n }\n }\n }\n }\n\n private void requestCallback() {\n if (mSimpleCallback != null) {\n if (mPermissionsRequest.size() == 0\n || mPermissions.size() == mPermissionsGranted.size()) {\n mSimpleCallback.onGranted();\n } else {\n if (!mPermissionsDenied.isEmpty()) {\n mSimpleCallback.onDenied();\n }\n }\n mSimpleCallback = null;\n }\n if (mFullCallback != null) {\n if (mPermissionsRequest.size() == 0\n || mPermissions.size() == mPermissionsGranted.size()) {\n mFullCallback.onGranted(mPermissionsGranted);\n } else {\n if (!mPermissionsDenied.isEmpty()) {\n mFullCallback.onDenied(mPermissionsDeniedForever, mPermissionsDenied);\n }\n }\n mFullCallback = null;\n }\n mOnRationaleListener = null;\n mThemeCallback = null;\n }\n\n private void onRequestPermissionsResult(final Activity activity) {\n getPermissionsStatus(activity);\n requestCallback();\n }\n\n\n @RequiresApi(api = Build.VERSION_CODES.M)\n public static class PermissionActivity extends Activity {\n\n public static void start(final Context context) {\n Intent starter = new Intent(context, PermissionActivity.class);\n starter.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);\n context.startActivity(starter);\n }\n\n @Override\n protected void onCreate(@Nullable Bundle savedInstanceState) {\n getWindow().addFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE\n | WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH);\n getWindow().setStatusBarColor(Color.TRANSPARENT);\n if (sInstance == null) {\n super.onCreate(savedInstanceState);\n Log.e(\"PermissionUtils\", \"request permissions failed\");\n finish();\n return;\n }\n if (sInstance.mThemeCallback != null) {\n sInstance.mThemeCallback.onActivityCreate(this);\n }\n super.onCreate(savedInstanceState);\n\n if (sInstance.rationale(this)) {\n finish();\n return;\n }\n if (sInstance.mPermissionsRequest != null) {\n int size = sInstance.mPermissionsRequest.size();\n if (size <= 0) {\n finish();\n return;\n }\n requestPermissions(sInstance.mPermissionsRequest.toArray(new String[size]), 1);\n }\n }\n\n @Override\n public void onRequestPermissionsResult(int requestCode,\n @NonNull String[] permissions,\n @NonNull int[] grantResults) {\n sInstance.onRequestPermissionsResult(this);\n finish();\n }\n\n @Override\n public boolean dispatchTouchEvent(MotionEvent ev) {\n finish();\n return true;\n }\n }\n\n ///////////////////////////////////////////////////////////////////////////\n // interface\n ///////////////////////////////////////////////////////////////////////////\n\n public interface OnRationaleListener {\n\n void rationale(ShouldRequest shouldRequest);\n\n interface ShouldRequest {\n void again(boolean again);\n }\n }\n\n public interface SimpleCallback {\n void onGranted();\n\n void onDenied();\n }\n\n public interface FullCallback {\n void onGranted(List
{@code false}: no\n */\n public static boolean isFullScreen(@NonNull final Activity activity) {\n int fullScreenFlag = WindowManager.LayoutParams.FLAG_FULLSCREEN;\n return (activity.getWindow().getAttributes().flags & fullScreenFlag) == fullScreenFlag;\n }\n\n /**\n * Set the screen to landscape.\n *\n * @param activity The activity.\n */\n public static void setLandscape(@NonNull final Activity activity) {\n activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);\n }\n\n /**\n * Set the screen to portrait.\n *\n * @param activity The activity.\n */\n public static void setPortrait(@NonNull final Activity activity) {\n activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);\n }\n\n /**\n * Return whether screen is landscape.\n *\n * @return {@code true}: yes
{@code false}: no\n */\n public static boolean isLandscape(Context context) {\n return context.getResources().getConfiguration().orientation\n == Configuration.ORIENTATION_LANDSCAPE;\n }\n\n /**\n * Return whether screen is portrait.\n *\n * @return {@code true}: yes
{@code false}: no\n */\n public static boolean isPortrait(Context context) {\n return context.getResources().getConfiguration().orientation\n == Configuration.ORIENTATION_PORTRAIT;\n }\n\n /**\n * Return the rotation of screen.\n *\n * @param activity The activity.\n * @return the rotation of screen\n */\n public static int getScreenRotation(@NonNull final Activity activity) {\n switch (activity.getWindowManager().getDefaultDisplay().getRotation()) {\n case Surface.ROTATION_0:\n return 0;\n case Surface.ROTATION_90:\n return 90;\n case Surface.ROTATION_180:\n return 180;\n case Surface.ROTATION_270:\n return 270;\n default:\n return 0;\n }\n }\n\n /**\n * Return the bitmap of screen.\n *\n * @param activity The activity.\n * @return the bitmap of screen\n */\n public static Bitmap screenShot(@NonNull final Activity activity) {\n return screenShot(activity, false);\n }\n\n /**\n * Return the bitmap of screen.\n *\n * @param activity The activity.\n * @param isDeleteStatusBar True to delete status bar, false otherwise.\n * @return the bitmap of screen\n */\n public static Bitmap screenShot(@NonNull final Activity activity, boolean isDeleteStatusBar) {\n View decorView = activity.getWindow().getDecorView();\n decorView.setDrawingCacheEnabled(true);\n decorView.setWillNotCacheDrawing(false);\n Bitmap bmp = decorView.getDrawingCache();\n if (bmp == null) return null;\n DisplayMetrics dm = new DisplayMetrics();\n activity.getWindowManager().getDefaultDisplay().getMetrics(dm);\n Bitmap ret;\n if (isDeleteStatusBar) {\n Resources resources = activity.getResources();\n int resourceId = resources.getIdentifier(\"status_bar_height\", \"dimen\", \"android\");\n int statusBarHeight = resources.getDimensionPixelSize(resourceId);\n ret = Bitmap.createBitmap(\n bmp,\n 0,\n statusBarHeight,\n dm.widthPixels,\n dm.heightPixels - statusBarHeight\n );\n } else {\n ret = Bitmap.createBitmap(bmp, 0, 0, dm.widthPixels, dm.heightPixels);\n }\n decorView.destroyDrawingCache();\n return ret;\n }\n\n /**\n * Return whether screen is locked.\n *\n * @return {@code true}: yes
{@code false}: no\n */\n public static boolean isScreenLock(Context context) {\n KeyguardManager km =\n (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);\n //noinspection ConstantConditions\n return km.inKeyguardRestrictedInputMode();\n }\n\n\n /**\n * Return the duration of sleep.\n *\n * @return the duration of sleep.\n */\n public static int getSleepDuration(Context context) {\n try {\n return Settings.System.getInt(\n context.getContentResolver(),\n Settings.System.SCREEN_OFF_TIMEOUT\n );\n } catch (Settings.SettingNotFoundException e) {\n e.printStackTrace();\n return -123;\n }\n }\n\n /**\n * Return whether device is tablet.\n *\n * @return {@code true}: yes
{@code false}: no\n */\n public static boolean isTablet(Context context) {\n return (context.getResources().getConfiguration().screenLayout\n & Configuration.SCREENLAYOUT_SIZE_MASK)\n >= Configuration.SCREENLAYOUT_SIZE_LARGE;\n }\n}\n"
},
{
"path": "scanner/src/main/java/com/nanchen/scanner/zxing/AmbientLightManager.java",
"content": "/*\n * Copyright (C) 2012 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.nanchen.scanner.zxing;\n\nimport android.content.Context;\nimport android.content.SharedPreferences;\nimport android.hardware.Sensor;\nimport android.hardware.SensorEvent;\nimport android.hardware.SensorEventListener;\nimport android.hardware.SensorManager;\nimport android.preference.PreferenceManager;\n\nimport com.nanchen.scanner.zxing.camera.CameraManager;\nimport com.nanchen.scanner.zxing.camera.FrontLightMode;\n\n/**\n * Detects ambient light and switches on the front light when very dark, and off again when sufficiently light.\n *\n * @author Sean Owen\n * @author Nikolaus Huber\n */\nfinal class AmbientLightManager implements SensorEventListener {\n\n private static final float TOO_DARK_LUX = 45.0f;\n private static final float BRIGHT_ENOUGH_LUX = 450.0f;\n\n private final Context context;\n private CameraManager cameraManager;\n private Sensor lightSensor;\n\n AmbientLightManager(Context context) {\n this.context = context;\n }\n\n void start(CameraManager cameraManager) {\n this.cameraManager = cameraManager;\n SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(context);\n if (FrontLightMode.readPref(sharedPrefs) == FrontLightMode.AUTO) {\n SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);\n lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);\n if (lightSensor != null) {\n sensorManager.registerListener(this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL);\n }\n }\n }\n\n void stop() {\n if (lightSensor != null) {\n SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);\n sensorManager.unregisterListener(this);\n cameraManager = null;\n lightSensor = null;\n }\n }\n\n @Override\n public void onSensorChanged(SensorEvent sensorEvent) {\n float ambientLightLux = sensorEvent.values[0];\n if (cameraManager != null) {\n if (ambientLightLux <= TOO_DARK_LUX) {\n cameraManager.setTorch(true);\n } else if (ambientLightLux >= BRIGHT_ENOUGH_LUX) {\n cameraManager.setTorch(false);\n }\n }\n }\n\n @Override\n public void onAccuracyChanged(Sensor sensor, int accuracy) {\n // do nothing\n }\n\n}\n"
},
{
"path": "scanner/src/main/java/com/nanchen/scanner/zxing/BaseCaptureActivity.java",
"content": "/*\n * Copyright (C) 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.nanchen.scanner.zxing;\n\nimport com.nanchen.scanner.zxing.camera.CameraManager;\n\nimport android.app.Activity;\nimport android.graphics.Bitmap;\nimport android.os.Handler;\nimport android.view.SurfaceHolder;\n\n/**\n * This activity opens the camera and does the actual scanning on a background thread. It draws a\n * viewfinder to help the user place the barcode correctly, shows feedback as the image processing\n * is happening, and then overlays the results when a scan is successful.\n *\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Sean Owen\n */\npublic abstract class BaseCaptureActivity extends Activity implements SurfaceHolder.Callback {\n\n public abstract ViewfinderView getViewfinderView();\n\n public abstract Handler getHandler();\n\n public abstract CameraManager getCameraManager();\n\n public abstract void handleDecode(String result, Bitmap barcode, float scaleFactor);\n\n public abstract void drawViewfinder();\n}\n"
},
{
"path": "scanner/src/main/java/com/nanchen/scanner/zxing/BeepManager.java",
"content": "/*\n * Copyright (C) 2010 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.nanchen.scanner.zxing;\n\nimport android.annotation.TargetApi;\nimport android.app.Activity;\nimport android.content.Context;\nimport android.content.SharedPreferences;\nimport android.content.res.AssetFileDescriptor;\nimport android.media.AudioManager;\nimport android.media.MediaPlayer;\nimport android.os.Build;\nimport android.os.Vibrator;\nimport android.preference.PreferenceManager;\nimport android.util.Log;\n\nimport com.nanchen.scanner.R;\n\nimport java.io.Closeable;\nimport java.io.IOException;\n\n/**\n * Manages beeps and vibrations for {@link BaseCaptureActivity}.\n */\npublic final class BeepManager implements MediaPlayer.OnErrorListener, Closeable {\n\n private static final String TAG = BeepManager.class.getSimpleName();\n\n private static final float BEEP_VOLUME = 0.10f;\n private static final long VIBRATE_DURATION = 200L;\n\n private final Activity activity;\n private MediaPlayer mediaPlayer;\n private boolean playBeep;\n private boolean vibrate;\n\n public BeepManager(Activity activity) {\n this.activity = activity;\n this.mediaPlayer = null;\n updatePrefs();\n }\n\n public synchronized void updatePrefs() {\n SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);\n playBeep = shouldBeep(prefs, activity);\n // vibrate = prefs.getBoolean(PreferencesActivity.KEY_VIBRATE, false);\n vibrate = true;\n if (playBeep && mediaPlayer == null) {\n // The volume on STREAM_SYSTEM is not adjustable, and users found it too loud,\n // so we now play on the music stream.\n activity.setVolumeControlStream(AudioManager.STREAM_MUSIC);\n mediaPlayer = buildMediaPlayer(activity);\n }\n }\n\n public synchronized void playBeepSoundAndVibrate() {\n if (playBeep && mediaPlayer != null) {\n mediaPlayer.start();\n }\n if (vibrate) {\n Vibrator vibrator = (Vibrator) activity.getSystemService(Context.VIBRATOR_SERVICE);\n vibrator.vibrate(VIBRATE_DURATION);\n }\n }\n\n private static boolean shouldBeep(SharedPreferences prefs, Context activity) {\n// boolean shouldPlayBeep = prefs.getBoolean(PreferencesActivity.KEY_PLAY_BEEP, true);\n // 直接true\n boolean shouldPlayBeep = true;\n if (shouldPlayBeep) {\n // See if sound settings overrides this\n AudioManager audioService = (AudioManager) activity.getSystemService(Context.AUDIO_SERVICE);\n if (audioService.getRingerMode() != AudioManager.RINGER_MODE_NORMAL) {\n shouldPlayBeep = false;\n }\n }\n return shouldPlayBeep;\n }\n\n @TargetApi(Build.VERSION_CODES.KITKAT)\n private MediaPlayer buildMediaPlayer(Context activity) {\n MediaPlayer mediaPlayer = new MediaPlayer();\n try (AssetFileDescriptor file = activity.getResources().openRawResourceFd(R.raw.beep)) {\n mediaPlayer.setDataSource(file.getFileDescriptor(), file.getStartOffset(), file.getLength());\n mediaPlayer.setOnErrorListener(this);\n mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);\n mediaPlayer.setLooping(false);\n mediaPlayer.setVolume(BEEP_VOLUME, BEEP_VOLUME);\n mediaPlayer.prepare();\n return mediaPlayer;\n } catch (IOException ioe) {\n Log.w(TAG, ioe);\n mediaPlayer.release();\n return null;\n }\n }\n\n @Override\n public synchronized boolean onError(MediaPlayer mp, int what, int extra) {\n if (what == MediaPlayer.MEDIA_ERROR_SERVER_DIED) {\n // we are finished, so put up an appropriate error toast if required and finish\n activity.finish();\n } else {\n // possibly media player error, so release and recreate\n close();\n updatePrefs();\n }\n return true;\n }\n\n @Override\n public synchronized void close() {\n if (mediaPlayer != null) {\n mediaPlayer.release();\n mediaPlayer = null;\n }\n }\n\n}\n"
},
{
"path": "scanner/src/main/java/com/nanchen/scanner/zxing/CaptureActivityHandler.java",
"content": "/*\n * Copyright (C) 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.nanchen.scanner.zxing;\n\nimport android.content.ActivityNotFoundException;\nimport android.content.pm.PackageManager;\nimport android.content.pm.ResolveInfo;\nimport android.graphics.BitmapFactory;\nimport android.provider.Browser;\n\nimport com.google.zxing.BarcodeFormat;\nimport com.google.zxing.DecodeHintType;\nimport com.nanchen.scanner.R;\nimport com.nanchen.scanner.zxing.camera.CameraManager;\n\nimport android.app.Activity;\nimport android.content.Intent;\nimport android.graphics.Bitmap;\nimport android.net.Uri;\nimport android.os.Bundle;\nimport android.os.Handler;\nimport android.os.Message;\nimport android.util.Log;\n\n\n/**\n * This class handles all the messaging which comprises the state machine for capture.\n *\n * @author dswitkin@google.com (Daniel Switkin)\n */\npublic final class CaptureActivityHandler extends Handler {\n\n private static final String TAG = CaptureActivityHandler.class.getSimpleName();\n\n private final BaseCaptureActivity activity;\n private final DecodeThread decodeThread;\n private State state;\n private final CameraManager cameraManager;\n\n private enum State {\n PREVIEW,\n SUCCESS,\n DONE\n }\n\n public CaptureActivityHandler(BaseCaptureActivity activity,\n CameraManager cameraManager) {\n this.activity = activity;\n decodeThread = new DecodeThread(activity);\n decodeThread.start();\n state = State.SUCCESS;\n\n // Start ourselves capturing previews and decoding.\n this.cameraManager = cameraManager;\n cameraManager.startPreview();\n restartPreviewAndDecode();\n }\n\n @Override\n public void handleMessage(Message message) {\n if (message.what == R.id.restart_preview) {\n restartPreviewAndDecode();\n } else if (message.what == R.id.decode_succeeded) {\n state = State.SUCCESS;\n Bundle bundle = message.getData();\n Bitmap barcode = null;\n float scaleFactor = 1.0f;\n if (bundle != null) {\n byte[] compressedBitmap = bundle.getByteArray(DecodeThread.BARCODE_BITMAP);\n if (compressedBitmap != null) {\n barcode = BitmapFactory.decodeByteArray(compressedBitmap, 0, compressedBitmap.length, null);\n // Mutable copy:\n barcode = barcode.copy(Bitmap.Config.ARGB_8888, true);\n }\n scaleFactor = bundle.getFloat(DecodeThread.BARCODE_SCALED_FACTOR);\n }\n activity.handleDecode((String) message.obj, barcode, scaleFactor);\n\n } else if (message.what == R.id.decode_failed) {// We're decoding as fast as possible, so when one decode fails, start another.\n state = State.PREVIEW;\n cameraManager.requestPreviewFrame(decodeThread.getHandler(), R.id.decode);\n } else if (message.what == R.id.return_scan_result) {\n activity.setResult(Activity.RESULT_OK, (Intent) message.obj);\n activity.finish();\n\n } else if (message.what == R.id.launch_product_query) {\n String url = (String) message.obj;\n\n Intent intent = new Intent(Intent.ACTION_VIEW);\n intent.addFlags(Intents.FLAG_NEW_DOC);\n intent.setData(Uri.parse(url));\n\n ResolveInfo resolveInfo =\n activity.getPackageManager().resolveActivity(intent, PackageManager.MATCH_DEFAULT_ONLY);\n String browserPackageName = null;\n if (resolveInfo != null && resolveInfo.activityInfo != null) {\n browserPackageName = resolveInfo.activityInfo.packageName;\n Log.d(TAG, \"Using browser in package \" + browserPackageName);\n }\n\n // Needed for default Android browser / Chrome only apparently\n if (browserPackageName != null) {\n switch (browserPackageName) {\n case \"com.android.browser\":\n case \"com.android.chrome\":\n intent.setPackage(browserPackageName);\n intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);\n intent.putExtra(Browser.EXTRA_APPLICATION_ID, browserPackageName);\n break;\n }\n }\n\n try {\n activity.startActivity(intent);\n } catch (ActivityNotFoundException ignored) {\n Log.w(TAG, \"Can't find anything to handle VIEW of URI\");\n }\n\n }\n }\n\n public void quitSynchronously() {\n state = State.DONE;\n cameraManager.stopPreview();\n Message quit = Message.obtain(decodeThread.getHandler(), R.id.quit);\n quit.sendToTarget();\n try {\n // Wait at most half a second; should be enough time, and onPause() will timeout quickly\n decodeThread.join(500L);\n } catch (InterruptedException e) {\n // continue\n }\n\n // Be absolutely sure we don't send any queued up messages\n removeMessages(R.id.decode_succeeded);\n removeMessages(R.id.decode_failed);\n }\n\n private void restartPreviewAndDecode() {\n if (state == State.SUCCESS) {\n state = State.PREVIEW;\n cameraManager.requestPreviewFrame(decodeThread.getHandler(), R.id.decode);\n activity.drawViewfinder();\n }\n }\n\n}\n"
},
{
"path": "scanner/src/main/java/com/nanchen/scanner/zxing/Contents.java",
"content": "/*\n * Copyright (C) 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.nanchen.scanner.zxing;\n\nimport android.provider.ContactsContract;\n\n/**\n * The set of constants to use when sending Barcode Scanner an Intent which requests a barcode\n * to be encoded.\n *\n * @author dswitkin@google.com (Daniel Switkin)\n */\npublic final class Contents {\n private Contents() {\n }\n\n /**\n * Contains type constants used when sending Intents.\n */\n public static final class Type {\n /**\n * Plain text. Use Intent.putExtra(DATA, string). This can be used for URLs too, but string\n * must include \"http://\" or \"https://\".\n */\n public static final String TEXT = \"TEXT_TYPE\";\n\n /**\n * An email type. Use Intent.putExtra(DATA, string) where string is the email address.\n */\n public static final String EMAIL = \"EMAIL_TYPE\";\n\n /**\n * Use Intent.putExtra(DATA, string) where string is the phone number to call.\n */\n public static final String PHONE = \"PHONE_TYPE\";\n\n /**\n * An SMS type. Use Intent.putExtra(DATA, string) where string is the number to SMS.\n */\n public static final String SMS = \"SMS_TYPE\";\n\n /**\n * A contact. Send a request to encode it as follows:\n * {@code\n * import android.provider.Contacts;\n *\n * Intent intent = new Intent(Intents.Encode.ACTION);\n * intent.putExtra(Intents.Encode.TYPE, CONTACT);\n * Bundle bundle = new Bundle();\n * bundle.putString(ContactsContract.Intents.Insert.NAME, \"Jenny\");\n * bundle.putString(ContactsContract.Intents.Insert.PHONE, \"8675309\");\n * bundle.putString(ContactsContract.Intents.Insert.EMAIL, \"jenny@the80s.com\");\n * bundle.putString(ContactsContract.Intents.Insert.POSTAL, \"123 Fake St. San Francisco, CA 94102\");\n * intent.putExtra(Intents.Encode.DATA, bundle);\n * }\n */\n public static final String CONTACT = \"CONTACT_TYPE\";\n\n /**\n * A geographic location. Use as follows:\n * Bundle bundle = new Bundle();\n * bundle.putFloat(\"LAT\", latitude);\n * bundle.putFloat(\"LONG\", longitude);\n * intent.putExtra(Intents.Encode.DATA, bundle);\n */\n public static final String LOCATION = \"LOCATION_TYPE\";\n\n private Type() {\n }\n }\n\n public static final String URL_KEY = \"URL_KEY\";\n\n public static final String NOTE_KEY = \"NOTE_KEY\";\n\n /**\n * When using Type.CONTACT, these arrays provide the keys for adding or retrieving multiple\n * phone numbers and addresses.\n */\n public static final String[] PHONE_KEYS = {\n ContactsContract.Intents.Insert.PHONE,\n ContactsContract.Intents.Insert.SECONDARY_PHONE,\n ContactsContract.Intents.Insert.TERTIARY_PHONE\n };\n\n public static final String[] PHONE_TYPE_KEYS = {\n ContactsContract.Intents.Insert.PHONE_TYPE,\n ContactsContract.Intents.Insert.SECONDARY_PHONE_TYPE,\n ContactsContract.Intents.Insert.TERTIARY_PHONE_TYPE\n };\n\n public static final String[] EMAIL_KEYS = {\n ContactsContract.Intents.Insert.EMAIL,\n ContactsContract.Intents.Insert.SECONDARY_EMAIL,\n ContactsContract.Intents.Insert.TERTIARY_EMAIL\n };\n\n public static final String[] EMAIL_TYPE_KEYS = {\n ContactsContract.Intents.Insert.EMAIL_TYPE,\n ContactsContract.Intents.Insert.SECONDARY_EMAIL_TYPE,\n ContactsContract.Intents.Insert.TERTIARY_EMAIL_TYPE\n };\n\n}\n"
},
{
"path": "scanner/src/main/java/com/nanchen/scanner/zxing/DecodeFormatManager.java",
"content": "/*\n * Copyright (C) 2010 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.nanchen.scanner.zxing;\n\nimport android.content.Intent;\nimport android.net.Uri;\nimport android.util.ArraySet;\n\nimport com.google.zxing.BarcodeFormat;\n\nimport java.util.Arrays;\nimport java.util.EnumSet;\nimport java.util.HashMap;\nimport java.util.List;\nimport java.util.Map;\nimport java.util.Set;\nimport java.util.regex.Pattern;\n\npublic final class DecodeFormatManager {\n\n private static final Pattern COMMA_PATTERN = Pattern.compile(\",\");\n\n static final Set