+ * Input data should include a 8-digit Deliver Point ID + * (DPID) optionally followed by customer information as shown below. + *
Input Length |
+ * Required Input Format |
+ * Symbol Length |
+ * FCC |
+ * Encoding Table |
+ *
|---|---|---|---|---|
8 |
+ * 99999999 |
+ * 37-bar |
+ * 11 |
+ * None |
+ *
13 |
+ * 99999999AAAAA |
+ * 52-bar |
+ * 59 |
+ * C |
+ *
16 |
+ * 9999999999999999 |
+ * 52-bar |
+ * 59 |
+ * N |
+ *
18 |
+ * 99999999AAAAAAAAAA |
+ * 67-bar |
+ * 62 |
+ * C |
+ *
23 |
+ * 99999999999999999999999 |
+ * 67-bar |
+ * 62 |
+ * N |
+ *
+ * Input |
+ * + * Symbol Size |
+ * + * Input |
+ * + * Symbol Size |
+ *
|---|---|---|---|
+ * 1 |
+ * + * 15 x 15* |
+ * + * 19 |
+ * + * 79 x 79 |
+ *
+ * 2 |
+ * + * 19 x 19* |
+ * + * 20 |
+ * + * 83 x 83 |
+ *
+ * 3 |
+ * + * 23 x 23* |
+ * + * 21 |
+ * + * 87 x 87 |
+ *
+ * 4 |
+ * + * 27 x 27* |
+ * + * 22 |
+ * + * 91 x 91 |
+ *
+ * 5 |
+ * + * 19 x 19 |
+ * + * 23 |
+ * + * 95 x 95 |
+ *
+ * 6 |
+ * + * 23 x 23 |
+ * + * 24 |
+ * + * 101 x 101 |
+ *
+ * 7 |
+ * + * 27 x 27 |
+ * + * 25 |
+ * + * 105 x 105 |
+ *
+ * 8 |
+ * + * 31 x 31 |
+ * + * 26 |
+ * + * 109 x 109 |
+ *
+ * 9 |
+ * + * 37 x 37 |
+ * + * 27 |
+ * + * 113 x 113 |
+ *
+ * 10 |
+ * + * 41 x 41 |
+ * + * 28 |
+ * + * 117 x 117 |
+ *
+ * 11 |
+ * + * 45 x 45 |
+ * + * 29 |
+ * + * 121 x 121 |
+ *
+ * 12 |
+ * + * 49 x 49 |
+ * + * 30 |
+ * + * 125 x 125 |
+ *
+ * 13 |
+ * + * 53 x 53 |
+ * + * 31 |
+ * + * 131 x 131 |
+ *
+ * 14 |
+ * + * 57 x 57 |
+ * + * 32 |
+ * + * 135 x 135 |
+ *
+ * 15 |
+ * + * 61 x 61 |
+ * + * 33 |
+ * + * 139 x 139 |
+ *
+ * 16 |
+ * + * 67 x 67 |
+ * + * 34 |
+ * + * 143 x 143 |
+ *
+ * 17 |
+ * + * 71 x 71 |
+ * + * 35 |
+ * + * 147 x 147 |
+ *
+ * 18 |
+ * + * 75 x 75 |
+ * + * 36 |
+ * + * 151 x 151 |
+ *
setPreferredSize Valid options are:
+ * + * Mode |
+ * + * Error Correction Capacity |
+ *
|---|---|
+ * 1 |
+ * + * >10% + 3 codewords |
+ *
+ * 2 |
+ * + * >23% + 3 codewords |
+ *
+ * 3 |
+ * + * >36% + 3 codewords |
+ *
+ * 4 |
+ * + * >50% + 3 codewords |
+ *
null).
+ *
+ * @param startDelimiter an optional start delimiter to be shown in the human-readable text
+ */
+ public void setStartDelimiter(Character startDelimiter) {
+ this.startDelimiter = startDelimiter;
+ }
+
+ /**
+ * Returns the optional stop delimiter to be shown in the human-readable text.
+ *
+ * @return the optional stop delimiter to be shown in the human-readable text
+ */
+ public Character getStopDelimiter() {
+ return stopDelimiter;
+ }
+
+ /**
+ * Sets an optional stop delimiter to be shown in the human-readable text (defaults to null).
+ *
+ * @param stopDelimiter an optional stop delimiter to be shown in the human-readable text
+ */
+ public void setStopDelimiter(Character stopDelimiter) {
+ this.stopDelimiter = stopDelimiter;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean encode() {
+
+ if (!(content.matches("[0-9-]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ StringBuilder horizontalSpacing = new StringBuilder("112211");
+ String humanReadable = content;
+ int length = content.length();
+ int[] weight = new int[length + 1];
+
+ for (int i = 0; i < length; i++) {
+ char c = content.charAt(i);
+ weight[i] = positionOf(c, CHARACTER_SET);
+ horizontalSpacing.append(CODE_11_TABLE[weight[i]]);
+ }
+
+ int checkDigitC = getCheckDigitC(weight, length);
+ horizontalSpacing.append(CODE_11_TABLE[checkDigitC]);
+ humanReadable += CHARACTER_SET[checkDigitC];
+ encodeInfo.append("Check Digit C: ").append(checkDigitC).append("\n");
+
+ if (checkDigitCount == 2) {
+ weight[length] = checkDigitC;
+ int checkDigitK = getCheckDigitK(weight, length + 1);
+ horizontalSpacing.append(CODE_11_TABLE[checkDigitK]);
+ humanReadable += CHARACTER_SET[checkDigitK];
+ encodeInfo.append("Check Digit K: ").append(checkDigitK).append("\n");
+ }
+
+ horizontalSpacing.append("112211");
+
+ readable = new StringBuilder(humanReadable);
+ if (startDelimiter != null) {
+ readable = new StringBuilder(startDelimiter).append(readable);
+ }
+ if (stopDelimiter != null) {
+ readable.append(stopDelimiter);
+ }
+
+ pattern = new String[]{horizontalSpacing.toString()};
+ rowCount = 1;
+ rowHeight = new int[]{-1};
+
+ plotSymbol();
+
+ return true;
+ }
+
+ @Override
+ protected double getModuleWidth(int originalWidth) {
+ if (originalWidth == 1) {
+ return 1;
+ } else {
+ return moduleWidthRatio;
+ }
+ }
+
+ @Override
+ protected int[] getCodewords() {
+ return getPatternAsCodewords(6);
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/Code128.java b/barcode/src/main/java/org/xbib/graphics/barcode/Code128.java
new file mode 100755
index 0000000..3272c45
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/Code128.java
@@ -0,0 +1,843 @@
+package org.xbib.graphics.barcode;
+
+import java.io.UnsupportedEncodingException;
+
+/**
+ * Implements Code 128 bar code symbology according to ISO/IEC 15417:2007.
+ * Code 128 supports encoding of 8-bit ISO 8859-1 (Latin-1) characters.
+ * Setting GS1 mode allows encoding in GS1-128 (also known as UPC/EAN-128).
+ */
+public class Code128 extends Symbol {
+ private String[] code128Table = {
+ "212222", "222122", "222221", "121223", "121322", "131222", "122213",
+ "122312", "132212", "221213", "221312", "231212", "112232", "122132",
+ "122231", "113222", "123122", "123221", "223211", "221132", "221231",
+ "213212", "223112", "312131", "311222", "321122", "321221", "312212",
+ "322112", "322211", "212123", "212321", "232121", "111323", "131123",
+ "131321", "112313", "132113", "132311", "211313", "231113", "231311",
+ "112133", "112331", "132131", "113123", "113321", "133121", "313121",
+ "211331", "231131", "213113", "213311", "213131", "311123", "311321",
+ "331121", "312113", "312311", "332111", "314111", "221411", "431111",
+ "111224", "111422", "121124", "121421", "141122", "141221", "112214",
+ "112412", "122114", "122411", "142112", "142211", "241211", "221114",
+ "413111", "241112", "134111", "111242", "121142", "121241", "114212",
+ "124112", "124211", "411212", "421112", "421211", "212141", "214121",
+ "412121", "111143", "111341", "131141", "114113", "114311", "411113",
+ "411311", "113141", "114131", "311141", "411131", "211412", "211214",
+ "211232", "2331112"
+ };
+ private Mode[] mode_type = new Mode[200];
+ private int[] mode_length = new int[200];
+ private int index_point = 0, read = 0;
+ private boolean modeCSupression;
+ private Composite compositeMode;
+
+ public Code128() {
+ modeCSupression = false;
+ compositeMode = Composite.OFF;
+ }
+
+ /**
+ * Allow the use of subset C (numeric compression) in encoding (default).
+ */
+ public void useModeC() {
+ modeCSupression = false;
+ }
+
+ ;
+
+ /**
+ * Disallow the use of subset C (numeric compression) in encoding.
+ * Numeric values will be encoded using subset B.
+ */
+ public void stopModeC() {
+ modeCSupression = true;
+ }
+
+ protected void setCca() {
+ compositeMode = Composite.CCA;
+ }
+
+ protected void setCcb() {
+ compositeMode = Composite.CCB;
+ }
+
+ protected void setCcc() {
+ compositeMode = Composite.CCC;
+ }
+
+ public void unsetCc() {
+ compositeMode = Composite.OFF;
+ }
+
+ @Override
+ public boolean encode() {
+ int sourcelen = content.length();
+ int i, j, k;
+ int input_point = 0;
+ Mode mode, last_mode;
+ Mode last_set, current_set;
+ double glyph_count;
+ int bar_characters = 0, total_sum = 0;
+ FMode f_state = FMode.LATCHN;
+ int[] values = new int[200];
+ int c;
+ StringBuilder dest = new StringBuilder();
+ int[] inputData;
+ int c_count;
+ int linkage_flag = 0;
+
+ if (!content.matches("[\u0000-\u00FF]+")) {
+ errorMsg.append("Invalid characters in input data");
+ return false;
+ }
+
+ try {
+ inputBytes = content.getBytes("ISO8859_1");
+ } catch (UnsupportedEncodingException e) {
+ errorMsg.append("Character encoding error");
+ return false;
+ }
+
+ inputData = new int[sourcelen];
+ for (i = 0; i < sourcelen; i++) {
+ inputData[i] = inputBytes[i] & 0xFF;
+ }
+
+ FMode[] fset = new FMode[200];
+ Mode[] set = new Mode[200]; /* set[] = Calculated mode for each character */
+
+ if (sourcelen > 170) {
+ errorMsg.append("Input data too long");
+ return false;
+ }
+
+ /* Detect extended ASCII characters */
+ for (i = 0; i < sourcelen; i++) {
+ if (inputData[i] >= 128) {
+ fset[i] = FMode.SHIFTF;
+ } else {
+ fset[i] = FMode.LATCHN;
+ }
+ }
+
+ /* Decide when to latch to extended mode - Annex E note 3 */
+ j = 0;
+ for (i = 0; i < sourcelen; i++) {
+ if (fset[i] == FMode.SHIFTF) {
+ j++;
+ } else {
+ j = 0;
+ }
+
+ if (j >= 5) {
+ for (k = i; k > (i - 5); k--) {
+ fset[k] = FMode.LATCHF;
+ }
+ }
+
+ if ((j >= 3) && (i == (sourcelen - 1))) {
+ for (k = i; k > (i - 3); k--) {
+ fset[k] = FMode.LATCHF;
+ }
+ }
+ }
+
+ /* Decide if it is worth reverting to 646 encodation for a few characters as described in 4.3.4.2 (d) */
+ for (i = 1; i < sourcelen; i++) {
+ if ((fset[i - 1] == FMode.LATCHF) && (fset[i] == FMode.LATCHN)) {
+ /* Detected a change from 8859-1 to 646 - count how long for */
+ for (j = 0; (fset[i + j] == FMode.LATCHN) && ((i + j) < sourcelen); j++) ;
+ if ((j < 5) || ((j < 3) && ((i + j) == (sourcelen - 1)))) {
+ /* Uses the same figures recommended by Annex E note 3 */
+ /* Change to shifting back rather than latching back */
+ for (k = 0; k < j; k++) {
+ fset[i + k] = FMode.SHIFTN;
+ }
+ }
+ }
+ }
+
+ /* Decide on mode using same system as PDF417 and rules of ISO 15417 Annex E */
+ mode = findSubset(inputData[input_point]);
+ mode_type[0] = mode;
+ mode_length[0] = 1;
+
+ if (inputDataType == DataType.GS1) {
+ mode = Mode.ABORC;
+ }
+
+ if ((modeCSupression) && (mode == Mode.ABORC)) {
+ mode = Mode.AORB;
+ }
+
+ for (i = 1; i < sourcelen; i++) {
+ last_mode = mode;
+ mode = findSubset(inputData[i]);
+ if ((inputDataType == DataType.GS1) && inputData[i] == '[') {
+ mode = Mode.ABORC;
+ }
+ if ((modeCSupression) && (mode == Mode.ABORC)) {
+ mode = Mode.AORB;
+ }
+ if (mode == last_mode) {
+ mode_length[index_point]++;
+ } else {
+ index_point++;
+ mode_type[index_point] = mode;
+ mode_length[index_point] = 1;
+ }
+ }
+ index_point++;
+
+ reduceSubsetChanges();
+
+
+ if (inputDataType == DataType.GS1) {
+ /* Put set data into set[] */
+ read = 0;
+ for (i = 0; i < index_point; i++) {
+ for (j = 0; j < mode_length[i]; j++) {
+ set[read] = mode_type[i];
+ read++;
+ }
+ }
+
+ /* Resolve odd length LATCHC blocks */
+ c_count = 0;
+ for (i = 0; i < read; i++) {
+ if (set[i] == Mode.LATCHC) {
+ if (inputData[i] == '[') {
+ if ((c_count & 1) != 0) {
+ if ((i - c_count) != 0) {
+ set[i - c_count] = Mode.LATCHB;
+ } else {
+ set[i - 1] = Mode.LATCHB;
+ }
+ }
+ c_count = 0;
+ } else {
+ c_count++;
+ }
+ } else {
+ if ((c_count & 1) != 0) {
+ if ((i - c_count) != 0) {
+ set[i - c_count] = Mode.LATCHB;
+ } else {
+ set[i - 1] = Mode.LATCHB;
+ }
+ }
+ c_count = 0;
+ }
+ }
+ if ((c_count & 1) != 0) {
+ if ((i - c_count) != 0) {
+ set[i - c_count] = Mode.LATCHB;
+ } else {
+ set[i - 1] = Mode.LATCHB;
+ }
+ }
+ for (i = 1; i < read - 1; i++) {
+ if ((set[i] == Mode.LATCHC) && ((set[i - 1] == Mode.LATCHB)
+ && (set[i + 1] == Mode.LATCHB))) {
+ set[i] = Mode.LATCHB;
+ }
+ }
+ } else {
+ /* Resolve odd length LATCHC blocks */
+
+ if ((mode_type[0] == Mode.LATCHC) && ((mode_length[0] & 1) != 0)) {
+ /* Rule 2 */
+ mode_length[1]++;
+ mode_length[0]--;
+ if (index_point == 1) {
+ mode_length[1] = 1;
+ mode_type[1] = Mode.LATCHB;
+ index_point = 2;
+ }
+ }
+ if (index_point > 1) {
+ for (i = 1; i < index_point; i++) {
+ if ((mode_type[i] == Mode.LATCHC) && ((mode_length[i] & 1) != 0)) {
+ /* Rule 3b */
+ mode_length[i - 1]++;
+ mode_length[i]--;
+ }
+ }
+ }
+
+ /* Put set data into set[] */
+ for (i = 0; i < index_point; i++) {
+ for (j = 0; j < mode_length[i]; j++) {
+ set[read] = mode_type[i];
+ read++;
+ }
+ }
+ }
+
+ /* Adjust for strings which start with shift characters - make them latch instead */
+ if (set[0] == Mode.SHIFTA) {
+ i = 0;
+ do {
+ set[i] = Mode.LATCHA;
+ i++;
+ } while (set[i] == Mode.SHIFTA);
+ }
+
+ if (set[0] == Mode.SHIFTB) {
+ i = 0;
+ do {
+ set[i] = Mode.LATCHB;
+ i++;
+ } while (set[i] == Mode.SHIFTB);
+ }
+
+ /* Now we can calculate how long the barcode is going to be - and stop it from
+ being too long */
+ last_set = Mode.NULL;
+ glyph_count = 0.0;
+ for (i = 0; i < sourcelen; i++) {
+ if ((set[i] == Mode.SHIFTA) || (set[i] == Mode.SHIFTB)) {
+ glyph_count += 1.0;
+ }
+ if ((fset[i] == FMode.SHIFTF) || (fset[i] == FMode.SHIFTN)) {
+ glyph_count += 1.0;
+ }
+ if (((set[i] == Mode.LATCHA) || (set[i] == Mode.LATCHB)) || (set[i] == Mode.LATCHC)) {
+ if (set[i] != last_set) {
+ last_set = set[i];
+ glyph_count += 1.0;
+ }
+ }
+ if (i == 0) {
+ if (fset[i] == FMode.LATCHF) {
+ glyph_count += 2.0;
+ }
+ } else {
+ if ((fset[i] == FMode.LATCHF) && (fset[i - 1] != FMode.LATCHF)) {
+ glyph_count += 2.0;
+ }
+ if ((fset[i] != FMode.LATCHF) && (fset[i - 1] == FMode.LATCHF)) {
+ glyph_count += 2.0;
+ }
+ }
+
+ if (set[i] == Mode.LATCHC) {
+ if ((inputDataType == DataType.GS1) && (inputData[i] == '[')) {
+ glyph_count += 1.0;
+ } else {
+ glyph_count += 0.5;
+ }
+ } else {
+ glyph_count += 1.0;
+ }
+ }
+ if (glyph_count > 80.0) {
+ errorMsg.append("Input data too long");
+ return false;
+ }
+
+ encodeInfo.append("Encoding: ");
+
+ /* So now we know what start character to use - we can get on with it! */
+ if (readerInit) {
+ /* Reader Initialisation mode */
+ switch (set[0]) {
+ case LATCHA: /* Start A */
+ dest.append(code128Table[103]);
+ values[0] = 103;
+ current_set = Mode.LATCHA;
+ dest.append(code128Table[96]); /* FNC3 */
+ values[1] = 96;
+ bar_characters++;
+ encodeInfo.append("STARTA FNC3 ");
+ break;
+ case LATCHB: /* Start B */
+ dest.append(code128Table[104]);
+ values[0] = 104;
+ current_set = Mode.LATCHB;
+ dest.append(code128Table[96]); /* FNC3 */
+ values[1] = 96;
+ bar_characters++;
+ encodeInfo.append("STARTB FNC3 ");
+ break;
+ default: /* Start C */
+ dest.append(code128Table[104]); /* Start B */
+ values[0] = 105;
+ dest.append(code128Table[96]); /* FNC3 */
+ values[1] = 96;
+ dest.append(code128Table[99]); /* Code C */
+ values[2] = 99;
+ bar_characters += 2;
+ current_set = Mode.LATCHC;
+ encodeInfo.append("STARTB FNC3 CODEC ");
+ break;
+ }
+ } else {
+ /* Normal mode */
+ switch (set[0]) {
+ case LATCHA:
+ /* Start A */
+ dest.append(code128Table[103]);
+ values[0] = 103;
+ current_set = Mode.LATCHA;
+ encodeInfo.append("STARTA ");
+ break;
+ case LATCHB:
+ /* Start B */
+ dest.append(code128Table[104]);
+ values[0] = 104;
+ current_set = Mode.LATCHB;
+ encodeInfo.append("STARTB ");
+ break;
+ default:
+ /* Start C */
+ dest.append(code128Table[105]);
+ values[0] = 105;
+ current_set = Mode.LATCHC;
+ encodeInfo.append("STARTC ");
+ break;
+ }
+ }
+ bar_characters++;
+
+ if (inputDataType == DataType.GS1) {
+ dest.append(code128Table[102]);
+ values[1] = 102;
+ bar_characters++;
+ encodeInfo.append("FNC1 ");
+ }
+
+ if (fset[0] == FMode.LATCHF) {
+ switch (current_set) {
+ case LATCHA:
+ dest.append(code128Table[101]);
+ dest.append(code128Table[101]);
+ values[bar_characters] = 101;
+ values[bar_characters + 1] = 101;
+ encodeInfo.append("FNC4 FNC4 ");
+ break;
+ case LATCHB:
+ dest.append(code128Table[100]);
+ dest.append(code128Table[100]);
+ values[bar_characters] = 100;
+ values[bar_characters + 1] = 100;
+ encodeInfo.append("FNC4 FNC4 ");
+ break;
+ }
+ bar_characters += 2;
+ f_state = FMode.LATCHF;
+ }
+
+ /* Encode the data */
+ read = 0;
+ do {
+
+ if ((read != 0) && (set[read] != current_set)) { /* Latch different code set */
+ switch (set[read]) {
+ case LATCHA:
+ dest.append(code128Table[101]);
+ values[bar_characters] = 101;
+ bar_characters++;
+ current_set = Mode.LATCHA;
+ encodeInfo.append("CODEA ");
+ break;
+ case LATCHB:
+ dest.append(code128Table[100]);
+ values[bar_characters] = 100;
+ bar_characters++;
+ current_set = Mode.LATCHB;
+ encodeInfo.append("CODEB ");
+ break;
+ case LATCHC:
+ dest.append(code128Table[99]);
+ values[bar_characters] = 99;
+ bar_characters++;
+ current_set = Mode.LATCHC;
+ encodeInfo.append("CODEC ");
+ break;
+ }
+ }
+
+ if (read != 0) {
+ if ((fset[read] == FMode.LATCHF) && (f_state == FMode.LATCHN)) {
+ /* Latch beginning of extended mode */
+ switch (current_set) {
+ case LATCHA:
+ dest.append(code128Table[101]);
+ dest.append(code128Table[101]);
+ values[bar_characters] = 101;
+ values[bar_characters + 1] = 101;
+ encodeInfo.append("FNC4 FNC4 ");
+ break;
+ case LATCHB:
+ dest.append(code128Table[100]);
+ dest.append(code128Table[100]);
+ values[bar_characters] = 100;
+ values[bar_characters + 1] = 100;
+ encodeInfo.append("FNC4 FNC4 ");
+ break;
+ }
+ bar_characters += 2;
+ f_state = FMode.LATCHN;
+ }
+ if ((fset[read] == FMode.LATCHN) && (f_state == FMode.LATCHF)) {
+ /* Latch end of extended mode */
+ switch (current_set) {
+ case LATCHA:
+ dest.append(code128Table[101]);
+ dest.append(code128Table[101]);
+ values[bar_characters] = 101;
+ values[bar_characters + 1] = 101;
+ encodeInfo.append("FNC4 FNC4 ");
+ break;
+ case LATCHB:
+ dest.append(code128Table[100]);
+ dest.append(code128Table[100]);
+ values[bar_characters] = 100;
+ values[bar_characters + 1] = 100;
+ encodeInfo.append("FNC4 FNC4 ");
+ break;
+ }
+ bar_characters += 2;
+ f_state = FMode.LATCHN;
+ }
+ }
+
+ if ((fset[read] == FMode.SHIFTF) || (fset[read] == FMode.SHIFTN)) {
+ /* Shift to or from extended mode */
+ switch (current_set) {
+ case LATCHA:
+ dest.append(code128Table[101]); /* FNC 4 */
+ values[bar_characters] = 101;
+ encodeInfo.append("FNC4 ");
+ break;
+ case LATCHB:
+ dest.append(code128Table[100]); /* FNC 4 */
+ values[bar_characters] = 100;
+ encodeInfo.append("FNC4 ");
+ break;
+ }
+ bar_characters++;
+ }
+
+ if ((set[read] == Mode.SHIFTA) || (set[read] == Mode.SHIFTB)) {
+ /* Insert shift character */
+ dest.append(code128Table[98]);
+ values[bar_characters] = 98;
+ encodeInfo.append("SHFT ");
+ bar_characters++;
+ }
+
+ if (!((inputDataType == DataType.GS1) && (inputData[read] == '['))) {
+ /* Encode data characters */
+ c = inputData[read];
+ switch (set[read]) {
+ case SHIFTA:
+ case LATCHA:
+ if (c > 127) {
+ if (c < 160) {
+ dest.append(code128Table[(c - 128) + 64]);
+ values[bar_characters] = (c - 128) + 64;
+ } else {
+ dest.append(code128Table[(c - 128) - 32]);
+ values[bar_characters] = (c - 128) - 32;
+ }
+ } else {
+ if (c < 32) {
+ dest.append(code128Table[c + 64]);
+ values[bar_characters] = c + 64;
+ } else {
+ dest.append(code128Table[c - 32]);
+ values[bar_characters] = c - 32;
+ }
+ }
+ encodeInfo.append(Integer.toString(values[bar_characters])).append(" ");
+ bar_characters++;
+ read++;
+ break;
+ case SHIFTB:
+ case LATCHB:
+ if (c > 127) {
+ dest.append(code128Table[c - 32 - 128]);
+ values[bar_characters] = c - 32 - 128;
+ } else {
+ dest.append(code128Table[c - 32]);
+ values[bar_characters] = c - 32;
+ }
+ encodeInfo.append(Integer.toString(values[bar_characters])).append(" ");
+ bar_characters++;
+ read++;
+ break;
+ case LATCHC:
+ int weight;
+ int d = inputData[read + 1];
+
+ weight = (10 * (c - '0')) + (d - '0');
+ dest.append(code128Table[weight]);
+ values[bar_characters] = weight;
+ encodeInfo.append(Integer.toString(values[bar_characters])).append(" ");
+ bar_characters++;
+ read += 2;
+ break;
+ }
+ } else {
+ // FNC1
+ dest.append(code128Table[102]);
+ values[bar_characters] = 102;
+ bar_characters++;
+ read++;
+ encodeInfo.append("FNC1 ");
+ }
+
+ } while (read < sourcelen);
+
+ encodeInfo.append("\n");
+
+ /* "...note that the linkage flag is an extra code set character between
+ the last data character and the Symbol Check Character" (GS1 Specification) */
+
+ /* Linkage flags in GS1-128 are determined by ISO/IEC 24723 section 7.4 */
+
+ switch (compositeMode) {
+ case CCA:
+ case CCB:
+ /* CC-A or CC-B 2D component */
+ switch (set[sourcelen - 1]) {
+ case LATCHA:
+ linkage_flag = 100;
+ break;
+ case LATCHB:
+ linkage_flag = 99;
+ break;
+ case LATCHC:
+ linkage_flag = 101;
+ break;
+ }
+ encodeInfo.append("Linkage flag: ").append(linkage_flag).append('\n');
+ break;
+ case CCC:
+ /* CC-C 2D component */
+ switch (set[sourcelen - 1]) {
+ case LATCHA:
+ linkage_flag = 99;
+ break;
+ case LATCHB:
+ linkage_flag = 101;
+ break;
+ case LATCHC:
+ linkage_flag = 100;
+ break;
+ }
+ encodeInfo.append("Linkage flag: ").append(linkage_flag).append('\n');
+ break;
+ default:
+ break;
+ }
+
+ if (linkage_flag != 0) {
+ dest.append(code128Table[linkage_flag]);
+ values[bar_characters] = linkage_flag;
+ bar_characters++;
+ }
+
+ /* check digit calculation */
+ for (i = 0; i < bar_characters; i++) {
+ if (i > 0) {
+ values[i] *= i;
+ }
+ total_sum += values[i];
+ }
+ dest.append(code128Table[total_sum % 103]);
+ encodeInfo.append("Data Codewords: ").append(bar_characters).append('\n');
+ encodeInfo.append("Check Digit: ").append(total_sum % 103).append('\n');
+
+ /* Stop character */
+ dest.append(code128Table[106]);
+
+ if (!(inputDataType == DataType.GS1)) {
+ readable = new StringBuilder(content);
+ }
+
+ if (inputDataType == DataType.HIBC) {
+ readable.append("*").append(content).append("*");
+ }
+
+ if (compositeMode == Composite.OFF) {
+ pattern = new String[1];
+ pattern[0] = dest.toString();
+ rowCount = 1;
+ rowHeight = new int[1];
+ rowHeight[0] = -1;
+ } else {
+ /* Add the separator pattern for composite symbols */
+ pattern = new String[2];
+ pattern[0] = "0" + dest;
+ pattern[1] = dest.toString();
+ rowCount = 2;
+ rowHeight = new int[2];
+ rowHeight[0] = 1;
+ rowHeight[1] = -1;
+ }
+ plotSymbol();
+ return true;
+ }
+
+ private Mode findSubset(int letter) {
+ Mode mode;
+
+ if (letter <= 31) {
+ mode = Mode.SHIFTA;
+ } else if ((letter >= 48) && (letter <= 57)) {
+ mode = Mode.ABORC;
+ } else if (letter <= 95) {
+ mode = Mode.AORB;
+ } else if (letter <= 127) {
+ mode = Mode.SHIFTB;
+ } else if (letter <= 159) {
+ mode = Mode.SHIFTA;
+ } else if (letter <= 223) {
+ mode = Mode.AORB;
+ } else {
+ mode = Mode.SHIFTB;
+ }
+
+ return mode;
+ }
+
+ private void reduceSubsetChanges() { /* Implements rules from ISO 15417 Annex E */
+ int i, length;
+ Mode current, last, next;
+
+ for (i = 0; i < index_point; i++) {
+ current = mode_type[i];
+ length = mode_length[i];
+ if (i != 0) {
+ last = mode_type[i - 1];
+ } else {
+ last = Mode.NULL;
+ }
+ if (i != index_point - 1) {
+ next = mode_type[i + 1];
+ } else {
+ next = Mode.NULL;
+ }
+
+ if (i == 0) { /* first block */
+ if ((index_point == 1) && ((length == 2) && (current == Mode.ABORC))) { /* Rule 1a */
+ mode_type[i] = Mode.LATCHC;
+ }
+ if (current == Mode.ABORC) {
+ if (length >= 4) { /* Rule 1b */
+ mode_type[i] = Mode.LATCHC;
+ } else {
+ mode_type[i] = Mode.AORB;
+ current = Mode.AORB;
+ }
+ }
+ if (current == Mode.SHIFTA) { /* Rule 1c */
+ mode_type[i] = Mode.LATCHA;
+ }
+ if ((current == Mode.AORB) && (next == Mode.SHIFTA)) { /* Rule 1c */
+ mode_type[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if (current == Mode.AORB) { /* Rule 1d */
+ mode_type[i] = Mode.LATCHB;
+ }
+ } else {
+ if ((current == Mode.ABORC) && (length >= 4)) { /* Rule 3 */
+ mode_type[i] = Mode.LATCHC;
+ current = Mode.LATCHC;
+ }
+ if (current == Mode.ABORC) {
+ mode_type[i] = Mode.AORB;
+ current = Mode.AORB;
+ }
+ if ((current == Mode.AORB) && (last == Mode.LATCHA)) {
+ mode_type[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if ((current == Mode.AORB) && (last == Mode.LATCHB)) {
+ mode_type[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ if ((current == Mode.AORB) && (next == Mode.SHIFTA)) {
+ mode_type[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if ((current == Mode.AORB) && (next == Mode.SHIFTB)) {
+ mode_type[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ if (current == Mode.AORB) {
+ mode_type[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ if ((current == Mode.SHIFTA) && (length > 1)) { /* Rule 4 */
+ mode_type[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if ((current == Mode.SHIFTB) && (length > 1)) { /* Rule 5 */
+ mode_type[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ if ((current == Mode.SHIFTA) && (last == Mode.LATCHA)) {
+ mode_type[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if ((current == Mode.SHIFTB) && (last == Mode.LATCHB)) {
+ mode_type[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ if ((current == Mode.SHIFTA) && (last == Mode.LATCHC)) {
+ mode_type[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if ((current == Mode.SHIFTB) && (last == Mode.LATCHC)) {
+ mode_type[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ } /* Rule 2 is implemented elsewhere, Rule 6 is implied */
+ }
+
+ combineSubsetBlocks();
+
+ }
+
+ private void combineSubsetBlocks() {
+ int i, j;
+
+ /* bring together same type blocks */
+ if (index_point > 1) {
+ i = 1;
+ while (i < index_point) {
+ if (mode_type[i - 1] == mode_type[i]) {
+ /* bring together */
+ mode_length[i - 1] = mode_length[i - 1] + mode_length[i];
+ j = i + 1;
+
+ /* decreace the list */
+ while (j < index_point) {
+ mode_length[j - 1] = mode_length[j];
+ mode_type[j - 1] = mode_type[j];
+ j++;
+ }
+ index_point--;
+ i--;
+ }
+ i++;
+ }
+ }
+ }
+
+ private enum Mode {
+ NULL, SHIFTA, LATCHA, SHIFTB, LATCHB, SHIFTC, LATCHC, AORB, ABORC
+ }
+
+ private enum FMode {
+ SHIFTN, LATCHN, SHIFTF, LATCHF
+ }
+
+ private enum Composite {OFF, CCA, CCB, CCC}
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/Code16k.java b/barcode/src/main/java/org/xbib/graphics/barcode/Code16k.java
new file mode 100755
index 0000000..eb2ae61
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/Code16k.java
@@ -0,0 +1,769 @@
+package org.xbib.graphics.barcode;
+
+import java.awt.geom.Rectangle2D;
+import java.io.UnsupportedEncodingException;
+
+/**
+ * Implements Code 16K symbology
+ * According to BS EN 12323:2005
+ * Encodes using a stacked symbology based on Code 128. Supports encoding
+ * of any 8-bit ISO 8859-1 (Latin-1) data with a maximum data capacity of 77
+ * alpha-numeric characters or 154 numerical digits.
+ */
+public class Code16k extends Symbol {
+
+ /* EN 12323 Table 1 - "Code 16K" character encodations */
+ private static final String[] C_16_K_TABLE = {
+ "212222", "222122", "222221", "121223", "121322", "131222", "122213",
+ "122312", "132212", "221213", "221312", "231212", "112232", "122132",
+ "122231", "113222", "123122", "123221", "223211", "221132", "221231",
+ "213212", "223112", "312131", "311222", "321122", "321221", "312212",
+ "322112", "322211", "212123", "212321", "232121", "111323", "131123",
+ "131321", "112313", "132113", "132311", "211313", "231113", "231311",
+ "112133", "112331", "132131", "113123", "113321", "133121", "313121",
+ "211331", "231131", "213113", "213311", "213131", "311123", "311321",
+ "331121", "312113", "312311", "332111", "314111", "221411", "431111",
+ "111224", "111422", "121124", "121421", "141122", "141221", "112214",
+ "112412", "122114", "122411", "142112", "142211", "241211", "221114",
+ "413111", "241112", "134111", "111242", "121142", "121241", "114212",
+ "124112", "124211", "411212", "421112", "421211", "212141", "214121",
+ "412121", "111143", "111341", "131141", "114113", "114311", "411113",
+ "411311", "113141", "114131", "311141", "411131", "211412", "211214",
+ "211232", "211133"
+ };
+ /* EN 12323 Table 3 and Table 4 - Start patterns and stop patterns */
+ private static final String[] C_16_K_START_STOP = {
+ "3211", "2221", "2122", "1411", "1132", "1231", "1114", "3112"
+ };
+ /* EN 12323 Table 5 - Start and stop values defining row numbers */
+ private static final int[] C_16_K_START_VALUES = {
+ 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7
+ };
+ private static final int[] C_16_K_STOP_VALUES = {
+ 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, 7, 0, 1, 2, 3
+ };
+ private final Mode[] block_mode = new Mode[170]; /* RENAME block_mode */
+ private final int[] block_length = new int[170]; /* RENAME block_length */
+
+ @Override
+ public boolean encode() {
+ StringBuilder width_pattern;
+ int current_row, rows_needed, first_check, second_check;
+ int indexchaine, pads_needed;
+ char[] set, fset;
+ Mode mode;
+ char last_set, current_set;
+ int i, j, k, m, read;
+ int[] values;
+ int bar_characters;
+ double glyph_count;
+ int first_sum, second_sum;
+ int input_length;
+ int c_count;
+ boolean f_state;
+ int[] inputData;
+
+ if (!content.matches("[\u0000-\u00FF]+")) {
+ errorMsg.append("Invalid characters in input data");
+ return false;
+ }
+
+ try {
+ inputBytes = content.getBytes("ISO8859_1");
+ } catch (UnsupportedEncodingException e) {
+ errorMsg.append("Character encoding error");
+ return false;
+ }
+
+ input_length = content.length();
+ inputData = new int[input_length];
+ for (i = 0; i < input_length; i++) {
+ inputData[i] = inputBytes[i] & 0xFF;
+ }
+
+ bar_characters = 0;
+ set = new char[160];
+ fset = new char[160];
+ values = new int[160];
+
+ if (input_length > 157) {
+ errorMsg.append("Input too long");
+ return false;
+ }
+
+ /* Detect extended ASCII characters */
+ for (i = 0; i < input_length; i++) {
+ if (inputData[i] >= 128) {
+ fset[i] = 'f';
+ } else {
+ fset[i] = ' ';
+ }
+ }
+
+ /* Decide when to latch to extended mode */
+ for (i = 0; i < input_length; i++) {
+ j = 0;
+ if (fset[i] == 'f') {
+ do {
+ j++;
+ } while (fset[i + j] == 'f');
+ if ((j >= 5) || ((j >= 3) && ((i + j) == (input_length - 1)))) {
+ for (k = 0; k <= j; k++) {
+ fset[i + k] = 'F';
+ }
+ }
+ }
+ }
+
+ /* Decide if it is worth reverting to 646 encodation for a few characters */
+ if (input_length > 1) {
+ for (i = 1; i < input_length; i++) {
+ if ((fset[i - 1] == 'F') && (fset[i] == ' ')) {
+ /* Detected a change from 8859-1 to 646 - count how long for */
+ for (j = 0; (fset[i + j] == ' ') && ((i + j) < input_length); j++)
+ ;
+ if (j < 5) {
+ /* Change to shifting back rather than latching back */
+ for (k = 0; k < j; k++) {
+ fset[i + k] = 'n';
+ }
+ }
+ }
+ }
+ }
+
+ /* Detect mode A, B and C characters */
+ int block_count = 0;
+ indexchaine = 0;
+
+ mode = findSubset(inputData[indexchaine]);
+ if ((inputDataType == DataType.GS1) && (inputData[indexchaine] == '[')) {
+ mode = Mode.ABORC;
+ } /* FNC1 */
+
+ for (i = 0; i < 160; i++) {
+ block_length[i] = 0;
+ }
+
+ do {
+ block_mode[block_count] = mode;
+ while ((block_mode[block_count] == mode) && (indexchaine < input_length)) {
+ block_length[block_count]++;
+ indexchaine++;
+ if (indexchaine < input_length) {
+ mode = findSubset(inputData[indexchaine]);
+ if ((inputDataType == DataType.GS1) && (inputData[indexchaine] == '[')) {
+ mode = Mode.ABORC;
+ } /* FNC1 */
+ }
+ }
+ block_count++;
+ } while (indexchaine < input_length);
+
+ reduceSubsetChanges(block_count);
+
+
+ /* Put set data into set[] */
+ read = 0;
+ for (i = 0; i < block_count; i++) {
+ for (j = 0; j < block_length[i]; j++) {
+ switch (block_mode[i]) {
+ case SHIFTA:
+ set[read] = 'a';
+ break;
+ case LATCHA:
+ set[read] = 'A';
+ break;
+ case SHIFTB:
+ set[read] = 'b';
+ break;
+ case LATCHB:
+ set[read] = 'B';
+ break;
+ case LATCHC:
+ set[read] = 'C';
+ break;
+ }
+ read++;
+ }
+ }
+
+ /* Adjust for strings which start with shift characters - make them latch instead */
+ if (set[0] == 'a') {
+ i = 0;
+ do {
+ set[i] = 'A';
+ i++;
+ } while (set[i] == 'a');
+ }
+
+ if (set[0] == 'b') {
+ i = 0;
+ do {
+ set[i] = 'B';
+ i++;
+ } while (set[i] == 'b');
+ }
+
+ /* Watch out for odd-length Mode C blocks */
+ c_count = 0;
+ for (i = 0; i < read; i++) {
+ if (set[i] == 'C') {
+ if (inputData[i] == '[') {
+ if ((c_count & 1) != 0) {
+ if ((i - c_count) != 0) {
+ set[i - c_count] = 'B';
+ } else {
+ set[i - 1] = 'B';
+ }
+ }
+ c_count = 0;
+ } else {
+ c_count++;
+ }
+ } else {
+ if ((c_count & 1) != 0) {
+ if ((i - c_count) != 0) {
+ set[i - c_count] = 'B';
+ } else {
+ set[i - 1] = 'B';
+ }
+ }
+ c_count = 0;
+ }
+ }
+ if ((c_count & 1) != 0) {
+ if ((i - c_count) != 0) {
+ set[i - c_count] = 'B';
+ } else {
+ set[i - 1] = 'B';
+ }
+ }
+ for (i = 1; i < read - 1; i++) {
+ if ((set[i] == 'C') && ((set[i - 1] == 'B') && (set[i + 1] == 'B'))) {
+ set[i] = 'B';
+ }
+ }
+
+ /* Make sure the data will fit in the symbol */
+ last_set = ' ';
+ glyph_count = 0.0;
+ for (i = 0; i < input_length; i++) {
+ if ((set[i] == 'a') || (set[i] == 'b')) {
+ glyph_count = glyph_count + 1.0;
+ }
+ if ((fset[i] == 'f') || (fset[i] == 'n')) {
+ glyph_count = glyph_count + 1.0;
+ }
+ if (((set[i] == 'A') || (set[i] == 'B')) || (set[i] == 'C')) {
+ if (set[i] != last_set) {
+ last_set = set[i];
+ glyph_count = glyph_count + 1.0;
+ }
+ }
+ if (i == 0) {
+ if ((set[i] == 'B') && (set[1] == 'C')) {
+ glyph_count = glyph_count - 1.0;
+ }
+ if ((set[i] == 'B') && (set[1] == 'B') && set[2] == 'C') {
+ glyph_count = glyph_count - 1.0;
+ }
+ if (fset[i] == 'F') {
+ glyph_count = glyph_count + 2.0;
+ }
+ } else {
+ if ((fset[i] == 'F') && (fset[i - 1] != 'F')) {
+ glyph_count = glyph_count + 2.0;
+ }
+ if ((fset[i] != 'F') && (fset[i - 1] == 'F')) {
+ glyph_count = glyph_count + 2.0;
+ }
+ }
+
+ if ((set[i] == 'C') && (!((inputDataType == DataType.GS1) && (content.charAt(i) == '[')))) {
+ glyph_count = glyph_count + 0.5;
+ } else {
+ glyph_count = glyph_count + 1.0;
+ }
+ }
+
+ if ((inputDataType == DataType.GS1) && (set[0] != 'A')) {
+ /* FNC1 can be integrated with mode character */
+ glyph_count--;
+ }
+
+ if (glyph_count > 77.0) {
+ errorMsg.append("Input too long");
+ return false;
+ }
+
+ /* Calculate how tall the symbol will be */
+ glyph_count = glyph_count + 2.0;
+ i = (int) glyph_count;
+ rows_needed = (i / 5);
+ if (i % 5 > 0) {
+ rows_needed++;
+ }
+
+ if (rows_needed == 1) {
+ rows_needed = 2;
+ }
+
+ /* start with the mode character - Table 2 */
+ m = 0;
+ switch (set[0]) {
+ case 'A':
+ m = 0;
+ break;
+ case 'B':
+ m = 1;
+ break;
+ case 'C':
+ m = 2;
+ break;
+ }
+
+ if (readerInit) {
+ if (m == 2) {
+ m = 5;
+ }
+ if (inputDataType == DataType.GS1) {
+ errorMsg.append("Cannot use both GS1 mode and Reader Initialisation");
+ return false;
+ } else {
+ if ((set[0] == 'B') && (set[1] == 'C')) {
+ m = 6;
+ }
+ }
+ values[bar_characters] = (7 * (rows_needed - 2)) + m; /* see 4.3.4.2 */
+ values[bar_characters + 1] = 96; /* FNC3 */
+ bar_characters += 2;
+ } else {
+ if (inputDataType == DataType.GS1) {
+ /* Integrate FNC1 */
+ switch (set[0]) {
+ case 'B':
+ m = 3;
+ break;
+ case 'C':
+ m = 4;
+ break;
+ }
+ } else {
+ if ((set[0] == 'B') && (set[1] == 'C')) {
+ m = 5;
+ }
+ if (((set[0] == 'B') && (set[1] == 'B')) && (set[2] == 'C')) {
+ m = 6;
+ }
+ }
+ }
+ values[bar_characters] = (7 * (rows_needed - 2)) + m; /* see 4.3.4.2 */
+ bar_characters++;
+ //}
+ current_set = set[0];
+ f_state = false;
+ /* f_state remembers if we are in Extended ASCII mode (value 1) or
+ in ISO/IEC 646 mode (value 0) */
+ if (fset[0] == 'F') {
+ switch (current_set) {
+ case 'A':
+ values[bar_characters] = 101;
+ values[bar_characters + 1] = 101;
+ break;
+ case 'B':
+ values[bar_characters] = 100;
+ values[bar_characters + 1] = 100;
+ break;
+ }
+ bar_characters += 2;
+ f_state = true;
+ }
+
+ read = 0;
+
+ /* Encode the data */
+ do {
+
+ if ((read != 0) && (set[read] != set[read - 1])) { /* Latch different code set */
+ switch (set[read]) {
+ case 'A':
+ values[bar_characters] = 101;
+ bar_characters++;
+ current_set = 'A';
+ break;
+ case 'B':
+ values[bar_characters] = 100;
+ bar_characters++;
+ current_set = 'B';
+ break;
+ case 'C':
+ if (!((read == 1) && (set[0] == 'B'))) { /* Not Mode C/Shift B */
+ if (!((read == 2) && ((set[0] == 'B') && (set[1] == 'B')))) {
+ /* Not Mode C/Double Shift B */
+ values[bar_characters] = 99;
+ bar_characters++;
+ }
+ }
+ current_set = 'C';
+ break;
+ }
+ }
+ if (read != 0) {
+ if ((fset[read] == 'F') && !f_state) {
+ /* Latch beginning of extended mode */
+ switch (current_set) {
+ case 'A':
+ values[bar_characters] = 101;
+ values[bar_characters + 1] = 101;
+ break;
+ case 'B':
+ values[bar_characters] = 100;
+ values[bar_characters + 1] = 100;
+ break;
+ }
+ bar_characters += 2;
+ f_state = true;
+ }
+ if ((fset[read] == ' ') && f_state) {
+ /* Latch end of extended mode */
+ switch (current_set) {
+ case 'A':
+ values[bar_characters] = 101;
+ values[bar_characters + 1] = 101;
+ break;
+ case 'B':
+ values[bar_characters] = 100;
+ values[bar_characters + 1] = 100;
+ break;
+ }
+ bar_characters += 2;
+ f_state = false;
+ }
+ }
+
+ if ((fset[i] == 'f') || (fset[i] == 'n')) {
+ /* Shift extended mode */
+ switch (current_set) {
+ case 'A':
+ values[bar_characters] = 101; /* FNC 4 */
+ break;
+ case 'B':
+ values[bar_characters] = 100; /* FNC 4 */
+ break;
+ }
+ bar_characters++;
+ }
+
+ if ((set[i] == 'a') || (set[i] == 'b')) {
+ /* Insert shift character */
+ values[bar_characters] = 98;
+ bar_characters++;
+ }
+
+ if (!((inputDataType == DataType.GS1) && (inputData[read] == '['))) {
+ switch (set[read]) { /* Encode data characters */
+ case 'A':
+ case 'a':
+ getValueSubsetA(inputData[read], values, bar_characters);
+ bar_characters++;
+ read++;
+ break;
+ case 'B':
+ case 'b':
+ getValueSubsetB(inputData[read], values, bar_characters);
+ bar_characters++;
+ read++;
+ break;
+ case 'C':
+ getValueSubsetC(inputData[read], inputData[read + 1], values, bar_characters);
+ bar_characters++;
+ read += 2;
+ break;
+ }
+ } else {
+ values[bar_characters] = 102;
+ bar_characters++;
+ read++;
+ }
+
+ } while (read < input_length);
+
+ pads_needed = 5 - ((bar_characters + 2) % 5);
+ if (pads_needed == 5) {
+ pads_needed = 0;
+ }
+ if ((bar_characters + pads_needed) < 8) {
+ pads_needed += 8 - (bar_characters + pads_needed);
+ }
+ for (i = 0; i < pads_needed; i++) {
+ values[bar_characters] = 106;
+ bar_characters++;
+ }
+
+ /* Calculate check digits */
+ first_sum = 0;
+ second_sum = 0;
+ for (i = 0; i < bar_characters; i++) {
+ first_sum += (i + 2) * values[i];
+ second_sum += (i + 1) * values[i];
+ }
+ first_check = first_sum % 107;
+ second_sum += first_check * (bar_characters + 1);
+ second_check = second_sum % 107;
+ values[bar_characters] = first_check;
+ values[bar_characters + 1] = second_check;
+ readable = new StringBuilder();
+ pattern = new String[rows_needed];
+ rowCount = rows_needed;
+ rowHeight = new int[rows_needed];
+ encodeInfo.append("Symbol Rows: ").append(rows_needed).append("\n");
+ encodeInfo.append("First Check Digit: ").append(first_check).append("\n");
+ encodeInfo.append("Second Check Digit: ").append(second_check).append("\n");
+ encodeInfo.append("Codewords: ");
+ for (current_row = 0; current_row < rows_needed; current_row++) {
+ width_pattern = new StringBuilder();
+ width_pattern.append(C_16_K_START_STOP[C_16_K_START_VALUES[current_row]]);
+ width_pattern.append("1");
+ for (i = 0; i < 5; i++) {
+ width_pattern.append(C_16_K_TABLE[values[(current_row * 5) + i]]);
+ encodeInfo.append(values[(current_row * 5) + i]).append(" ");
+ }
+ width_pattern.append(C_16_K_START_STOP[C_16_K_STOP_VALUES[current_row]]);
+
+ pattern[current_row] = width_pattern.toString();
+ rowHeight[current_row] = 10;
+ }
+ encodeInfo.append("\n");
+ plotSymbol();
+ return true;
+ }
+
+ private void getValueSubsetA(int source, int[] values, int bar_chars) {
+ if (source > 127) {
+ if (source < 160) {
+ values[bar_chars] = source + 64 - 128;
+ } else {
+ values[bar_chars] = source - 32 - 128;
+ }
+ } else {
+ if (source < 32) {
+ values[bar_chars] = source + 64;
+ } else {
+ values[bar_chars] = source - 32;
+ }
+ }
+ }
+
+ private void getValueSubsetB(int source, int[] values, int bar_chars) {
+ if (source > 127) {
+ values[bar_chars] = source - 32 - 128;
+ } else {
+ values[bar_chars] = source - 32;
+ }
+ }
+
+ private void getValueSubsetC(int source_a, int source_b, int[] values, int bar_chars) {
+ int weight;
+
+ weight = (10 * Character.getNumericValue(source_a)) + Character.getNumericValue(source_b);
+ values[bar_chars] = weight;
+ }
+
+ private Mode findSubset(int letter) {
+ Mode mode;
+
+ if (letter <= 31) {
+ mode = Mode.SHIFTA;
+ } else if ((letter >= 48) && (letter <= 57)) {
+ mode = Mode.ABORC;
+ } else if (letter <= 95) {
+ mode = Mode.AORB;
+ } else if (letter <= 127) {
+ mode = Mode.SHIFTB;
+ } else if (letter <= 159) {
+ mode = Mode.SHIFTA;
+ } else if (letter <= 223) {
+ mode = Mode.AORB;
+ } else {
+ mode = Mode.SHIFTB;
+ }
+
+ return mode;
+ }
+
+ private void reduceSubsetChanges(int block_count) { /* Implements rules from ISO 15417 Annex E */
+ int i, length;
+ Mode current, last, next;
+
+ for (i = 0; i < block_count; i++) {
+ current = block_mode[i];
+ length = block_length[i];
+ if (i != 0) {
+ last = block_mode[i - 1];
+ } else {
+ last = Mode.NULL;
+ }
+ if (i != block_count - 1) {
+ next = block_mode[i + 1];
+ } else {
+ next = Mode.NULL;
+ }
+
+ if (i == 0) { /* first block */
+ if ((block_count == 1) && ((length == 2) && (current == Mode.ABORC))) { /* Rule 1a */
+ block_mode[i] = Mode.LATCHC;
+ }
+ if (current == Mode.ABORC) {
+ if (length >= 4) { /* Rule 1b */
+ block_mode[i] = Mode.LATCHC;
+ } else {
+ block_mode[i] = Mode.AORB;
+ current = Mode.AORB;
+ }
+ }
+ if (current == Mode.SHIFTA) { /* Rule 1c */
+ block_mode[i] = Mode.LATCHA;
+ }
+ if ((current == Mode.AORB) && (next == Mode.SHIFTA)) { /* Rule 1c */
+ block_mode[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if (current == Mode.AORB) { /* Rule 1d */
+ block_mode[i] = Mode.LATCHB;
+ }
+ } else {
+ if ((current == Mode.ABORC) && (length >= 4)) { /* Rule 3 */
+ block_mode[i] = Mode.LATCHC;
+ current = Mode.LATCHC;
+ }
+ if (current == Mode.ABORC) {
+ block_mode[i] = Mode.AORB;
+ current = Mode.AORB;
+ }
+ if ((current == Mode.AORB) && (last == Mode.LATCHA)) {
+ block_mode[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if ((current == Mode.AORB) && (last == Mode.LATCHB)) {
+ block_mode[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ if ((current == Mode.AORB) && (next == Mode.SHIFTA)) {
+ block_mode[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if ((current == Mode.AORB) && (next == Mode.SHIFTB)) {
+ block_mode[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ if (current == Mode.AORB) {
+ block_mode[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ if ((current == Mode.SHIFTA) && (length > 1)) { /* Rule 4 */
+ block_mode[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if ((current == Mode.SHIFTB) && (length > 1)) { /* Rule 5 */
+ block_mode[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ if ((current == Mode.SHIFTA) && (last == Mode.LATCHA)) {
+ block_mode[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if ((current == Mode.SHIFTB) && (last == Mode.LATCHB)) {
+ block_mode[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ if ((current == Mode.SHIFTA) && (last == Mode.LATCHC)) {
+ block_mode[i] = Mode.LATCHA;
+ current = Mode.LATCHA;
+ }
+ if ((current == Mode.SHIFTB) && (last == Mode.LATCHC)) {
+ block_mode[i] = Mode.LATCHB;
+ current = Mode.LATCHB;
+ }
+ }
+ }
+ combineSubsetBlocks(block_count);
+ }
+
+ private void combineSubsetBlocks(int block_count) {
+ int i, j;
+ if (block_count > 1) {
+ i = 1;
+ while (i < block_count) {
+ if (block_mode[i - 1] == block_mode[i]) {
+ block_length[i - 1] = block_length[i - 1] + block_length[i];
+ j = i + 1;
+ while (j < block_count) {
+ block_length[j - 1] = block_length[j];
+ block_mode[j - 1] = block_mode[j];
+ j++;
+ }
+ block_count = block_count - 1;
+ i--;
+ }
+ i++;
+ }
+ }
+ }
+
+ @Override
+ protected void plotSymbol() {
+ int xBlock, yBlock;
+ int x, y, w, h;
+ boolean black;
+ getRectangles().clear();
+ y = 1;
+ h = 1;
+ for (yBlock = 0; yBlock < rowCount; yBlock++) {
+ black = true;
+ x = 15;
+ for (xBlock = 0; xBlock < pattern[yBlock].length(); xBlock++) {
+ if (black) {
+ black = false;
+ w = pattern[yBlock].charAt(xBlock) - '0';
+ if (rowHeight[yBlock] == -1) {
+ h = defaultHeight;
+ } else {
+ h = rowHeight[yBlock];
+ }
+ if (w != 0 && h != 0) {
+ Rectangle2D.Double rect = new Rectangle2D.Double(x, y, w, h);
+ getRectangles().add(rect);
+ }
+ if ((x + w) > symbolWidth) {
+ symbolWidth = x + w;
+ }
+ } else {
+ black = true;
+ }
+ x += (double) (pattern[yBlock].charAt(xBlock) - '0');
+ }
+ y += h;
+ if ((y + h) > symbolHeight) {
+ symbolHeight = y + h;
+ }
+ /* Add bars between rows */
+ if (yBlock != (rowCount - 1)) {
+ Rectangle2D.Double rect = new Rectangle2D.Double(15, y - 1, (symbolWidth - 15), 2);
+ getRectangles().add(rect);
+ }
+ }
+ Rectangle2D.Double top = new Rectangle2D.Double(0, 0, (symbolWidth + 15), 2);
+ getRectangles().add(top);
+ Rectangle2D.Double bottom = new Rectangle2D.Double(0, y - 1, (symbolWidth + 15), 2);
+ getRectangles().add(bottom);
+ symbolWidth += 30;
+ symbolHeight += 2;
+ mergeVerticalBlocks();
+ }
+
+ private enum Mode {
+ NULL, SHIFTA, LATCHA, SHIFTB, LATCHB, SHIFTC, LATCHC, AORB, ABORC, CANDB, CANDBB
+ }
+
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/Code2Of5.java b/barcode/src/main/java/org/xbib/graphics/barcode/Code2Of5.java
new file mode 100755
index 0000000..6dba07d
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/Code2Of5.java
@@ -0,0 +1,493 @@
+package org.xbib.graphics.barcode;
+
+import static org.xbib.graphics.barcode.HumanReadableLocation.NONE;
+import static org.xbib.graphics.barcode.HumanReadableLocation.TOP;
+import org.xbib.graphics.barcode.util.TextBox;
+import java.awt.geom.Rectangle2D;
+
+/**
+ * Implements the Code 2 of 5 family of barcode standards.
+ */
+public class Code2Of5 extends Symbol {
+
+ private static final String[] C25_MATRIX_TABLE = {
+ "113311", "311131", "131131", "331111", "113131", "313111", "133111", "111331", "311311", "131311"
+ };
+ private static final String[] C25_INDUSTRIAL_TABLE = {
+ "1111313111", "3111111131", "1131111131", "3131111111", "1111311131", "3111311111", "1131311111", "1111113131", "3111113111", "1131113111"
+ };
+ private static final String[] C25_INTERLEAVED_TABLE = {
+ "11331", "31113", "13113", "33111", "11313", "31311", "13311", "11133", "31131", "13131"
+ };
+ /**
+ * The 2-of-5 mode.
+ */
+ private ToFMode mode = ToFMode.MATRIX;
+ /**
+ * Ratio of wide bar width to narrow bar width.
+ */
+ private double moduleWidthRatio = 3;
+
+ /**
+ * Returns the ratio of wide bar width to narrow bar width.
+ *
+ * @return the ratio of wide bar width to narrow bar width
+ */
+ public double getModuleWidthRatio() {
+ return moduleWidthRatio;
+ }
+
+ /**
+ * Sets the ratio of wide bar width to narrow bar width. Valid values are usually
+ * between {@code 2} and {@code 3}. The default value is {@code 3}.
+ *
+ * @param moduleWidthRatio the ratio of wide bar width to narrow bar width
+ */
+ public void setModuleWidthRatio(double moduleWidthRatio) {
+ this.moduleWidthRatio = moduleWidthRatio;
+ }
+
+ /**
+ * Select Standard Code 2 of 5 mode, also known as Code 2 of 5 Matrix. (default)
+ * Encodes any length numeric input (digits 0-9).
+ */
+ public void setMatrixMode() {
+ mode = ToFMode.MATRIX;
+ }
+
+ /**
+ * Select Industrial Code 2 of 5 which can encode any length numeric input
+ * (digits 0-9) and does not include a check digit.
+ */
+ public void setIndustrialMode() {
+ mode = ToFMode.INDUSTRIAL;
+ }
+
+ /**
+ * Select International Air Transport Agency variation of Code 2 of 5.
+ * Encodes any length numeric input (digits 0-9) and does not include
+ * a check digit.
+ */
+ public void setIATAMode() {
+ mode = ToFMode.IATA;
+ }
+
+ /**
+ * Select Code 2 of 5 Data Logic. Encodes any length numeric input
+ * (digits 0-9) and does not include a check digit.
+ */
+ public void setDataLogicMode() {
+ mode = ToFMode.DATA_LOGIC;
+ }
+
+ /**
+ * Select Interleaved Code 2 of 5. encodes pairs of numbers, and so can
+ * only encode an even number of digits (0-9). If an odd number of digits
+ * is entered a leading zero is added. No check digit is calculated.
+ */
+ public void setInterleavedMode() {
+ mode = ToFMode.INTERLEAVED;
+ }
+
+ /**
+ * Select ITF-14, also known as UPC Shipping Container Symbol or Case Code.
+ * Requires a 13 digit numeric input (digits 0-9). One modulo-10 check
+ * digit is calculated.
+ */
+ public void setITF14Mode() {
+ mode = ToFMode.ITF14;
+ }
+
+ /**
+ * Select Deutsche Post Leitcode. Requires a 13-digit numerical input.
+ * Check digit is calculated.
+ */
+ public void setDPLeitMode() {
+ mode = ToFMode.DPLEIT;
+ }
+
+ /**
+ * Select Deutsche Post Identcode. Requires an 11-digit numerical input.
+ * Check digit is calculated.
+ */
+ public void setDPIdentMode() {
+ mode = ToFMode.DPIDENT;
+ }
+
+ @Override
+ public boolean encode() {
+ boolean retval = false;
+
+ switch (mode) {
+ case MATRIX:
+ retval = dataMatrixTof();
+ break;
+ case INDUSTRIAL:
+ retval = industrialTof();
+ break;
+ case IATA:
+ retval = iataTof();
+ break;
+ case INTERLEAVED:
+ retval = interleavedTof();
+ break;
+ case DATA_LOGIC:
+ retval = dataLogic();
+ break;
+ case ITF14:
+ retval = itf14();
+ break;
+ case DPLEIT:
+ retval = deutschePostLeitcode();
+ break;
+ case DPIDENT:
+ retval = deutschePostIdentcode();
+ break;
+ }
+
+ if (retval) {
+ plotSymbol();
+ }
+
+ return retval;
+ }
+
+ private boolean dataMatrixTof() {
+
+ if (!(content.matches("[0-9]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ StringBuilder dest = new StringBuilder("311111");
+
+ for (int i = 0; i < content.length(); i++) {
+ dest.append(C25_MATRIX_TABLE[Character.getNumericValue(content.charAt(i))]);
+ }
+ dest.append("31111");
+
+ readable = new StringBuilder(content);
+ pattern = new String[]{dest.toString()};
+ rowCount = 1;
+ rowHeight = new int[]{-1};
+ return true;
+ }
+
+ private boolean industrialTof() {
+ if (!(content.matches("[0-9]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ StringBuilder dest = new StringBuilder("313111");
+ readable = new StringBuilder(content);
+ for (int i = 0; i < readable.length(); i++) {
+ dest.append(C25_INDUSTRIAL_TABLE[Character.getNumericValue(readable.charAt(i))]);
+ }
+ dest.append("31113");
+
+ pattern = new String[]{dest.toString()};
+ rowCount = 1;
+ rowHeight = new int[]{-1};
+ return true;
+ }
+
+ private boolean iataTof() {
+ if (!(content.matches("[0-9]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ StringBuilder dest = new StringBuilder("1111");
+ readable = new StringBuilder(content);
+ for (int i = 0; i < readable.length(); i++) {
+ dest.append(C25_INDUSTRIAL_TABLE[Character.getNumericValue(readable.charAt(i))]);
+ }
+ dest.append("311");
+
+ pattern = new String[]{dest.toString()};
+ rowCount = 1;
+ rowHeight = new int[]{-1};
+ return true;
+ }
+
+ private boolean dataLogic() {
+ if (!(content.matches("[0-9]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ StringBuilder dest = new StringBuilder("1111");
+ readable = new StringBuilder(content);
+
+ for (int i = 0; i < readable.length(); i++) {
+ dest.append(C25_MATRIX_TABLE[Character.getNumericValue(readable.charAt(i))]);
+ }
+
+ dest.append("311");
+
+ pattern = new String[]{dest.toString()};
+ rowCount = 1;
+ rowHeight = new int[]{-1};
+ return true;
+ }
+
+ private boolean interleavedTof() {
+ int i;
+ StringBuilder dest;
+
+ if ((content.length() & 1) == 0) {
+ readable = new StringBuilder(content);
+ } else {
+ readable = new StringBuilder("0").append(content);
+ }
+ if (!(readable.toString().matches("[0-9]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ dest = new StringBuilder("1111");
+
+ for (i = 0; i < readable.length(); i += 2) {
+ dest.append(interlace(i, i + 1));
+ }
+
+ dest.append("311");
+
+ pattern = new String[]{dest.toString()};
+ rowCount = 1;
+ rowHeight = new int[]{-1};
+ return true;
+ }
+
+ private String interlace(int x, int y) {
+ char a = readable.charAt(x);
+ char b = readable.charAt(y);
+
+ String one = C25_INTERLEAVED_TABLE[Character.getNumericValue(a)];
+ String two = C25_INTERLEAVED_TABLE[Character.getNumericValue(b)];
+ String f = "";
+
+ for (int i = 0; i < 5; i++) {
+ f += one.charAt(i);
+ f += two.charAt(i);
+ }
+
+ return f;
+ }
+
+ private boolean itf14() {
+ int i, count = 0;
+ int input_length = content.length();
+ StringBuilder dest;
+
+ if (!(content.matches("[0-9]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ if (input_length > 13) {
+ errorMsg.append("Input data too long");
+ return false;
+ }
+
+ readable = new StringBuilder();
+ for (i = input_length; i < 13; i++) {
+ readable.append("0");
+ }
+
+ readable.append(content);
+ for (i = 12; i >= 0; i--) {
+ count += readable.charAt(i) - '0';
+
+ if ((i & 1) == 0) {
+ count += 2 * (readable.charAt(i) - '0');
+ }
+ }
+
+ readable.append((char) (((10 - (count % 10)) % 10) + '0'));
+ encodeInfo.append("Check Digit: ").append((char) (((10 - (count % 10)) % 10) + '0'));
+ encodeInfo.append('\n');
+
+ dest = new StringBuilder("1111");
+
+ for (i = 0; i < readable.length(); i += 2) {
+ dest.append(interlace(i, i + 1));
+ }
+
+ dest.append("311");
+
+ pattern = new String[]{dest.toString()};
+ rowCount = 1;
+ rowHeight = new int[]{-1};
+ return true;
+ }
+
+ private boolean deutschePostLeitcode() {
+ int i, count = 0;
+ int input_length = content.length();
+ StringBuilder dest;
+
+ if (!(content.matches("[0-9]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ if (input_length > 13) {
+ errorMsg.append("Input data too long");
+ return false;
+ }
+
+ readable = new StringBuilder();
+ for (i = input_length; i < 13; i++) {
+ readable.append("0");
+ }
+
+ readable.append(content);
+
+ for (i = 12; i >= 0; i--) {
+ count += 4 * (readable.charAt(i) - '0');
+
+ if ((i & 1) != 0) {
+ count += 5 * (readable.charAt(i) - '0');
+ }
+ }
+
+ readable.append((char) (((10 - (count % 10)) % 10) + '0'));
+ encodeInfo.append("Check digit: ").append((char) (((10 - (count % 10)) % 10) + '0'));
+ encodeInfo.append('\n');
+
+ dest = new StringBuilder("1111");
+
+ for (i = 0; i < readable.length(); i += 2) {
+ dest.append(interlace(i, i + 1));
+ }
+
+ dest.append("311");
+
+ pattern = new String[]{dest.toString()};
+ rowCount = 1;
+ rowHeight = new int[]{-1};
+ return true;
+ }
+
+ private boolean deutschePostIdentcode() {
+ int i, count = 0;
+ int input_length = content.length();
+ StringBuilder dest;
+
+ if (!(content.matches("[0-9]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ if (input_length > 11) {
+ errorMsg.append("Input data too long");
+ return false;
+ }
+
+ readable = new StringBuilder();
+ for (i = input_length; i < 11; i++) {
+ readable.append("0");
+ }
+
+ readable.append(content);
+ for (i = 10; i >= 0; i--) {
+ count += 4 * (readable.charAt(i) - '0');
+
+ if ((i & 1) != 0) {
+ count += 5 * (readable.charAt(i) - '0');
+ }
+ }
+
+ readable.append((char) (((10 - (count % 10)) % 10) + '0'));
+ encodeInfo.append("Check Digit: ").append((char) (((10 - (count % 10)) % 10) + '0'));
+ encodeInfo.append('\n');
+
+ dest = new StringBuilder("1111");
+
+ for (i = 0; i < readable.length(); i += 2) {
+ dest.append(interlace(i, i + 1));
+ }
+
+ dest.append("311");
+
+ pattern = new String[]{dest.toString()};
+ rowCount = 1;
+ rowHeight = new int[]{-1};
+ return true;
+ }
+
+ @Override
+ protected void plotSymbol() {
+ int xBlock;
+ getRectangles().clear();
+ getTexts().clear();
+ int baseY;
+ if (getHumanReadableLocation() == TOP) {
+ baseY = getTheoreticalHumanReadableHeight();
+ } else {
+ baseY = 0;
+ }
+ double x = 0;
+ int y = baseY;
+ int h = 0;
+ boolean black = true;
+ int offset = 0;
+ if (mode == ToFMode.ITF14) {
+ offset = 20;
+ }
+ for (xBlock = 0; xBlock < pattern[0].length(); xBlock++) {
+ char c = pattern[0].charAt(xBlock);
+ double w = getModuleWidth(c - '0') * moduleWidth;
+ if (black) {
+ if (rowHeight[0] == -1) {
+ h = defaultHeight;
+ } else {
+ h = rowHeight[0];
+ }
+ if (w != 0 && h != 0) {
+ Rectangle2D.Double rect = new Rectangle2D.Double(x + offset, y, w, h);
+ getRectangles().add(rect);
+ }
+ symbolWidth = (int) Math.ceil(x + w + (2 * offset));
+ }
+ black = !black;
+ x += w;
+ }
+ symbolHeight = h;
+ if (mode == ToFMode.ITF14) {
+ Rectangle2D.Double topBar = new Rectangle2D.Double(0, baseY, symbolWidth, 4);
+ Rectangle2D.Double bottomBar = new Rectangle2D.Double(0, baseY + symbolHeight - 4, symbolWidth, 4);
+ Rectangle2D.Double leftBar = new Rectangle2D.Double(0, baseY, 4, symbolHeight);
+ Rectangle2D.Double rightBar = new Rectangle2D.Double(symbolWidth - 4, baseY, 4, symbolHeight);
+ getRectangles().add(topBar);
+ getRectangles().add(bottomBar);
+ getRectangles().add(leftBar);
+ getRectangles().add(rightBar);
+ }
+ if (getHumanReadableLocation() != NONE && readable.length() > 0) {
+ double baseline;
+ if (getHumanReadableLocation() == TOP) {
+ baseline = fontSize;
+ } else {
+ baseline = getHeight() + fontSize;
+ }
+ double centerX = getWidth() / 2.0;
+ getTexts().add(new TextBox(centerX, baseline, readable.toString()));
+ }
+ }
+
+ @Override
+ protected double getModuleWidth(int originalWidth) {
+ if (originalWidth == 1) {
+ return 1;
+ } else {
+ return moduleWidthRatio;
+ }
+ }
+
+ private enum ToFMode {
+ MATRIX, INDUSTRIAL, IATA, DATA_LOGIC, INTERLEAVED, ITF14, DPLEIT, DPIDENT
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/Code32.java b/barcode/src/main/java/org/xbib/graphics/barcode/Code32.java
new file mode 100755
index 0000000..6c35717
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/Code32.java
@@ -0,0 +1,103 @@
+package org.xbib.graphics.barcode;
+
+/**
+ * Implements Code 32, also known as Italian Pharmacode, A variation of Code
+ * 39 used by the Italian Ministry of Health ("Ministero della Sanità ")
+ * Requires a numeric input up to 8 digits in length. Check digit is
+ * calculated.
+ */
+public class Code32 extends Symbol {
+ private char[] tabella = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'B', 'C', 'D', 'F',
+ 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+ 'W', 'X', 'Y', 'Z'
+ };
+
+ @Override
+ public boolean encode() {
+ int i, checksum, checkpart, checkdigit;
+ int pharmacode, remainder, devisor;
+ StringBuilder localstr;
+ StringBuilder risultante;
+ int[] codeword = new int[6];
+ Code3Of9 c39 = new Code3Of9();
+
+ if (content.length() > 8) {
+ errorMsg.append("Input too long");
+ return false;
+ }
+
+ if (!(content.matches("[0-9]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ /* Add leading zeros as required */
+ localstr = new StringBuilder();
+ for (i = content.length(); i < 8; i++) {
+ localstr.append("0");
+ }
+ localstr.append(content);
+
+ /* Calculate the check digit */
+ checksum = 0;
+ checkpart = 0;
+ for (i = 0; i < 4; i++) {
+ checkpart = Character.getNumericValue(localstr.charAt(i * 2));
+ checksum += checkpart;
+ checkpart = 2 * Character.getNumericValue(localstr.charAt((i * 2) + 1));
+ if (checkpart >= 10) {
+ checksum += (checkpart - 10) + 1;
+ } else {
+ checksum += checkpart;
+ }
+ }
+
+ /* Add check digit to data string */
+ checkdigit = checksum % 10;
+ localstr.append((char) (checkdigit + '0'));
+ encodeInfo.append("Check Digit: ").append((char) (checkdigit + '0'));
+ encodeInfo.append('\n');
+
+ /* Convert string into an integer value */
+ pharmacode = 0;
+ for (i = 0; i < localstr.length(); i++) {
+ pharmacode *= 10;
+ pharmacode += Character.getNumericValue(localstr.charAt(i));
+ }
+
+ /* Convert from decimal to base-32 */
+ devisor = 33554432;
+ for (i = 5; i >= 0; i--) {
+ codeword[i] = pharmacode / devisor;
+ remainder = pharmacode % devisor;
+ pharmacode = remainder;
+ devisor /= 32;
+ }
+
+ /* Look up values in 'Tabella di conversione' */
+ risultante = new StringBuilder();
+ for (i = 5; i >= 0; i--) {
+ risultante.append(tabella[codeword[i]]);
+ }
+
+ /* Plot the barcode using Code 39 */
+
+ readable = new StringBuilder("A").append(localstr);
+ pattern = new String[1];
+ rowCount = 1;
+ rowHeight = new int[1];
+ rowHeight[0] = -1;
+ encodeInfo.append("Code 39 Equivalent: ").append(risultante).append('\n');
+ try {
+ c39.setContent(risultante.toString());
+ } catch (Exception e) {
+ errorMsg.append(e.getMessage());
+ return false;
+ }
+
+ this.pattern[0] = c39.pattern[0];
+ this.plotSymbol();
+ return true;
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/Code3Of9.java b/barcode/src/main/java/org/xbib/graphics/barcode/Code3Of9.java
new file mode 100755
index 0000000..7fb0378
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/Code3Of9.java
@@ -0,0 +1,155 @@
+package org.xbib.graphics.barcode;
+
+/**
+ * Implements Code 39 bar code symbology according to ISO/IEC 16388:2007.
+ * Input data can be of any length and supports the characters 0-9, A-Z, dash
+ * (-), full stop (.), space, asterisk (*), dollar ($), slash (/), plus (+)
+ * and percent (%). The standard does not require a check digit but a
+ * modulo-43 check digit can be added if required.
+ */
+public class Code3Of9 extends Symbol {
+
+ private static final String[] CODE_39 = {
+ "1112212111", "2112111121", "1122111121", "2122111111", "1112211121",
+ "2112211111", "1122211111", "1112112121", "2112112111", "1122112111",
+ "2111121121", "1121121121", "2121121111", "1111221121", "2111221111",
+ "1121221111", "1111122121", "2111122111", "1121122111", "1111222111",
+ "2111111221", "1121111221", "2121111211", "1111211221", "2111211211",
+ "1121211211", "1111112221", "2111112211", "1121112211", "1111212211",
+ "2211111121", "1221111121", "2221111111", "1211211121", "2211211111",
+ "1221211111", "1211112121", "2211112111", "1221112111", "1212121111",
+ "1212111211", "1211121211", "1112121211"
+ };
+ private static final char[] LOOKUP = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
+ 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
+ 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '-', '.', ' ', '$', '/', '+',
+ '%'
+ };
+ private CheckDigit checkOption = CheckDigit.NONE;
+ /**
+ * Ratio of wide bar width to narrow bar width.
+ */
+ private double moduleWidthRatio = 2;
+
+ /**
+ * Returns the ratio of wide bar width to narrow bar width.
+ *
+ * @return the ratio of wide bar width to narrow bar width
+ */
+ public double getModuleWidthRatio() {
+ return moduleWidthRatio;
+ }
+
+ /**
+ * Sets the ratio of wide bar width to narrow bar width. Valid values are usually
+ * between {@code 2} and {@code 3}. The default value is {@code 2}.
+ *
+ * @param moduleWidthRatio the ratio of wide bar width to narrow bar width
+ */
+ public void setModuleWidthRatio(double moduleWidthRatio) {
+ this.moduleWidthRatio = moduleWidthRatio;
+ }
+
+ /**
+ * Select addition of optional Modulo-43 check digit or encoding without
+ * check digit.
+ *
+ * @param checkMode Check digit option.
+ */
+ public void setCheckDigit(CheckDigit checkMode) {
+ checkOption = checkMode;
+ }
+
+ @Override
+ public boolean encode() {
+ if (!(content.matches("[0-9A-Z\\. \\-$/+%]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+ StringBuilder p = new StringBuilder();
+ StringBuilder dest = new StringBuilder();
+ int l = content.length();
+ int charval;
+ char thischar;
+ int counter = 0;
+ char check_digit = ' ';
+ dest.append("1211212111");
+ for (int i = 0; i < l; i++) {
+ thischar = content.charAt(i);
+ charval = positionOf(thischar, LOOKUP);
+ counter += charval;
+ p.append(CODE_39[charval]);
+ }
+ dest.append(p);
+ if (checkOption == CheckDigit.MOD43) {
+ counter = counter % 43;
+ if (counter < 10) {
+ check_digit = (char) (counter + '0');
+ } else {
+ if (counter < 36) {
+ check_digit = (char) ((counter - 10) + 'A');
+ } else {
+ switch (counter) {
+ case 36:
+ check_digit = '-';
+ break;
+ case 37:
+ check_digit = '.';
+ break;
+ case 38:
+ check_digit = ' ';
+ break;
+ case 39:
+ check_digit = '$';
+ break;
+ case 40:
+ check_digit = '/';
+ break;
+ case 41:
+ check_digit = '+';
+ break;
+ default:
+ check_digit = 37;
+ break;
+ }
+ }
+ }
+ charval = positionOf(check_digit, LOOKUP);
+ p.append(CODE_39[charval]);
+ if (check_digit == ' ') {
+ check_digit = '_';
+ }
+ }
+ dest.append("121121211");
+ if (checkOption == CheckDigit.MOD43) {
+ readable = new StringBuilder("*").append(content).append(check_digit).append("*");
+ encodeInfo.append("Check Digit: ").append(check_digit).append("\n");
+ } else {
+ readable = new StringBuilder("*").append(content).append("*");
+ }
+ pattern = new String[]{dest.toString()};
+ rowCount = 1;
+ rowHeight = new int[]{-1};
+ plotSymbol();
+ return true;
+ }
+
+ @Override
+ protected double getModuleWidth(int originalWidth) {
+ if (originalWidth == 1) {
+ return 1;
+ } else {
+ return moduleWidthRatio;
+ }
+ }
+
+ @Override
+ protected int[] getCodewords() {
+ return getPatternAsCodewords(10);
+ }
+
+ public enum CheckDigit {
+ NONE, MOD43
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/Code3Of9Extended.java b/barcode/src/main/java/org/xbib/graphics/barcode/Code3Of9Extended.java
new file mode 100755
index 0000000..30d9e63
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/Code3Of9Extended.java
@@ -0,0 +1,79 @@
+package org.xbib.graphics.barcode;
+
+/**
+ * Implements Code 3 of 9 Extended, also known as Code 39e and Code39+.
+ * Supports encoding of all characters in the 7-bit ASCII table. A
+ * modulo-43 check digit can be added if required.
+ */
+public class Code3Of9Extended extends Symbol {
+
+ private final String[] ECode39 = {
+ "%U", "$A", "$B", "$C", "$D", "$E", "$F", "$G", "$H", "$I", "$J", "$K",
+ "$L", "$M", "$N", "$O", "$P", "$Q", "$R", "$S", "$T", "$U", "$V", "$W",
+ "$X", "$Y", "$Z", "%A", "%B", "%C", "%D", "%E", " ", "/A", "/B", "/C",
+ "/D", "/E", "/F", "/G", "/H", "/I", "/J", "/K", "/L", "-", ".", "/O",
+ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "/Z", "%F", "%G",
+ "%H", "%I", "%J", "%V", "A", "B", "C", "D", "E", "F", "G", "H", "I",
+ "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W",
+ "X", "Y", "Z", "%K", "%L", "%M", "%N", "%O", "%W", "+A", "+B", "+C",
+ "+D", "+E", "+F", "+G", "+H", "+I", "+J", "+K", "+L", "+M", "+N", "+O",
+ "+P", "+Q", "+R", "+S", "+T", "+U", "+V", "+W", "+X", "+Y", "+Z", "%P",
+ "%Q", "%R", "%S", "%T"
+ };
+ private CheckDigit checkOption;
+
+ public Code3Of9Extended() {
+ checkOption = CheckDigit.NONE;
+ }
+
+ /**
+ * Select addition of optional Modulo-43 check digit or encoding without
+ * check digit.
+ *
+ * @param checkMode Check digit option
+ */
+ public void setCheckDigit(CheckDigit checkMode) {
+ checkOption = checkMode;
+ }
+
+ @Override
+ public boolean encode() {
+ StringBuilder buffer = new StringBuilder();
+ int l = content.length();
+ int asciicode;
+ Code3Of9 c = new Code3Of9();
+
+ if (checkOption == CheckDigit.MOD43) {
+ c.setCheckDigit(Code3Of9.CheckDigit.MOD43);
+ }
+
+ if (!content.matches("[\u0000-\u007F]+")) {
+ errorMsg.append("Invalid characters in input data");
+ return false;
+ }
+
+ for (int i = 0; i < l; i++) {
+ asciicode = content.charAt(i);
+ buffer.append(ECode39[asciicode]);
+ }
+
+ try {
+ c.setContent(buffer.toString());
+ } catch (Exception e) {
+ errorMsg.append(e.getMessage());
+ return false;
+ }
+ readable = new StringBuilder(content);
+ pattern = new String[1];
+ pattern[0] = c.pattern[0];
+ rowCount = 1;
+ rowHeight = new int[1];
+ rowHeight[0] = -1;
+ plotSymbol();
+ return true;
+ }
+
+ public enum CheckDigit {
+ NONE, MOD43
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/Code49.java b/barcode/src/main/java/org/xbib/graphics/barcode/Code49.java
new file mode 100755
index 0000000..ef55083
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/Code49.java
@@ -0,0 +1,1345 @@
+package org.xbib.graphics.barcode;
+
+import java.awt.geom.Rectangle2D;
+
+/**
+ * Implements Code 49 according to ANSI/AIM-BC6-2000.
+ * Encoding supports full 7-bit ASCII input up to a maximum of 49 characters
+ * or 81 numeric digits. GS1 data encoding is also supported.
+ */
+public class Code49 extends Symbol {
+
+ private final String[] c49_table7 = {
+ /* Table 7: Code 49 ASCII Chart */
+ "! ", "!A", "!B", "!C", "!D", "!E", "!F", "!G", "!H", "!I", "!J", "!K",
+ "!L", "!M", "!N", "!O", "!P", "!Q", "!R", "!S", "!T", "!U", "!V", "!W",
+ "!X", "!Y", "!Z", "!1", "!2", "!3", "!4", "!5", " ", "!6", "!7", "!8",
+ "$", "%", "!9", "!0", "!-", "!.", "!$", "+", "!/", "-", ".", "/", "0",
+ "1", "2", "3", "4", "5", "6", "7", "8", "9", "!+", "&1", "&2", "&3",
+ "&4", "&5", "&6", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K",
+ "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y",
+ "Z", "&7", "&8", "&9", "&0", "&-", "&.", "&A", "&B", "&C", "&D", "&E",
+ "&F", "&G", "&H", "&I", "&J", "&K", "&L", "&M", "&N", "&O", "&P", "&Q",
+ "&R", "&S", "&T", "&U", "&V", "&W", "&X", "&Y", "&Z", "&$", "&/", "&+",
+ "&%", "& "
+ };
+
+ /* Table 5: Check Character Weighting Values */
+ private final int[] c49_x_weight = {
+ 1, 9, 31, 26, 2, 12, 17, 23, 37, 18, 22, 6, 27, 44, 15, 43, 39, 11, 13,
+ 5, 41, 33, 36, 8, 4, 32, 3, 19, 40, 25, 29, 10
+ };
+
+ private final int[] c49_y_weight = {
+ 9, 31, 26, 2, 12, 17, 23, 37, 18, 22, 6, 27, 44, 15, 43, 39, 11, 13, 5,
+ 41, 33, 36, 8, 4, 32, 3, 19, 40, 25, 29, 10, 24
+ };
+
+ private final int[] c49_z_weight = {
+ 31, 26, 2, 12, 17, 23, 37, 18, 22, 6, 27, 44, 15, 43, 39, 11, 13, 5, 41,
+ 33, 36, 8, 4, 32, 3, 19, 40, 25, 29, 10, 24, 30
+ };
+
+ private final String[] c49_table4 = {
+ /* Table 4: Row Parity Pattern for Code 49 Symbols */
+ "OEEO", "EOEO", "OOEE", "EEOO", "OEOE", "EOOE", "OOOO", "EEEE"
+ };
+
+ private final String[] c49_appxe_even = {
+ /* Appendix E - Code 49 Encodation Patterns (Even Symbol Character Parity) */
+ /* Column 1 */
+ "11521132", "25112131", "14212132", "25121221", "14221222", "12412132",
+ "23321221", "12421222", "21521221", "15112222", "15121312", "13312222",
+ "24221311", "13321312", "11512222", "22421311", "11521312", "25112311",
+ "14212312", "23312311", "12412312", "21512311", "16121131", "14321131",
+ "12521131", "15212131", "15221221", "13412131", "13421221", "11612131",
+ "16112221", "16121311", "14312221", "14321311", "12512221", "12521311",
+ "15212311", "13412311", "11612311", "11131135", "31131133", "51131131",
+ "21122134", "41122132", "21131224", "41131222", "11113135", "31113133",
+ "51113131", "11122225", "31122223", "51122221", "11131315", "31131313",
+ "51131311", "21113224", "41113222", "21122314",
+ /* Column 2 */
+ "41122312", "11113315", "31113313", "51113311", "12131134", "32131132",
+ "21231133", "41231131", "22122133", "42122131", "11222134", "22131223",
+ "42131221", "11231224", "31231222", "12113134", "32113132", "12122224",
+ "32122222", "12131314", "32131312", "21231313", "41231311", "22113223",
+ "42113221", "11213224", "22122313", "42122311", "11222314", "31222312",
+ "12113314", "32113312", "21213313", "41213311", "13131133", "33131131",
+ "22231132", "11331133", "31331131", "23122132", "12222133", "23131222",
+ "12231223", "32231221", "21331222", "13113133", "33113131", "13122223",
+ "33122221", "11313133", "13131313", "33131311", "11322223", "22231312",
+ "11331313", "31331311", "23113222", "12213223",
+ /* Column 3 */
+ "23122312", "12222313", "32222311", "21322312", "13113313", "33113311",
+ "22213312", "11313313", "31313311", "14131132", "23231131", "12331132",
+ "21431131", "24122131", "13222132", "24131221", "13231222", "11422132",
+ "22331221", "11431222", "14113132", "14122222", "12313132", "14131312",
+ "12322222", "23231311", "12331312", "21431311", "24113221", "13213222",
+ "24122311", "13222312", "11413222", "22322311", "11422312", "14113312",
+ "23213311", "12313312", "21413311", "15131131", "13331131", "14222131",
+ "14231221", "12422131", "12431221", "15113131", "15122221", "13313131",
+ "15131311", "13322221", "11513131", "13331311", "11522221", "14213221",
+ "14222311", "12413221", "12422311", "15113311",
+ /* Column 4 */
+ "13313311", "11513311", "11141134", "31141132", "21132133", "41132131",
+ "21141223", "41141221", "11123134", "31123132", "11132224", "31132222",
+ "11141314", "31141312", "21114133", "41114131", "21123223", "41123221",
+ "21132313", "41132311", "11114224", "31114222", "11123314", "31123312",
+ "21114313", "41114311", "12141133", "32141131", "21241132", "22132132",
+ "11232133", "22141222", "11241223", "31241221", "12123133", "32123131",
+ "12132223", "32132221", "12141313", "32141311", "21241312", "22114132",
+ "11214133", "22123222", "11223223", "22132312", "11232313", "31232311",
+ "12114223", "32114221", "12123313", "32123311", "21223312", "22114312",
+ "11214313", "31214311", "13141132", "22241131",
+ /* Column 5 */
+ "11341132", "23132131", "12232132", "23141221", "12241222", "21341221",
+ "13123132", "13132222", "11323132", "13141312", "11332222", "22241311",
+ "11341312", "23114131", "12214132", "23123221", "12223222", "23132311",
+ "12232312", "21332311", "13114222", "13123312", "11314222", "22223311",
+ "11323312", "23114311", "12214312", "21314311", "14141131", "12341131",
+ "13232131", "13241221", "11432131", "14123131", "14132221", "12323131",
+ "14141311", "12332221", "12341311", "13214131", "13223221", "11414131",
+ "13232311", "11423221", "11432311", "14114221", "14123311", "12314221",
+ "12323311", "13214311", "11414311", "11151133", "31151131", "21142132",
+ "21151222", "11133133", "31133131", "11142223",
+ /* Column 6 */
+ "31142221", "11151313", "31151311", "21124132", "21133222", "21142312",
+ "11115133", "31115131", "11124223", "31124221", "11133313", "31133311",
+ "21115222", "21124312", "12151132", "21251131", "22142131", "11242132",
+ "22151221", "11251222", "12133132", "12142222", "12151312", "21251311",
+ "22124131", "11224132", "22133221", "11233222", "22142311", "11242312",
+ "12115132", "12124222", "12133312", "21233311", "22115221", "11215222",
+ "22124311", "11224312", "13151131", "12242131", "12251221", "13133131",
+ "13142221", "11333131", "13151311", "11342221", "12224131", "12233221",
+ "12242311", "13115131", "13124221", "11315131", "13133311", "11324221",
+ "11333311", "12215221", "12224311", "11161132",
+ /* Column 7 */
+ "21152131", "21161221", "11143132", "11152222", "11161312", "21134131",
+ "21143221", "21152311", "11125132", "11134222", "11143312", "21116131",
+ "21125221", "21134311", "12161131", "11252131", "12143131", "12152221",
+ "12161311", "11234131", "11243221", "11252311", "12125131", "12134221",
+ "12143311", "11216131", "11225221", "11234311", "11111236", "31111234",
+ "51111232", "21111325", "41111323", "61111321", "11111416", "31111414",
+ "51111412", "31211143", "51211141", "12111235", "32111233", "52111231",
+ "21211234", "41211232", "22111324", "42111322", "11211325", "31211323",
+ "51211321", "12111415", "32111413", "52111411", "21211414", "41211412",
+ "12211144", "32211142", "21311143", "41311141",
+ /* Column 8 */
+ "13111234", "33111232", "22211233", "42211231", "11311234", "31311232",
+ "23111323", "43111321", "12211324", "32211322", "21311323", "41311321",
+ "13111414", "33111412", "22211413", "42211411", "11311414", "31311412",
+ "13211143", "33211141", "22311142", "11411143", "31411141", "14111233",
+ "34111231", "23211232", "12311233", "32311231", "21411232", "24111322",
+ "13211323", "33211321", "22311322", "11411323", "31411321", "14111413",
+ "34111411", "23211412", "12311413", "32311411", "21411412", "14211142",
+ "23311141", "12411142", "21511141", "15111232", "24211231", "13311232",
+ "22411231", "11511232", "25111321", "14211322", "23311321", "12411322",
+ "21511321", "15111412", "24211411", "13311412",
+ /* Column 9 */
+ "22411411", "11511412", "15211141", "13411141", "11611141", "16111231",
+ "14311231", "12511231", "15211321", "13411321", "11611321", "16111411",
+ "14311411", "12511411", "21121144", "41121142", "11112145", "31112143",
+ "51112141", "11121235", "31121233", "51121231", "21112234", "41112232",
+ "21121324", "41121322", "11112325", "31112323", "51112321", "11121415",
+ "31121413", "51121411", "21112414", "41112412", "22121143", "42121141",
+ "11221144", "31221142", "12112144", "32112142", "12121234", "32121232",
+ "21221233", "41221231", "22112233", "42112231", "11212234", "22121323",
+ "42121321", "11221324", "31221322", "12112324", "32112322", "12121414",
+ "32121412", "21221413", "41221411", "22112413",
+ /* Column 10 */
+ "42112411", "11212414", "31212412", "23121142", "12221143", "32221141",
+ "21321142", "13112143", "33112141", "13121233", "33121231", "11312143",
+ "22221232", "11321233", "31321231", "23112232", "12212233", "23121322",
+ "12221323", "32221321", "21321322", "13112323", "33112321", "13121413",
+ "33121411", "11312323", "22221412", "11321413", "31321411", "23112412",
+ "12212413", "32212411", "21312412", "24121141", "13221142", "22321141",
+ "11421142", "14112142", "14121232", "12312142", "23221231", "12321232",
+ "21421231", "24112231", "13212232", "24121321", "13221322", "11412232",
+ "22321321", "11421322", "14112322", "14121412", "12312322", "23221411",
+ "12321412", "21421411", "24112411", "13212412",
+ /* Column 11 */
+ "22312411", "11412412", "14221141", "12421141", "15112141", "15121231",
+ "13312141", "13321231", "11512141", "11521231", "14212231", "14221321",
+ "12412231", "12421321", "15112321", "15121411", "13312321", "13321411",
+ "11512321", "11521411", "14212411", "12412411", "21131143", "41131141",
+ "11122144", "31122142", "11131234", "31131232", "21113143", "41113141",
+ "21122233", "41122231", "21131323", "41131321", "11113234", "31113232",
+ "11122324", "31122322", "11131414", "31131412", "21113323", "41113321",
+ "21122413", "41122411", "11113414", "31113412", "22131142", "11231143",
+ "31231141", "12122143", "32122141", "12131233", "32131231", "21231232",
+ "22113142", "11213143", "22122232", "11222233",
+ /* Column 12 */
+ "22131322", "11231323", "31231321", "12113233", "32113231", "12122323",
+ "32122321", "12131413", "32131411", "21231412", "22113322", "11213323",
+ "22122412", "11222413", "31222411", "12113413", "32113411", "21213412",
+ "23131141", "12231142", "21331141", "13122142", "13131232", "11322142",
+ "22231231", "11331232", "23113141", "12213142", "23122231", "12222232",
+ "23131321", "12231322", "21331321", "13113232", "13122322", "11313232",
+ "13131412", "11322322", "22231411", "11331412", "23113321", "12213322",
+ "23122411", "12222412", "21322411", "13113412", "22213411", "11313412",
+ "13231141", "11431141", "14122141", "14131231", "12322141", "12331231",
+ "13213141", "13222231", "11413141", "13231321",
+ /* Column 13 */
+ "11422231", "11431321", "14113231", "14122321", "12313231", "14131411",
+ "12322321", "12331411", "13213321", "13222411", "11413321", "11422411",
+ "14113411", "12313411", "21141142", "11132143", "31132141", "11141233",
+ "31141231", "21123142", "21132232", "21141322", "11114143", "31114141",
+ "11123233", "31123231", "11132323", "31132321", "11141413", "31141411",
+ "21114232", "21123322", "21132412", "11114323", "31114321", "11123413",
+ "31123411", "22141141", "11241142", "12132142", "12141232", "21241231",
+ "22123141", "11223142", "22132231", "11232232", "22141321", "11241322",
+ "12114142", "12123232", "12132322", "12141412", "21241411", "22114231",
+ "11214232", "22123321", "11223322", "22132411",
+ /* Column 14 */
+ "11232412", "12114322", "12123412", "21223411", "12241141", "13132141",
+ "13141231", "11332141", "11341231", "12223141", "12232231", "12241321",
+ "13114141", "13123231", "11314141", "13132321", "11323231", "13141411",
+ "11332321", "11341411", "12214231", "12223321", "12232411", "13114321",
+ "13123411", "11314321", "11323411", "21151141", "11142142", "11151232",
+ "21133141", "21142231", "21151321", "11124142", "11133232", "11142322",
+ "11151412", "21115141", "21124231", "21133321", "21142411", "11115232",
+ "11124322", "11133412", "11251141", "12142141", "12151231", "11233141",
+ "11242231", "11251321", "12124141", "12133231", "12142321", "12151411",
+ "11215141", "11224231", "11233321", "11242411",
+ /* Column 15 */
+ "12115231", "12124321", "12133411", "11152141", "11161231", "11134141",
+ "11143231", "11152321", "11161411", "11116141", "11125231", "11134321",
+ "11143411", "21111244", "41111242", "11111335", "31111333", "51111331",
+ "21111424", "41111422", "11111515", "31111513", "51111511", "21211153",
+ "41211151", "22111243", "42111241", "11211244", "31211242", "12111334",
+ "32111332", "21211333", "41211331", "22111423", "42111421", "11211424",
+ "31211422", "12111514", "32111512", "21211513", "41211511", "22211152",
+ "11311153", "31311151", "23111242", "12211243", "32211241", "21311242",
+ "13111333", "33111331", "22211332", "11311333", "31311331", "23111422",
+ "12211423", "32211421", "21311422", "13111513",
+ /* Column 16 */
+ "33111511", "22211512", "11311513", "31311511", "23211151", "12311152",
+ "21411151", "24111241", "13211242", "22311241", "11411242", "14111332",
+ "23211331", "12311332", "21411331", "24111421", "13211422", "22311421",
+ "11411422", "14111512", "23211511", "12311512", "21411511", "13311151",
+ "11511151", "14211241", "12411241", "15111331", "13311331", "11511331",
+ "14211421", "12411421", "15111511", "13311511", "11511511", "31121152",
+ "21112153", "41112151", "21121243", "41121241", "11112244", "31112242",
+ "11121334", "31121332", "21112333", "41112331", "21121423", "41121421",
+ "11112424", "31112422", "11121514", "31121512", "21112513", "41112511",
+ "12121153", "32121151", "21221152", "22112152",
+ /* Column 17 */
+ "11212153", "22121242", "11221243", "31221241", "12112243", "32112241",
+ "12121333", "32121331", "21221332", "22112332", "11212333", "22121422",
+ "11221423", "31221421", "12112423", "32112421", "12121513", "32121511",
+ "21221512", "22112512", "11212513", "31212511", "13121152", "22221151",
+ "11321152", "23112151", "12212152", "23121241", "12221242", "21321241",
+ "13112242", "13121332", "11312242", "22221331", "11321332", "23112331",
+ "12212332", "23121421", "12221422", "21321421", "13112422", "13121512",
+ "11312422", "22221511", "11321512", "23112511", "12212512", "21312511",
+ "14121151", "12321151", "13212151", "13221241", "11412151", "11421241",
+ "14112241", "14121331", "12312241", "12321331",
+ /* Column 18 */
+ "13212331", "13221421", "11412331", "11421421", "14112421", "14121511",
+ "12312421", "12321511", "13212511", "11412511", "11131153", "31131151",
+ "21122152", "21131242", "11113153", "31113151", "11122243", "31122241",
+ "11131333", "31131331", "21113242", "21122332", "21131422", "11113333",
+ "31113331", "11122423", "31122421", "11131513", "31131511", "21113422",
+ "21122512", "12131152", "21231151", "22122151", "11222152", "22131241",
+ "11231242", "12113152", "12122242", "12131332", "21231331", "22113241",
+ "11213242", "22122331", "11222332", "22131421", "11231422", "12113332",
+ "12122422", "12131512", "21231511", "22113421", "11213422", "22122511",
+ "11222512", "13131151", "11331151", "12222151",
+ /* Column 19 */
+ "12231241", "13113151", "13122241", "11313151", "13131331", "11322241",
+ "11331331", "12213241", "12222331", "12231421", "13113331", "13122421",
+ "11313331", "13131511", "11322421", "11331511", "12213421", "12222511",
+ "11141152", "21132151", "21141241", "11123152", "11132242", "11141332",
+ "21114151", "21123241", "21132331", "21141421", "11114242", "11123332",
+ "11132422", "11141512", "21114331", "21123421", "21132511", "12141151",
+ "11232151", "11241241", "12123151", "12132241", "12141331", "11214151",
+ "11223241", "11232331", "11241421", "12114241", "12123331", "12132421",
+ "12141511", "11214331", "11223421", "11232511", "11151151", "11133151",
+ "11142241", "11151331", "11115151", "11124241",
+ /* Column 20 */
+ "11133331", "11142421", "11151511", "11111254", "31111252", "21111343",
+ "41111341", "11111434", "31111432", "21111523", "41111521", "11111614",
+ "31111612", "31211161", "12111253", "32111251", "21211252", "22111342",
+ "11211343", "31211341", "12111433", "32111431", "21211432", "22111522",
+ "11211523", "31211521", "12111613", "32111611", "21211612", "12211162",
+ "21311161", "13111252", "22211251", "11311252", "23111341", "12211342",
+ "21311341", "13111432", "22211431", "11311432", "23111521", "12211522",
+ "21311521", "13111612", "22211611", "11311612", "13211161", "11411161",
+ "14111251", "12311251", "13211341", "11411341", "14111431", "12311431",
+ "13211521", "11411521", "14111611", "12311611",
+ /* Column 21 */
+ "21121162", "11112163", "31112161", "11121253", "31121251", "21112252",
+ "21121342", "11112343", "31112341", "11121433", "31121431", "21112432",
+ "21121522", "11112523", "31112521", "11121613", "31121611", "22121161",
+ "11221162", "12112162", "12121252", "21221251", "22112251", "11212252",
+ "22121341", "11221342", "12112342", "12121432", "21221431", "22112431",
+ "11212432", "22121521", "11221522", "12112522", "12121612", "21221611",
+ "12221161", "13112161", "13121251", "11312161", "11321251", "32121115",
+ "52121113", "21221116", "41221114", "61221112", "22112116", "42112114",
+ "31212115", "51212113", "13121116", "33121114", "22221115", "42221113",
+ "11321116", "31321114", "51321112", "23112115",
+ /* Column 22 */
+ "43112113", "12212116", "32212114", "52212112", "21312115", "41312113",
+ "61312111", "14121115", "34121113", "23221114", "43221112", "12321115",
+ "32321113", "52321111", "21421114", "41421112", "24112114", "13212115",
+ "33212113", "22312114", "42312112", "11412115", "31412113", "51412111",
+ "15121114", "24221113", "13321114", "33321112", "22421113", "42421111",
+ "11521114", "31521112", "25112113", "14212114", "34212112", "23312113",
+ "43312111", "12412114", "32412112", "21512113", "41512111", "16121113",
+ "25221112", "14321113", "34321111", "23421112", "12521113", "32521111",
+ "15212113", "24312112", "13412113", "33412111", "22512112", "11612113",
+ "31612111", "31131115", "51131113", "21122116",
+ /* Column 23 */
+ "41122114", "61122112", "31113115", "51113113", "12131116", "32131114",
+ "52131112", "21231115", "41231113", "61231111", "22122115", "42122113",
+ "11222116", "31222114", "51222112", "12113116", "32113114", "52113112",
+ "21213115", "41213113", "61213111", "13131115", "33131113", "22231114",
+ "42231112", "11331115", "31331113", "51331111", "23122114", "43122112",
+ "12222115", "32222113", "52222111", "21322114", "41322112", "13113115",
+ "33113113", "22213114", "42213112", "11313115", "31313113", "51313111",
+ "14131114", "34131112", "23231113", "43231111", "12331114", "32331112",
+ "21431113", "41431111", "24122113", "13222114", "33222112", "22322113",
+ "42322111", "11422114", "31422112", "14113114",
+ /* Column 24 */
+ "34113112", "23213113", "43213111", "12313114", "32313112", "21413113",
+ "41413111", "15131113", "24231112", "13331113", "33331111", "22431112",
+ "25122112", "14222113", "34222111", "23322112", "12422113", "32422111",
+ "21522112", "15113113", "24213112", "13313113", "33313111", "22413112",
+ "11513113", "31513111", "16131112", "25231111", "14331112", "23431111",
+ "15222112", "24322111", "13422112", "22522111", "16113112", "25213111",
+ "14313112", "23413111", "12513112", "21613111", "11141116", "31141114",
+ "51141112", "21132115", "41132113", "61132111", "11123116", "31123114",
+ "51123112", "21114115", "41114113", "61114111", "12141115", "32141113",
+ "52141111", "21241114", "41241112", "22132114",
+ /* Column 25 */
+ "42132112", "11232115", "31232113", "51232111", "12123115", "32123113",
+ "52123111", "21223114", "41223112", "22114114", "42114112", "11214115",
+ "31214113", "51214111", "13141114", "33141112", "22241113", "42241111",
+ "11341114", "31341112", "23132113", "43132111", "12232114", "32232112",
+ "21332113", "41332111", "13123114", "33123112", "22223113", "42223111",
+ "11323114", "31323112", "23114113", "43114111", "12214114", "32214112",
+ "21314113", "41314111", "14141113", "34141111", "23241112", "12341113",
+ "32341111", "24132112", "13232113", "33232111", "22332112", "11432113",
+ "31432111", "14123113", "34123111", "23223112", "12323113", "32323111",
+ "21423112", "24114112", "13214113", "33214111",
+ /* Column 26 */
+ "22314112", "11414113", "31414111", "15141112", "24241111", "13341112",
+ "25132111", "14232112", "23332111", "12432112", "15123112", "24223111",
+ "13323112", "22423111", "11523112", "25114111", "14214112", "23314111",
+ "12414112", "21514111", "16141111", "14341111", "15232111", "13432111",
+ "16123111", "14323111", "12523111", "15214111", "13414111", "11614111",
+ "11151115", "31151113", "51151111", "21142114", "41142112", "11133115",
+ "31133113", "51133111", "21124114", "41124112", "11115115", "31115113",
+ "51115111", "12151114", "32151112", "21251113", "41251111", "22142113",
+ "42142111", "11242114", "31242112", "12133114", "32133112", "21233113",
+ "41233111", "22124113", "42124111", "11224114",
+ /* Column 27 */
+ "31224112", "12115114", "32115112", "21215113", "41215111", "13151113",
+ "33151111", "22251112", "23142112", "12242113", "32242111", "21342112",
+ "13133113", "33133111", "22233112", "11333113", "31333111", "23124112",
+ "12224113", "32224111", "21324112", "13115113", "33115111", "22215112",
+ "11315113", "31315111", "14151112", "23251111", "24142111", "13242112",
+ "22342111", "14133112", "23233111", "12333112", "21433111", "24124111",
+ "13224112", "22324111", "11424112", "14115112", "23215111", "12315112",
+ "21415111", "15151111", "14242111", "15133111", "13333111", "14224111",
+ "12424111", "15115111", "13315111", "11515111", "11161114", "31161112",
+ "21152113", "41152111", "11143114", "31143112",
+ /* Column 28 */
+ "21134113", "41134111", "11125114", "31125112", "21116113", "41116111",
+ "12161113", "32161111", "22152112", "11252113", "31252111", "12143113",
+ "32143111", "21243112", "22134112", "11234113", "31234111", "12125113",
+ "32125111", "21225112", "22116112", "11216113", "31216111", "13161112",
+ "23152111", "12252112", "13143112", "22243111", "11343112", "23134111",
+ "12234112", "21334111", "13125112", "22225111", "11325112", "23116111",
+ "12216112", "21316111", "14161111", "13252111", "14143111", "12343111",
+ "13234111", "11434111", "14125111", "12325111", "13216111", "11416111",
+ "31111216", "51111214", "31211125", "51211123", "32111215", "52111213",
+ "21211216", "41211214", "61211212", "12211126",
+ /* Column 29 */
+ "32211124", "52211122", "21311125", "41311123", "61311121", "13111216",
+ "33111214", "22211215", "42211213", "11311216", "31311214", "51311212",
+ "13211125", "33211123", "22311124", "42311122", "11411125", "31411123",
+ "51411121", "14111215", "34111213", "23211214", "43211212", "12311215",
+ "32311213", "52311211", "21411214", "41411212", "14211124", "34211122",
+ "23311123", "43311121", "12411124", "32411122", "21511123", "41511121",
+ "15111214", "24211213", "13311214", "33311212", "22411213", "42411211",
+ "11511214", "31511212", "15211123", "24311122", "13411123", "33411121",
+ "22511122", "11611123", "31611121", "16111213", "25211212", "14311213",
+ "34311211", "23411212", "12511213", "32511211",
+ /* Column 30 */
+ "21611212", "21121126", "41121124", "61121122", "31112125", "51112123",
+ "31121215", "51121213", "21112216", "41112214", "61112212", "22121125",
+ "42121123", "11221126", "31221124", "51221122", "12112126", "32112124",
+ "52112122", "12121216", "32121214", "52121212", "21221215", "41221213",
+ "61221211", "22112215", "42112213", "11212216", "31212214", "51212212",
+ "23121124", "43121122", "12221125", "32221123", "52221121", "21321124",
+ "41321122", "13112125", "33112123", "13121215", "33121213", "11312125",
+ "22221214", "42221212", "11321215", "31321213", "51321211", "23112214",
+ "43112212", "12212215", "32212213", "52212211", "21312214", "41312212",
+ "24121123", "13221124", "33221122", "22321123",
+ /* Column 31 */
+ "42321121", "11421124", "31421122", "14112124", "34112122", "14121214",
+ "34121212", "12312124", "23221213", "43221211", "12321214", "32321212",
+ "21421213", "41421211", "24112213", "13212214", "33212212", "22312213",
+ "42312211", "11412214", "31412212", "25121122", "14221123", "34221121",
+ "23321122", "12421123", "32421121", "21521122", "15112123", "15121213",
+ "13312123", "24221212", "13321213", "33321211", "11512123", "22421212",
+ "11521213", "31521211", "25112212", "14212213", "34212211", "23312212",
+ "12412213", "32412211", "21512212", "15221122", "24321121", "13421122",
+ "22521121", "16112122", "16121212", "14312122", "25221211", "14321212",
+ "12512122", "23421211", "12521212", "15212212",
+ /* Column 32 */
+ "24312211", "13412212", "22512211", "11612212", "21131125", "41131123",
+ "61131121", "11122126", "31122124", "51122122", "11131216", "31131214",
+ "51131212", "21113125", "41113123", "61113121", "21122215", "41122213",
+ "61122211", "11113216", "31113214", "51113212", "22131124", "42131122",
+ "11231125", "31231123", "51231121", "12122125", "32122123", "52122121",
+ "12131215", "32131213", "52131211", "21231214", "41231212", "22113124",
+ "42113122", "11213125", "22122214", "42122212", "11222215", "31222213",
+ "51222211", "12113215", "32113213", "52113211", "21213214", "41213212",
+ "23131123", "43131121", "12231124", "32231122", "21331123", "41331121",
+ "13122124", "33122122", "13131214", "33131212",
+ /* Column 33 */
+ "11322124", "22231213", "42231211", "11331214", "31331212", "23113123",
+ "43113121", "12213124", "23122213", "43122211", "12222214", "32222212",
+ "21322213", "41322211", "13113214", "33113212", "22213213", "42213211",
+ "11313214", "31313212", "24131122", "13231123", "33231121", "22331122",
+ "11431123", "31431121", "14122123", "34122121", "14131213", "34131211",
+ "12322123", "23231212", "12331213", "32331211", "21431212", "24113122",
+ "13213123", "24122212", "13222213", "33222211", "11413123", "22322212",
+ "11422213", "31422211", "14113213", "34113211", "23213212", "12313213",
+ "32313211", "21413212", "25131121", "14231122", "23331121", "12431122",
+ "15122122", "15131212", "13322122", "24231211",
+ /* Column 34 */
+ "13331212", "11522122", "22431211", "25113121", "14213122", "25122211",
+ "14222212", "12413122", "23322211", "12422212", "21522211", "15113212",
+ "24213211", "13313212", "22413211", "11513212", "15231121", "13431121",
+ "16122121", "16131211", "14322121", "14331211", "12522121", "15213121",
+ "15222211", "13413121", "13422211", "11613121", "16113211", "14313211",
+ "12513211", "21141124", "41141122", "11132125", "31132123", "51132121",
+ "11141215", "31141213", "51141211", "21123124", "41123122", "21132214",
+ "41132212", "11114125", "31114123", "51114121", "11123215", "31123213",
+ "51123211", "21114214", "41114212", "22141123", "42141121", "11241124",
+ "31241122", "12132124", "32132122", "12141214",
+ /* Column 35 */
+ "32141212", "21241213", "41241211", "22123123", "42123121", "11223124",
+ "22132213", "42132211", "11232214", "31232212", "12114124", "32114122",
+ "12123214", "32123212", "21223213", "41223211", "22114213", "42114211",
+ "11214214", "31214212", "23141122", "12241123", "32241121", "21341122",
+ "13132123", "33132121", "13141213", "33141211", "11332123", "22241212",
+ "11341213", "31341211", "23123122", "12223123", "23132212", "12232213",
+ "32232211", "21332212", "13114123", "33114121", "13123213", "33123211",
+ "11314123", "22223212", "11323213", "31323211", "23114212", "12214213",
+ "32214211", "21314212", "24141121", "13241122", "22341121", "14132122",
+ "14141212", "12332122", "23241211", "12341212",
+ /* Column 36 */
+ "24123121", "13223122", "24132211", "13232212", "11423122", "22332211",
+ "11432212", "14114122", "14123212", "12314122", "23223211", "12323212",
+ "21423211", "24114211", "13214212", "22314211", "11414212", "14241121",
+ "15132121", "15141211", "13332121", "13341211", "14223121", "14232211",
+ "12423121", "12432211", "15114121", "15123211", "13314121", "13323211",
+ "11514121", "11523211", "14214211", "12414211", "21151123", "41151121",
+ "11142124", "31142122", "11151214", "31151212", "21133123", "41133121",
+ "21142213", "41142211", "11124124", "31124122", "11133214", "31133212",
+ "21115123", "41115121", "21124213", "41124211", "11115214", "31115212",
+ "22151122", "11251123", "31251121", "12142123",
+ /* Column 37 */
+ "32142121", "12151213", "32151211", "21251212", "22133122", "11233123",
+ "22142212", "11242213", "31242211", "12124123", "32124121", "12133213",
+ "32133211", "21233212", "22115122", "11215123", "22124212", "11224213",
+ "31224211", "12115213", "32115211", "21215212", "23151121", "12251122",
+ "13142122", "13151212", "11342122", "22251211", "23133121", "12233122",
+ "23142211", "12242212", "21342211", "13124122", "13133212", "11324122",
+ "22233211", "11333212", "23115121", "12215122", "23124211", "12224212",
+ "21324211", "13115212", "22215211", "11315212", "13251121", "14142121",
+ "14151211", "12342121", "13233121", "13242211", "11433121", "14124121",
+ "14133211", "12324121", "12333211", "13215121",
+ /* Column 38 */
+ "13224211", "11415121", "11424211", "14115211", "12315211", "21161122",
+ "11152123", "31152121", "11161213", "31161211", "21143122", "21152212",
+ "11134123", "31134121", "11143213", "31143211", "21125122", "21134212",
+ "11116123", "31116121", "11125213", "31125211", "22161121", "12152122",
+ "12161212", "22143121", "11243122", "22152211", "11252212", "12134122",
+ "12143212", "21243211", "22125121", "11225122", "22134211", "11234212",
+ "12116122", "12125212", "21225211", "13152121", "13161211", "12243121",
+ "12252211", "13134121", "13143211", "11334121", "11343211", "12225121",
+ "12234211", "13116121", "13125211", "11316121", "11325211", "21111226",
+ "41111224", "61111222", "31111315", "51111313",
+ /* Column 39 */
+ "21211135", "41211133", "61211131", "22111225", "42111223", "11211226",
+ "31211224", "51211222", "12111316", "32111314", "52111312", "21211315",
+ "41211313", "61211311", "22211134", "42211132", "11311135", "31311133",
+ "51311131", "23111224", "43111222", "12211225", "32211223", "52211221",
+ "21311224", "41311222", "13111315", "33111313", "22211314", "42211312",
+ "11311315", "31311313", "51311311", "23211133", "43211131", "12311134",
+ "32311132", "21411133", "41411131", "24111223", "13211224", "33211222",
+ "22311223", "42311221", "11411224", "31411222", "14111314", "34111312",
+ "23211313", "43211311", "12311314", "32311312", "21411313", "41411311",
+ "24211132", "13311133", "33311131", "22411132",
+ /* Column 40 */
+ "11511133", "31511131", "25111222", "14211223", "34211221", "23311222",
+ "12411223", "32411221", "21511222", "15111313", "24211312", "13311313",
+ "33311311", "22411312", "11511313", "31511311", "25211131", "14311132",
+ "23411131", "12511132", "21611131", "15211222", "24311221", "13411222",
+ "22511221", "11611222", "16111312", "25211311", "14311312", "23411311",
+ "12511312", "21611311", "31121134", "51121132", "21112135", "41112133",
+ "61112131", "21121225", "41121223", "61121221", "11112226", "31112224",
+ "51112222", "11121316", "31121314", "51121312", "21112315", "41112313",
+ "61112311", "12121135", "32121133", "52121131", "21221134", "41221132",
+ "22112134", "42112132", "11212135", "22121224",
+ /* Column 41 */
+ "42121222", "11221225", "31221223", "51221221", "12112225", "32112223",
+ "52112221", "12121315", "32121313", "52121311", "21221314", "41221312",
+ "22112314", "42112312", "11212315", "31212313", "51212311", "13121134",
+ "33121132", "22221133", "42221131", "11321134", "31321132", "23112133",
+ "43112131", "12212134", "23121223", "43121221", "12221224", "32221222",
+ "21321223", "41321221", "13112224", "33112222", "13121314", "33121312",
+ "11312224", "22221313", "42221311", "11321314", "31321312",
+ /* Column 42 */
+ "23112313", "43112311", "12212314", "32212312", "21312313", "41312311",
+ "14121133", "34121131", "23221132", "12321133", "32321131", "21421132",
+ "24112132", "13212133", "24121222", "13221223", "33221221", "11412133",
+ "22321222", "11421223", "31421221", "14112223", "34112221", "14121313",
+ "34121311", "12312223", "23221312", "12321313", "32321311", "21421312",
+ "24112312", "13212313", "33212311", "22312312", "11412313", "31412311",
+ "15121132", "24221131", "13321132", "22421131"
+ };
+
+ private String[] c49_appxe_odd = {
+ /* Appendix E - Code 49 Encodation Patterns (Odd Symbol Character Parity) */
+ /* Column 1 */
+ "22121116", "42121114", "31221115", "51221113", "32112115", "52112113",
+ "21212116", "41212114", "61212112", "23121115", "43121113", "12221116",
+ "32221114", "52221112", "21321115", "41321113", "61321111", "13112116",
+ "33112114", "22212115", "42212113", "11312116", "31312114", "51312112",
+ "24121114", "13221115", "33221113", "22321114", "42321112", "11421115",
+ "31421113", "51421111", "14112115", "34112113", "23212114", "43212112",
+ "12312115", "32312113", "52312111", "21412114", "41412112", "25121113",
+ "14221114", "34221112", "23321113", "43321111", "12421114", "32421112",
+ "21521113", "41521111", "15112114", "24212113", "13312114", "33312112",
+ "22412113", "42412111", "11512114", "31512112",
+ /* Column 2 */
+ "15221113", "24321112", "13421113", "33421111", "22521112", "16112113",
+ "25212112", "14312113", "34312111", "23412112", "12512113", "32512111",
+ "21612112", "21131116", "41131114", "61131112", "31122115", "51122113",
+ "21113116", "41113114", "61113112", "22131115", "42131113", "11231116",
+ "31231114", "51231112", "12122116", "32122114", "52122112", "21222115",
+ "41222113", "61222111", "22113115", "42113113", "11213116", "31213114",
+ "51213112", "23131114", "43131112", "12231115", "32231113", "52231111",
+ "21331114", "41331112", "13122115", "33122113", "22222114", "42222112",
+ "11322115", "31322113", "51322111", "23113114", "43113112", "12213115",
+ "32213113", "52213111", "21313114", "41313112",
+ /* Column 3 */
+ "24131113", "13231114", "33231112", "22331113", "42331111", "11431114",
+ "31431112", "14122114", "34122112", "23222113", "43222111", "12322114",
+ "32322112", "21422113", "41422111", "24113113", "13213114", "33213112",
+ "22313113", "42313111", "11413114", "31413112", "25131112", "14231113",
+ "34231111", "23331112", "12431113", "32431111", "15122113", "24222112",
+ "13322113", "33322111", "22422112", "11522113", "31522111", "25113112",
+ "14213113", "34213111", "23313112", "12413113", "32413111", "21513112",
+ "15231112", "24331111", "13431112", "16122112", "25222111", "14322112",
+ "23422111", "12522112", "15213112", "24313111", "13413112", "22513111",
+ "11613112", "21141115", "41141113", "61141111",
+ /* Column 4 */
+ "11132116", "31132114", "51132112", "21123115", "41123113", "61123111",
+ "11114116", "31114114", "51114112", "22141114", "42141112", "11241115",
+ "31241113", "51241111", "12132115", "32132113", "52132111", "21232114",
+ "41232112", "22123114", "42123112", "11223115", "31223113", "51223111",
+ "12114115", "32114113", "52114111", "21214114", "41214112", "23141113",
+ "43141111", "12241114", "32241112", "21341113", "41341111", "13132114",
+ "33132112", "22232113", "42232111", "11332114", "31332112", "23123113",
+ "43123111", "12223114", "32223112", "21323113", "41323111", "13114114",
+ "33114112", "22214113", "42214111", "11314114", "31314112", "24141112",
+ "13241113", "33241111", "22341112", "14132113",
+ /* Column 5 */
+ "34132111", "23232112", "12332113", "32332111", "21432112", "24123112",
+ "13223113", "33223111", "22323112", "11423113", "31423111", "14114113",
+ "34114111", "23214112", "12314113", "32314111", "21414112", "25141111",
+ "14241112", "23341111", "15132112", "24232111", "13332112", "22432111",
+ "25123111", "14223112", "23323111", "12423112", "21523111", "15114112",
+ "24214111", "13314112", "22414111", "11514112", "15241111", "16132111",
+ "14332111", "15223111", "13423111", "16114111", "14314111", "12514111",
+ "21151114", "41151112", "11142115", "31142113", "51142111", "21133114",
+ "41133112", "11124115", "31124113", "51124111", "21115114", "41115112",
+ "22151113", "42151111", "11251114", "31251112",
+ /* Column 6 */
+ "12142114", "32142112", "21242113", "41242111", "22133113", "42133111",
+ "11233114", "31233112", "12124114", "32124112", "21224113", "41224111",
+ "22115113", "42115111", "11215114", "31215112", "23151112", "12251113",
+ "32251111", "13142113", "33142111", "22242112", "11342113", "31342111",
+ "23133112", "12233113", "32233111", "21333112", "13124113", "33124111",
+ "22224112", "11324113", "31324111", "23115112", "12215113", "32215111",
+ "21315112", "24151111", "13251112", "14142112", "23242111", "12342112",
+ "24133111", "13233112", "22333111", "11433112", "14124112", "23224111",
+ "12324112", "21424111", "24115111", "13215112", "22315111", "11415112",
+ "14251111", "15142111", "13342111", "14233111",
+ /* Column 7 */
+ "12433111", "15124111", "13324111", "11524111", "14215111", "12415111",
+ "21161113", "41161111", "11152114", "31152112", "21143113", "41143111",
+ "11134114", "31134112", "21125113", "41125111", "11116114", "31116112",
+ "22161112", "12152113", "32152111", "21252112", "22143112", "11243113",
+ "31243111", "12134113", "32134111", "21234112", "22125112", "11225113",
+ "31225111", "12116113", "32116111", "21216112", "23161111", "13152112",
+ "22252111", "23143111", "12243112", "21343111", "13134112", "22234111",
+ "11334112", "23125111", "12225112", "21325111", "13116112", "22216111",
+ "11316112", "14152111", "13243111", "14134111", "12334111", "13225111",
+ "11425111", "14116111", "12316111", "41111215",
+ /* Column 8 */
+ "61111213", "21211126", "41211124", "61211122", "22111216", "42111214",
+ "31211215", "51211213", "22211125", "42211123", "11311126", "31311124",
+ "51311122", "23111215", "43111213", "12211216", "32211214", "52211212",
+ "21311215", "41311213", "61311211", "23211124", "43211122", "12311125",
+ "32311123", "52311121", "21411124", "41411122", "24111214", "13211215",
+ "33211213", "22311214", "42311212", "11411215", "31411213", "51411211",
+ "24211123", "13311124", "33311122", "22411123", "42411121", "11511124",
+ "31511122", "25111213", "14211214", "34211212", "23311213", "43311211",
+ "12411214", "32411212", "21511213", "41511211", "25211122", "14311123",
+ "34311121", "23411122", "12511123", "32511121",
+ /* Column 9 */
+ "21611122", "15211213", "24311212", "13411213", "33411211", "22511212",
+ "11611213", "31611211", "31121125", "51121123", "21112126", "41112124",
+ "61112122", "21121216", "41121214", "61121212", "31112215", "51112213",
+ "12121126", "32121124", "52121122", "21221125", "41221123", "61221121",
+ "22112125", "42112123", "11212126", "22121215", "42121213", "11221216",
+ "31221214", "51221212", "12112216", "32112214", "52112212", "21212215",
+ "41212213", "61212211", "13121125", "33121123", "22221124", "42221122",
+ "11321125", "31321123", "51321121", "23112124", "43112122", "12212125",
+ "23121214", "43121212", "12221215", "32221213", "52221211", "21321214",
+ "41321212", "13112215", "33112213", "22212214",
+ /* Column 10 */
+ "42212212", "11312215", "31312213", "51312211", "14121124", "34121122",
+ "23221123", "43221121", "12321124", "32321122", "21421123", "41421121",
+ "24112123", "13212124", "24121213", "13221214", "33221212", "11412124",
+ "22321213", "42321211", "11421214", "31421212", "14112214", "34112212",
+ "23212213", "43212211", "12312214", "32312212", "21412213", "41412211",
+ "15121123", "24221122", "13321123", "33321121", "22421122", "11521123",
+ "31521121", "25112122", "14212123", "25121212", "14221213", "34221211",
+ "12412123", "23321212", "12421213", "32421211", "21521212", "15112213",
+ "24212212", "13312213", "33312211", "22412212", "11512213", "31512211",
+ "16121122", "25221121", "14321122", "23421121",
+ /* Column 11 */
+ "12521122", "15212122", "15221212", "13412122", "24321211", "13421212",
+ "11612122", "22521211", "16112212", "25212211", "14312212", "23412211",
+ "12512212", "21612211", "11131126", "31131124", "51131122", "21122125",
+ "41122123", "61122121", "21131215", "41131213", "61131211", "11113126",
+ "31113124", "51113122", "11122216", "31122214", "51122212", "21113215",
+ "41113213", "61113211", "12131125", "32131123", "52131121", "21231124",
+ "41231122", "22122124", "42122122", "11222125", "22131214", "42131212",
+ "11231215", "31231213", "51231211", "12113125", "32113123", "52113121",
+ "12122215", "32122213", "52122211", "21222214", "41222212", "22113214",
+ "42113212", "11213215", "31213213", "51213211",
+ /* Column 12 */
+ "13131124", "33131122", "22231123", "42231121", "11331124", "31331122",
+ "23122123", "43122121", "12222124", "23131213", "43131211", "12231214",
+ "32231212", "21331213", "41331211", "13113124", "33113122", "13122214",
+ "33122212", "11313124", "22222213", "42222211", "11322214", "31322212",
+ "23113213", "43113211", "12213214", "32213212", "21313213", "41313211",
+ "14131123", "34131121", "23231122", "12331123", "32331121", "21431122",
+ "24122122", "13222123", "24131212", "13231213", "33231211", "11422123",
+ "22331212", "11431213", "31431211", "14113123", "34113121", "14122213",
+ "34122211", "12313123", "23222212", "12322213", "32322211", "21422212",
+ "24113212", "13213213", "33213211", "22313212",
+ /* Column 13 */
+ "11413213", "31413211", "15131122", "24231121", "13331122", "22431121",
+ "25122121", "14222122", "25131211", "14231212", "12422122", "23331211",
+ "12431212", "15113122", "15122212", "13313122", "24222211", "13322212",
+ "11513122", "22422211", "11522212", "25113211", "14213212", "23313211",
+ "12413212", "21513211", "16131121", "14331121", "15222121", "15231211",
+ "13422121", "13431211", "16113121", "16122211", "14313121", "14322211",
+ "12513121", "12522211", "15213211", "13413211", "11613211", "11141125",
+ "31141123", "51141121", "21132124", "41132122", "21141214", "41141212",
+ "11123125", "31123123", "51123121", "11132215", "31132213", "51132211",
+ "21114124", "41114122", "21123214", "41123212",
+ /* Column 14 */
+ "11114215", "31114213", "51114211", "12141124", "32141122", "21241123",
+ "41241121", "22132123", "42132121", "11232124", "22141213", "42141211",
+ "11241214", "31241212", "12123124", "32123122", "12132214", "32132212",
+ "21232213", "41232211", "22114123", "42114121", "11214124", "22123213",
+ "42123211", "11223214", "31223212", "12114214", "32114212", "21214213",
+ "41214211", "13141123", "33141121", "22241122", "11341123", "31341121",
+ "23132122", "12232123", "23141212", "12241213", "32241211", "21341212",
+ "13123123", "33123121", "13132213", "33132211", "11323123", "22232212",
+ "11332213", "31332211", "23114122", "12214123", "23123212", "12223213",
+ "32223211", "21323212", "13114213", "33114211",
+ /* Column 15 */
+ "22214212", "11314213", "31314211", "14141122", "23241121", "12341122",
+ "24132121", "13232122", "24141211", "13241212", "11432122", "22341211",
+ "14123122", "14132212", "12323122", "23232211", "12332212", "21432211",
+ "24114121", "13214122", "24123211", "13223212", "11414122", "22323211",
+ "11423212", "14114212", "23214211", "12314212", "21414211", "15141121",
+ "13341121", "14232121", "14241211", "12432121", "15123121", "15132211",
+ "13323121", "13332211", "11523121", "14214121", "14223211", "12414121",
+ "12423211", "15114211", "13314211", "11514211", "11151124", "31151122",
+ "21142123", "41142121", "21151213", "41151211", "11133124", "31133122",
+ "11142214", "31142212", "21124123", "41124121",
+ /* Column 16 */
+ "21133213", "41133211", "11115124", "31115122", "11124214", "31124212",
+ "21115213", "41115211", "12151123", "32151121", "21251122", "22142122",
+ "11242123", "22151212", "11251213", "31251211", "12133123", "32133121",
+ "12142213", "32142211", "21242212", "22124122", "11224123", "22133212",
+ "11233213", "31233211", "12115123", "32115121", "12124213", "32124211",
+ "21224212", "22115212", "11215213", "31215211", "13151122", "22251121",
+ "23142121", "12242122", "23151211", "12251212", "13133122", "13142212",
+ "11333122", "22242211", "11342212", "23124121", "12224122", "23133211",
+ "12233212", "21333211", "13115122", "13124212", "11315122", "22224211",
+ "11324212", "23115211", "12215212", "21315211",
+ /* Column 17 */
+ "14151121", "13242121", "13251211", "14133121", "14142211", "12333121",
+ "12342211", "13224121", "13233211", "11424121", "11433211", "14115121",
+ "14124211", "12315121", "12324211", "13215211", "11415211", "11161123",
+ "31161121", "21152122", "21161212", "11143123", "31143121", "11152213",
+ "31152211", "21134122", "21143212", "11125123", "31125121", "11134213",
+ "31134211", "21116122", "21125212", "12161122", "22152121", "11252122",
+ "22161211", "12143122", "12152212", "21252211", "22134121", "11234122",
+ "22143211", "11243212", "12125122", "12134212", "21234211", "22116121",
+ "11216122", "22125211", "11225212", "13161121", "12252121", "13143121",
+ "13152211", "11343121", "12234121", "12243211",
+ /* Column 18 */
+ "13125121", "13134211", "11325121", "11334211", "12216121", "12225211",
+ "31111225", "51111223", "21111316", "41111314", "61111312", "31211134",
+ "51211132", "12111226", "32111224", "52111222", "21211225", "41211223",
+ "61211221", "22111315", "42111313", "11211316", "31211314", "51211312",
+ "12211135", "32211133", "52211131", "21311134", "41311132", "13111225",
+ "33111223", "22211224", "42211222", "11311225", "31311223", "51311221",
+ "23111314", "43111312", "12211315", "32211313", "52211311", "21311314",
+ "41311312", "13211134", "33211132", "22311133", "42311131", "11411134",
+ "31411132", "14111224", "34111222", "23211223", "43211221", "12311224",
+ "32311222", "21411223", "41411221", "24111313",
+ /* Column 19 */
+ "13211314", "33211312", "22311313", "42311311", "11411314", "31411312",
+ "14211133", "34211131", "23311132", "12411133", "32411131", "21511132",
+ "15111223", "24211222", "13311223", "33311221", "22411222", "11511223",
+ "31511221", "25111312", "14211313", "34211311", "23311312", "12411313",
+ "32411311", "21511312", "15211132", "24311131", "13411132", "22511131",
+ "11611132", "16111222", "25211221", "14311222", "23411221", "12511222",
+ "21611221", "15211312", "24311311", "13411312", "22511311", "11611312",
+ "21121135", "41121133", "61121131", "11112136", "31112134", "51112132",
+ "11121226", "31121224", "51121222", "21112225", "41112223", "61112221",
+ "21121315", "41121313", "61121311", "11112316",
+ /* Column 20 */
+ "31112314", "51112312", "22121134", "42121132", "11221135", "31221133",
+ "51221131", "12112135", "32112133", "52112131", "12121225", "32121223",
+ "52121221", "21221224", "41221222", "22112224", "42112222", "11212225",
+ "22121314", "42121312", "11221315", "31221313", "51221311", "12112315",
+ "32112313", "52112311", "21212314", "41212312", "23121133", "43121131",
+ "12221134", "32221132", "21321133", "41321131", "13112134", "33112132",
+ "13121224", "33121222", "11312134", "22221223", "42221221", "11321224",
+ "31321222", "23112223", "43112221", "12212224", "23121313", "43121311",
+ "12221314", "32221312", "21321313", "41321311", "13112314", "33112312",
+ "22212313", "42212311", "11312314", "31312312",
+ /* Column 21 */
+ "24121132", "13221133", "33221131", "22321132", "11421133", "31421131",
+ "14112133", "34112131", "14121223", "34121221", "12312133", "23221222",
+ "12321223", "32321221", "21421222", "24112222", "13212223", "24121312",
+ "13221313", "33221311", "11412223", "22321312", "11421313", "31421311",
+ "14112313", "34112311", "23212312", "12312313", "32312311", "21412312",
+ "25121131", "14221132", "23321131", "12421132", "21521131", "15112132",
+ "15121222", "13312132", "24221221", "13321222", "11512132", "22421221",
+ "11521222", "25112221", "14212222", "25121311", "14221312", "12412222",
+ "23321311", "12421312", "21521311", "15112312", "24212311", "13312312",
+ "22412311", "11512312", "15221131", "13421131",
+ /* Column 22 */
+ "16112131", "16121221", "14312131", "14321221", "12512131", "12521221",
+ "15212221", "15221311", "13412221", "13421311", "11612221", "16112311",
+ "14312311", "12512311", "21131134", "41131132", "11122135", "31122133",
+ "51122131", "11131225", "31131223", "51131221", "21113134", "41113132",
+ "21122224", "41122222", "21131314", "41131312", "11113225", "31113223",
+ "51113221", "11122315", "31122313", "51122311", "21113314", "41113312",
+ "22131133", "42131131", "11231134", "31231132", "12122134", "32122132",
+ "12131224", "32131222", "21231223", "41231221", "22113133", "42113131",
+ "11213134", "22122223", "42122221", "11222224", "22131313", "42131311",
+ "11231314", "31231312", "12113224", "32113222",
+ /* Column 23 */
+ "12122314", "32122312", "21222313", "41222311", "22113313", "42113311",
+ "11213314", "31213312", "23131132", "12231133", "32231131", "21331132",
+ "13122133", "33122131", "13131223", "33131221", "11322133", "22231222",
+ "11331223", "31331221", "23113132", "12213133", "23122222", "12222223",
+ "23131312", "12231313", "32231311", "21331312", "13113223", "33113221",
+ "13122313", "33122311", "11313223", "22222312", "11322313", "31322311",
+ "23113312", "12213313", "32213311", "21313312", "24131131", "13231132",
+ "22331131", "11431132", "14122132", "14131222", "12322132", "23231221",
+ "12331222", "21431221", "24113131", "13213132", "24122221", "13222222",
+ "24131311", "11413132", "13231312", "11422222",
+ /* Column 24 */
+ "22331311", "11431312", "14113222", "14122312", "12313222", "23222311",
+ "12322312", "21422311", "24113311", "13213312", "22313311", "11413312",
+ "14231131", "12431131", "15122131", "15131221", "13322131", "13331221",
+ "11522131", "14213131", "14222221", "12413131", "14231311", "12422221",
+ "12431311", "15113221", "15122311", "13313221", "13322311", "11513221",
+ "11522311", "14213311", "12413311", "21141133", "41141131", "11132134",
+ "31132132", "11141224", "31141222", "21123133", "41123131", "21132223",
+ "41132221", "21141313", "41141311", "11114134", "31114132", "11123224",
+ "31123222", "11132314", "31132312", "21114223", "41114221", "21123313",
+ "41123311", "11114314", "31114312", "22141132",
+ /* Column 25 */
+ "11241133", "31241131", "12132133", "32132131", "12141223", "32141221",
+ "21241222", "22123132", "11223133", "22132222", "11232223", "22141312",
+ "11241313", "31241311", "12114133", "32114131", "12123223", "32123221",
+ "12132313", "32132311", "21232312", "22114222", "11214223", "22123312",
+ "11223313", "31223311", "12114313", "32114311", "21214312", "23141131",
+ "12241132", "21341131", "13132132", "13141222", "11332132", "22241221",
+ "11341222", "23123131", "12223132", "23132221", "12232222", "23141311",
+ "12241312", "21341311", "13114132", "13123222", "11314132", "13132312",
+ "11323222", "22232311", "11332312", "23114221", "12214222", "23123311",
+ "12223312", "21323311", "13114312", "22214311",
+ /* Column 26 */
+ "11314312", "13241131", "14132131", "14141221", "12332131", "12341221",
+ "13223131", "13232221", "11423131", "13241311", "11432221", "14114131",
+ "14123221", "12314131", "14132311", "12323221", "12332311", "13214221",
+ "13223311", "11414221", "11423311", "14114311", "12314311", "21151132",
+ "11142133", "31142131", "11151223", "31151221", "21133132", "21142222",
+ "21151312", "11124133", "31124131", "11133223", "31133221", "11142313",
+ "31142311", "21115132", "21124222", "21133312", "11115223", "31115221",
+ "11124313", "31124311", "22151131", "11251132", "12142132", "12151222",
+ "21251221", "22133131", "11233132", "22142221", "11242222", "22151311",
+ "11251312", "12124132", "12133222", "12142312",
+ /* Column 27 */
+ "21242311", "22115131", "11215132", "22124221", "11224222", "22133311",
+ "11233312", "12115222", "12124312", "21224311", "12251131", "13142131",
+ "13151221", "11342131", "12233131", "12242221", "12251311", "13124131",
+ "13133221", "11324131", "13142311", "11333221", "11342311", "12215131",
+ "12224221", "12233311", "13115221", "13124311", "11315221", "11324311",
+ "21161131", "11152132", "11161222", "21143131", "21152221", "21161311",
+ "11134132", "11143222", "11152312", "21125131", "21134221", "21143311",
+ "11116132", "11125222", "11134312", "12152131", "12161221", "11243131",
+ "11252221", "12134131", "12143221", "12152311", "11225131", "11234221",
+ "11243311", "12116131", "12125221", "12134311",
+ /* Column 28 */
+ "21111235", "41111233", "61111231", "11111326", "31111324", "51111322",
+ "21111415", "41111413", "61111411", "21211144", "41211142", "22111234",
+ "42111232", "11211235", "31211233", "51211231", "12111325", "32111323",
+ "52111321", "21211324", "41211322", "22111414", "42111412", "11211415",
+ "31211413", "51211411", "22211143", "42211141", "11311144", "31311142",
+ "23111233", "43111231", "12211234", "32211232", "21311233", "41311231",
+ "13111324", "33111322", "22211323", "42211321", "11311324", "31311322",
+ "23111413", "43111411", "12211414", "32211412", "21311413", "41311411",
+ "23211142", "12311143", "32311141", "21411142", "24111232", "13211233",
+ "33211231", "22311232", "11411233", "31411231",
+ /* Column 29 */
+ "14111323", "34111321", "23211322", "12311323", "32311321", "21411322",
+ "24111412", "13211413", "33211411", "22311412", "11411413", "31411411",
+ "24211141", "13311142", "22411141", "11511142", "25111231", "14211232",
+ "23311231", "12411232", "21511231", "15111322", "24211321", "13311322",
+ "22411321", "11511322", "25111411", "14211412", "23311411", "12411412",
+ "21511411", "14311141", "12511141", "15211231", "13411231", "11611231",
+ "16111321", "14311321", "12511321", "15211411", "13411411", "11611411",
+ "31121143", "51121141", "21112144", "41112142", "21121234", "41121232",
+ "11112235", "31112233", "51112231", "11121325", "31121323", "51121321",
+ "21112324", "41112322", "21121414", "41121412",
+ /* Column 30 */
+ "11112415", "31112413", "51112411", "12121144", "32121142", "21221143",
+ "41221141", "22112143", "42112141", "11212144", "22121233", "42121231",
+ "11221234", "31221232", "12112234", "32112232", "12121324", "32121322",
+ "21221323", "41221321", "22112323", "42112321", "11212324", "22121413",
+ "42121411", "11221414", "31221412", "12112414", "32112412", "21212413",
+ "41212411", "13121143", "33121141", "22221142", "11321143", "31321141",
+ "23112142", "12212143", "23121232", "12221233", "32221231", "21321232",
+ "13112233", "33112231", "13121323", "33121321", "11312233", "22221322",
+ "11321323", "31321321", "23112322", "12212323", "23121412", "12221413",
+ "32221411", "21321412", "13112413", "33112411",
+ /* Column 31 */
+ "22212412", "11312413", "31312411", "14121142", "23221141", "12321142",
+ "21421141", "24112141", "13212142", "24121231", "13221232", "11412142",
+ "22321231", "11421232", "14112232", "14121322", "12312232", "23221321",
+ "12321322", "21421321", "24112321", "13212322", "24121411", "13221412",
+ "11412322", "22321411", "11421412", "14112412", "23212411", "12312412",
+ "21412411", "15121141", "13321141", "11521141", "14212141", "14221231",
+ "12412141", "12421231", "15112231", "15121321", "13312231", "13321321",
+ "11512231", "11521321", "14212321", "14221411", "12412321", "12421411",
+ "15112411", "13312411", "11512411", "11131144", "31131142", "21122143",
+ "41122141", "21131233", "41131231", "11113144",
+ /* Column 32 */
+ "31113142", "11122234", "31122232", "11131324", "31131322", "21113233",
+ "41113231", "21122323", "41122321", "21131413", "41131411", "11113324",
+ "31113322", "11122414", "31122412", "21113413", "41113411", "12131143",
+ "32131141", "21231142", "22122142", "11222143", "22131232", "11231233",
+ "31231231", "12113143", "32113141", "12122233", "32122231", "12131323",
+ "32131321", "21231322", "22113232", "11213233", "22122322", "11222323",
+ "22131412", "11231413", "31231411", "12113323", "32113321", "12122413",
+ "32122411", "21222412", "22113412", "11213413", "31213411", "13131142",
+ "22231141", "11331142", "23122141", "12222142", "23131231", "12231232",
+ "21331231", "13113142", "13122232", "11313142",
+ /* Column 33 */
+ "13131322", "11322232", "22231321", "11331322", "23113231", "12213232",
+ "23122321", "12222322", "23131411", "12231412", "21331411", "13113322",
+ "13122412", "11313322", "22222411", "11322412", "23113411", "12213412",
+ "21313411", "14131141", "12331141", "13222141", "13231231", "11422141",
+ "11431231", "14113141", "14122231", "12313141", "14131321", "12322231",
+ "12331321", "13213231", "13222321", "11413231", "13231411", "11422321",
+ "11431411", "14113321", "14122411", "12313321", "12322411", "13213411",
+ "11413411", "11141143", "31141141", "21132142", "21141232", "11123143",
+ "31123141", "11132233", "31132231", "11141323", "31141321", "21114142",
+ "21123232", "21132322", "21141412", "11114233",
+ /* Column 34 */
+ "31114231", "11123323", "31123321", "11132413", "31132411", "21114322",
+ "21123412", "12141142", "21241141", "22132141", "11232142", "22141231",
+ "11241232", "12123142", "12132232", "12141322", "21241321", "22114141",
+ "11214142", "22123231", "11223232", "22132321", "11232322", "22141411",
+ "11241412", "12114232", "12123322", "12132412", "21232411", "22114321",
+ "11214322", "22123411", "11223412", "13141141", "11341141", "12232141",
+ "12241231", "13123141", "13132231", "11323141", "13141321", "11332231",
+ "11341321", "12214141", "12223231", "12232321", "12241411", "13114231",
+ "13123321", "11314231", "13132411", "11323321", "11332411", "12214321",
+ "12223411", "11151142", "21142141", "21151231",
+ /* Column 35 */
+ "11133142", "11142232", "11151322", "21124141", "21133231", "21142321",
+ "21151411", "11115142", "11124232", "11133322", "11142412", "21115231",
+ "21124321", "21133411", "12151141", "11242141", "11251231", "12133141",
+ "12142231", "12151321", "11224141", "11233231", "11242321", "11251411",
+ "12115141", "12124231", "12133321", "12142411", "11215231", "11224321",
+ "11233411", "11161141", "11143141", "11152231", "11161321", "11125141",
+ "11134231", "11143321", "11152411", "11111245", "31111243", "51111241",
+ "21111334", "41111332", "11111425", "31111423", "51111421", "21111514",
+ "41111512", "31211152", "12111244", "32111242", "21211243", "41211241",
+ "22111333", "42111331", "11211334", "31211332",
+ /* Column 36 */
+ "12111424", "32111422", "21211423", "41211421", "22111513", "42111511",
+ "11211514", "31211512", "12211153", "32211151", "21311152", "13111243",
+ "33111241", "22211242", "11311243", "31311241", "23111332", "12211333",
+ "32211331", "21311332", "13111423", "33111421", "22211422", "11311423",
+ "31311421", "23111512", "12211513", "32211511", "21311512", "13211152",
+ "22311151", "11411152", "14111242", "23211241", "12311242", "21411241",
+ "24111331", "13211332", "22311331", "11411332", "14111422", "23211421",
+ "12311422", "21411421", "24111511", "13211512", "22311511", "11411512",
+ "14211151", "12411151", "15111241", "13311241", "11511241", "14211331",
+ "12411331", "15111421", "13311421", "11511421",
+ /* Column 37 */
+ "14211511", "12411511", "21121153", "41121151", "11112154", "31112152",
+ "11121244", "31121242", "21112243", "41112241", "21121333", "41121331",
+ "11112334", "31112332", "11121424", "31121422", "21112423", "41112421",
+ "21121513", "41121511", "11112514", "31112512", "22121152", "11221153",
+ "31221151", "12112153", "32112151", "12121243", "32121241", "21221242",
+ "22112242", "11212243", "22121332", "11221333", "31221331", "12112333",
+ "32112331", "12121423", "32121421", "21221422", "22112422", "11212423",
+ "22121512", "11221513", "31221511", "12112513", "32112511", "21212512",
+ "23121151", "12221152", "21321151", "13112152", "13121242", "11312152",
+ "22221241", "11321242", "23112241", "12212242",
+ /* Column 38 */
+ "23121331", "12221332", "21321331", "13112332", "13121422", "11312332",
+ "22221421", "11321422", "23112421", "12212422", "23121511", "12221512",
+ "21321511", "13112512", "22212511", "11312512", "13221151", "11421151",
+ "14112151", "14121241", "12312151", "12321241", "13212241", "13221331",
+ "11412241", "11421331", "14112331", "14121421", "12312331", "12321421",
+ "13212421", "13221511", "11412421", "11421511", "14112511", "12312511",
+ "21131152", "11122153", "31122151", "11131243", "31131241", "21113152",
+ "21122242", "21131332", "11113243", "31113241", "11122333", "31122331",
+ "11131423", "31131421", "21113332", "21122422", "21131512", "11113423",
+ "31113421", "11122513", "31122511", "22131151",
+ /* Column 39 */
+ "11231152", "12122152", "12131242", "21231241", "22113151", "11213152",
+ "22122241", "11222242", "22131331", "11231332", "12113242", "12122332",
+ "12131422", "21231421", "22113331", "11213332", "22122421", "11222422",
+ "22131511", "11231512", "12113422", "12122512", "21222511", "12231151",
+ "13122151", "13131241", "11322151", "11331241", "12213151", "12222241",
+ "12231331", "13113241", "13122331", "11313241", "13131421", "11322331",
+ "11331421", "12213331", "12222421", "12231511", "13113421", "13122511",
+ "11313421", "11322511", "21141151", "11132152", "11141242", "21123151",
+ "21132241", "21141331", "11114152", "11123242", "11132332", "11141422",
+ "21114241", "21123331", "21132421", "21141511",
+ /* Column 40 */
+ "11114332", "11123422", "11132512", "11241151", "12132151", "12141241",
+ "11223151", "11232241", "11241331", "12114151", "12123241", "12132331",
+ "12141421", "11214241", "11223331", "11232421", "11241511", "12114331",
+ "12123421", "12132511", "11142151", "11151241", "11124151", "11133241",
+ "11142331", "11151421", "11115241", "11124331", "11133421", "11142511",
+ "21111253", "41111251", "11111344", "31111342", "21111433", "41111431",
+ "11111524", "31111522", "21111613", "41111611", "21211162", "22111252",
+ "11211253", "31211251", "12111343", "32111341", "21211342", "22111432",
+ "11211433", "31211431", "12111523", "32111521", "21211522", "22111612",
+ "11211613", "31211611", "22211161", "11311162",
+ /* Column 41 */
+ "23111251", "12211252", "21311251", "13111342", "22211341", "11311342",
+ "23111431", "12211432", "21311431", "13111522", "22211521", "11311522",
+ "23111611", "12211612", "21311611", "12311161", "13211251", "11411251",
+ "14111341", "12311341", "13211431", "11411431", "14111521", "12311521",
+ "13211611", "11411611", "31121161", "21112162", "21121252", "11112253",
+ "31112251", "11121343", "31121341", "21112342", "21121432", "11112433",
+ "31112431", "11121523", "31121521", "21112522", "21121612",
+ /* Column 42 */
+ "12121162", "21221161", "22112161", "11212162", "22121251", "11221252",
+ "12112252", "12121342", "21221341", "22112341", "11212342", "22121431",
+ "11221432", "12112432", "12121522", "21221521", "22112521", "11212522",
+ "22121611", "11221612", "13121161", "11321161", "12212161", "12221251",
+ "13112251", "13121341", "11312251", "11321341", "12212341", "12221431",
+ "13112431", "13121521", "11312431", "11321521", "12212521", "12221611",
+ "11131162", "21122161", "21131251", "11113162"
+ };
+
+ private char[] C49_Set = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
+ 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
+ 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '-', '.', ' ', '$', '/', '+',
+ '%', '!', '&', '*'
+ };
+
+ @Override
+ public boolean encode() {
+ int length = content.length();
+ int i, codeword_count = 0, h, j, M, rows, pad_count = 0;
+ int x_count, y_count, z_count, posn_val, local_value;
+ StringBuilder intermediate = new StringBuilder();
+ StringBuilder localpattern;
+ int[] codewords = new int[170];
+ int[][] c_grid = new int[8][8];
+ int[][] w_grid = new int[8][4];
+
+ if (!content.matches("[\u0000-\u007F]+")) {
+ errorMsg.append("Invalid characters in input data");
+ return false;
+ }
+
+ if (inputDataType == DataType.GS1) {
+ intermediate.append("*"); // FNC1
+ }
+ for (i = 0; i < length; i++) {
+ if (content.charAt(i) > 127) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+ if ((inputDataType == DataType.GS1) && (content.charAt(i) == '[')) {
+ intermediate.append("*"); // FNC1
+ } else {
+ intermediate.append(c49_table7[content.charAt(i)]);
+ }
+ }
+
+ h = intermediate.length();
+
+ i = 0;
+ do {
+ if ((intermediate.charAt(i) >= '0') && (intermediate.charAt(i) <= '9')) {
+
+ /* Numeric data */
+ int latch = 0;
+ j = 0;
+ do {
+ if ((i + j) >= h) {
+ latch = 1;
+ } else {
+ if ((intermediate.charAt(i + j) >= '0') && (intermediate.charAt(i + j) <= '9')) {
+ j++;
+ } else {
+ latch = 1;
+ }
+ }
+ } while (latch == 0);
+ if (j >= 5) {
+ /* Use Numeric Encodation Method */
+ int block_count, c;
+ int block_remain;
+ int block_value;
+
+ codewords[codeword_count] = 48; /* Numeric Shift */
+ codeword_count++;
+
+ block_count = j / 5;
+ block_remain = j % 5;
+
+ for (c = 0; c < block_count; c++) {
+ if ((c == block_count - 1) && (block_remain == 2)) {
+ /* Rule (d) */
+ block_value = 100000;
+ block_value += (intermediate.charAt(i) - '0') * 1000;
+ block_value += (intermediate.charAt(i + 1) - '0') * 100;
+ block_value += (intermediate.charAt(i + 2) - '0') * 10;
+ block_value += intermediate.charAt(i + 3) - '0';
+
+ codewords[codeword_count] = block_value / (48 * 48);
+ block_value = block_value - (48 * 48) * codewords[codeword_count];
+ codeword_count++;
+ codewords[codeword_count] = block_value / 48;
+ block_value = block_value - 48 * codewords[codeword_count];
+ codeword_count++;
+ codewords[codeword_count] = block_value;
+ codeword_count++;
+ i += 4;
+ block_value = (intermediate.charAt(i) - '0') * 100;
+ block_value += (intermediate.charAt(i + 1) - '0') * 10;
+ block_value += intermediate.charAt(i + 2) - '0';
+
+ codewords[codeword_count] = block_value / 48;
+ block_value = block_value - 48 * codewords[codeword_count];
+ codeword_count++;
+ codewords[codeword_count] = block_value;
+ codeword_count++;
+ i += 3;
+ } else {
+ block_value = (intermediate.charAt(i) - '0') * 10000;
+ block_value += (intermediate.charAt(i + 1) - '0') * 1000;
+ block_value += (intermediate.charAt(i + 2) - '0') * 100;
+ block_value += (intermediate.charAt(i + 3) - '0') * 10;
+ block_value += intermediate.charAt(i + 4) - '0';
+
+ codewords[codeword_count] = block_value / (48 * 48);
+ block_value = block_value - (48 * 48) * codewords[codeword_count];
+ codeword_count++;
+ codewords[codeword_count] = block_value / 48;
+ block_value = block_value - 48 * codewords[codeword_count];
+ codeword_count++;
+ codewords[codeword_count] = block_value;
+ codeword_count++;
+ i += 5;
+ }
+ }
+
+ switch (block_remain) {
+ case 1:
+ /* Rule (a) */
+ codewords[codeword_count] = positionOf(intermediate.charAt(i), C49_Set);
+ codeword_count++;
+ i++;
+ break;
+ case 3:
+ /* Rule (b) */
+ block_value = (intermediate.charAt(i) - '0') * 100;
+ block_value += (intermediate.charAt(i + 1) - '0') * 10;
+ block_value += intermediate.charAt(i + 2) - '0';
+
+ codewords[codeword_count] = block_value / 48;
+ block_value = block_value - 48 * codewords[codeword_count];
+ codeword_count++;
+ codewords[codeword_count] = block_value;
+ codeword_count++;
+ i += 3;
+ break;
+ case 4:
+ /* Rule (c) */
+ block_value = 100000;
+ block_value += (intermediate.charAt(i) - '0') * 1000;
+ block_value += (intermediate.charAt(i + 1) - '0') * 100;
+ block_value += (intermediate.charAt(i + 2) - '0') * 10;
+ block_value += intermediate.charAt(i + 3) - '0';
+
+ codewords[codeword_count] = block_value / (48 * 48);
+ block_value = block_value - (48 * 48) * codewords[codeword_count];
+ codeword_count++;
+ codewords[codeword_count] = block_value / 48;
+ block_value = block_value - 48 * codewords[codeword_count];
+ codeword_count++;
+ codewords[codeword_count] = block_value;
+ codeword_count++;
+ i += 4;
+ break;
+ }
+ if (i < h) {
+ /* There is more to add */
+ codewords[codeword_count] = 48; /* Numeric Shift */
+ codeword_count++;
+ }
+ } else {
+ codewords[codeword_count] = positionOf(intermediate.charAt(i), C49_Set);
+ codeword_count++;
+ i++;
+ }
+ } else {
+ codewords[codeword_count] = positionOf(intermediate.charAt(i), C49_Set);
+ codeword_count++;
+ i++;
+ }
+ } while (i < h);
+
+ switch (codewords[0]) { /* Set starting mode value */
+ case 48:
+ M = 2;
+ break;
+ case 43:
+ M = 4;
+ break;
+ case 44:
+ M = 5;
+ break;
+ default:
+ M = 0;
+ break;
+ }
+
+ if (M != 0) {
+ for (i = 0; i < codeword_count; i++) {
+ codewords[i] = codewords[i + 1];
+ }
+ codeword_count--;
+ }
+
+ if (codeword_count > 49) {
+ errorMsg.append("Input too long");
+ return false;
+ }
+
+ encodeInfo.append("Starting Mode (M): ").append(M).append("\n");
+
+ /* Place codewords in code character array (c grid) */
+ rows = 0;
+ do {
+ for (i = 0; i < 7; i++) {
+ if (((rows * 7) + i) < codeword_count) {
+ c_grid[rows][i] = codewords[(rows * 7) + i];
+ } else {
+ c_grid[rows][i] = 48; /* Pad */
+ pad_count++;
+ }
+ }
+ rows++;
+ } while ((rows * 7) < codeword_count);
+
+ if ((((rows <= 6) && (pad_count < 5))) || (rows > 6) || (rows == 1)) {
+ /* Add a row */
+ for (i = 0; i < 7; i++) {
+ c_grid[rows][i] = 48; /* Pad */
+ }
+ rows++;
+ }
+
+ /* Add row count and mode character */
+ c_grid[rows - 1][6] = (7 * (rows - 2)) + M;
+
+ /* Add row check character */
+ for (i = 0; i < rows - 1; i++) {
+ int row_sum = 0;
+
+ for (j = 0; j < 7; j++) {
+ row_sum += c_grid[i][j];
+ }
+ c_grid[i][7] = row_sum % 49;
+ }
+
+ /* Calculate Symbol Check Characters */
+ posn_val = 0;
+ x_count = c_grid[rows - 1][6] * 20;
+ y_count = c_grid[rows - 1][6] * 16;
+ z_count = c_grid[rows - 1][6] * 38;
+ for (i = 0; i < rows - 1; i++) {
+ for (j = 0; j < 4; j++) {
+ local_value = (c_grid[i][2 * j] * 49) + c_grid[i][(2 * j) + 1];
+ x_count += c49_x_weight[posn_val] * local_value;
+ y_count += c49_y_weight[posn_val] * local_value;
+ z_count += c49_z_weight[posn_val] * local_value;
+ posn_val++;
+ }
+ }
+
+ if (rows > 6) {
+ /* Add Z Symbol Check */
+ c_grid[rows - 1][0] = (z_count % 2401) / 49;
+ c_grid[rows - 1][1] = (z_count % 2401) % 49;
+ }
+
+ local_value = (c_grid[rows - 1][0] * 49) + c_grid[rows - 1][1];
+ x_count += c49_x_weight[posn_val] * local_value;
+ y_count += c49_y_weight[posn_val] * local_value;
+ posn_val++;
+
+ /* Add Y Symbol Check */
+ c_grid[rows - 1][2] = (y_count % 2401) / 49;
+ c_grid[rows - 1][3] = (y_count % 2401) % 49;
+
+ local_value = (c_grid[rows - 1][2] * 49) + c_grid[rows - 1][3];
+ x_count += c49_x_weight[posn_val] * local_value;
+
+ /* Add X Symbol Check */
+ c_grid[rows - 1][4] = (x_count % 2401) / 49;
+ c_grid[rows - 1][5] = (x_count % 2401) % 49;
+
+ encodeInfo.append("Check Characters: ").append(Integer.toString(z_count % 2401)).append(" ").append(Integer.toString(y_count % 2401)).append("\n");
+
+ /* Add last row check character */
+ j = 0;
+ for (i = 0; i < 7; i++) {
+ j += c_grid[rows - 1][i];
+ }
+ c_grid[rows - 1][7] = j % 49;
+
+ encodeInfo.append("Codewords: ");
+ /* Transfer data to symbol character array (w grid) */
+ for (i = 0; i < rows; i++) {
+ for (j = 0; j < 4; j++) {
+ w_grid[i][j] = (c_grid[i][2 * j] * 49) + c_grid[i][(2 * j) + 1];
+ encodeInfo.append(Integer.toString(c_grid[i][2 * j])).append(" ").append(Integer.toString(c_grid[i][(2 * j) + 1])).append(" ");
+ }
+ }
+ encodeInfo.append("\n");
+
+ readable = new StringBuilder();
+ pattern = new String[rows];
+ rowCount = rows;
+ rowHeight = new int[rows];
+
+ encodeInfo.append("Symbol Characters: ");
+ for (i = 0; i < rows; i++) {
+ localpattern = new StringBuilder("11"); /* Start character */
+ for (j = 0; j < 4; j++) {
+ encodeInfo.append(Integer.toString(w_grid[i][j])).append(" ");
+ if (i != (rows - 1)) {
+ if (c49_table4[i].charAt(j) == 'E') {
+ /* Even Parity */
+ localpattern.append(c49_appxe_even[w_grid[i][j]]);
+ } else {
+ /* Odd Parity */
+ localpattern.append(c49_appxe_odd[w_grid[i][j]]);
+ }
+ } else {
+ /* Last row uses all even parity */
+ localpattern.append(c49_appxe_even[w_grid[i][j]]);
+ }
+ }
+ localpattern.append("4"); /* Stop character */
+
+ pattern[i] = localpattern.toString();
+ rowHeight[i] = 10;
+
+ }
+ encodeInfo.append("\n");
+ plotSymbol();
+ return true;
+ }
+
+ @Override
+ protected void plotSymbol() {
+ int xBlock, yBlock;
+ int x, y, w, h;
+ boolean black;
+ getRectangles().clear();
+ y = 1;
+ h = 1;
+ for (yBlock = 0; yBlock < rowCount; yBlock++) {
+ black = true;
+ x = 15;
+ for (xBlock = 0; xBlock < pattern[yBlock].length(); xBlock++) {
+ if (black) {
+ black = false;
+ w = pattern[yBlock].charAt(xBlock) - '0';
+ if (rowHeight[yBlock] == -1) {
+ h = defaultHeight;
+ } else {
+ h = rowHeight[yBlock];
+ }
+ if (w != 0 && h != 0) {
+ Rectangle2D.Double rect = new Rectangle2D.Double(x, y, w, h);
+ getRectangles().add(rect);
+ }
+ if ((x + w) > symbolWidth) {
+ symbolWidth = x + w;
+ }
+ } else {
+ black = true;
+ }
+ x += (double) (pattern[yBlock].charAt(xBlock) - '0');
+ }
+ y += h;
+ if ((y + h) > symbolHeight) {
+ symbolHeight = y + h;
+ }
+ /* Add bars between rows */
+ if (yBlock != (rowCount - 1)) {
+ Rectangle2D.Double rect = new Rectangle2D.Double(15, y - 1, (symbolWidth - 15), 2);
+ getRectangles().add(rect);
+ }
+ }
+ Rectangle2D.Double top = new Rectangle2D.Double(0, 0, (symbolWidth + 15), 2);
+ getRectangles().add(top);
+ Rectangle2D.Double bottom = new Rectangle2D.Double(0, y - 1, (symbolWidth + 15), 2);
+ getRectangles().add(bottom);
+ symbolWidth += 30;
+ symbolHeight += 2;
+ mergeVerticalBlocks();
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/Code93.java b/barcode/src/main/java/org/xbib/graphics/barcode/Code93.java
new file mode 100755
index 0000000..a286650
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/Code93.java
@@ -0,0 +1,192 @@
+package org.xbib.graphics.barcode;
+
+/**
+ * Implements Code 93.
+ * Supports encoding of 7-bit ASCII text. Two check digits are added.
+ */
+public class Code93 extends Symbol {
+
+ /**
+ * Code 93 control characters, indexed by ASCII codes (NOTE: a = Ctrl $,
+ * b = Ctrl %, c = Ctrl /, d = Ctrl + for sequences of two characters).
+ */
+ private static final String[] CODE_93_CTRL = {
+ "bU", "aA", "aB", "aC", "aD", "aE", "aF", "aG", "aH", "aI",
+ "aJ", "aK", "aL", "aM", "aN", "aO", "aP", "aQ", "aR", "aS",
+ "aT", "aU", "aV", "aW", "aX", "aY", "aZ", "bA", "bB", "bC",
+ "bD", "bE", " ", "cA", "cB", "cC", "$", "%", "cF", "cG",
+ "cH", "cI", "cJ", "+", "cL", "-", ".", "/", "0", "1",
+ "2", "3", "4", "5", "6", "7", "8", "9", "cZ", "bF",
+ "bG", "bH", "bI", "bJ", "bV", "A", "B", "C", "D", "E",
+ "F", "G", "H", "I", "J", "K", "L", "M", "N", "O",
+ "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y",
+ "Z", "bK", "bL", "bM", "bN", "bO", "bW", "dA", "dB", "dC",
+ "dD", "dE", "dF", "dG", "dH", "dI", "dJ", "dK", "dL", "dM",
+ "dN", "dO", "dP", "dQ", "dR", "dS", "dT", "dU", "dV", "dW",
+ "dX", "dY", "dZ", "bP", "bQ", "bR", "bS", "bT"};
+
+ /**
+ * Mapping of control characters to pattern table index (NOTE: a = Ctrl $,
+ * b = Ctrl %, c = Ctrl /, d = Ctrl + for sequences of two characters).
+ */
+ private static final char[] CODE_93_LOOKUP = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+ 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+ 'U', 'V', 'W', 'X', 'Y', 'Z', '-', '.', ' ', '$',
+ '/', '+', '%', 'a', 'b', 'c', 'd'};
+
+ /**
+ * Code 93 pattern table.
+ */
+ private static final String[] CODE_93_TABLE = {
+ "131112", "111213", "111312", "111411", "121113",
+ "121212", "121311", "111114", "131211", "141111",
+ "211113", "211212", "211311", "221112", "221211",
+ "231111", "112113", "112212", "112311", "122112",
+ "132111", "111123", "111222", "111321", "121122",
+ "131121", "212112", "212211", "211122", "211221",
+ "221121", "222111", "112122", "112221", "122121",
+ "123111", "121131", "311112", "311211", "321111",
+ "112131", "113121", "211131", "121221", "312111",
+ "311121", "122211"};
+
+ /**
+ * Whether or not to show check digits in the human-readable text.
+ */
+ private boolean showCheckDigits = true;
+
+ /**
+ * Optional start/stop delimiter to be shown in the human-readable text.
+ */
+ private Character startStopDelimiter;
+
+ private static char[] toControlChars(String s) {
+ StringBuilder buffer = new StringBuilder();
+ char[] chars = s.toCharArray();
+ for (char asciiCode : chars) {
+ buffer.append(CODE_93_CTRL[asciiCode]);
+ }
+ return buffer.toString().toCharArray();
+ }
+
+ private static int calculateCheckDigitC(int[] values, int length) {
+ int c = 0;
+ int weight = 1;
+ for (int i = length - 1; i >= 0; i--) {
+ c += values[i] * weight;
+ weight++;
+ if (weight == 21) {
+ weight = 1;
+ }
+ }
+ c = c % 47;
+ return c;
+ }
+
+ private static int calculateCheckDigitK(int[] values, int length) {
+ int k = 0;
+ int weight = 1;
+ for (int i = length - 1; i >= 0; i--) {
+ k += values[i] * weight;
+ weight++;
+ if (weight == 16) {
+ weight = 1;
+ }
+ }
+ k = k % 47;
+ return k;
+ }
+
+ private static String toPattern(int[] values) {
+ StringBuilder buffer = new StringBuilder("111141");
+ for (int value : values) {
+ buffer.append(CODE_93_TABLE[value]);
+ }
+ buffer.append("1111411");
+ return buffer.toString();
+ }
+
+ /**
+ * Returns whether or not this symbol shows check digits in the human-readable text.
+ *
+ * @return whether or not this symbol shows check digits in the human-readable text
+ */
+ public boolean getShowCheckDigits() {
+ return showCheckDigits;
+ }
+
+ /**
+ * Sets whether or not to show check digits in the human-readable text (defaults to true).
+ *
+ * @param showCheckDigits whether or not to show check digits in the human-readable text
+ */
+ public void setShowCheckDigits(boolean showCheckDigits) {
+ this.showCheckDigits = showCheckDigits;
+ }
+
+ /**
+ * Returns the optional start/stop delimiter to be shown in the human-readable text.
+ *
+ * @return the optional start/stop delimiter to be shown in the human-readable text
+ */
+ public Character getStartStopDelimiter() {
+ return startStopDelimiter;
+ }
+
+ /**
+ * Sets an optional start/stop delimiter to be shown in the human-readable text (defaults to null).
+ *
+ * @param startStopDelimiter an optional start/stop delimiter to be shown in the human-readable text
+ */
+ public void setStartStopDelimiter(Character startStopDelimiter) {
+ this.startStopDelimiter = startStopDelimiter;
+ }
+
+ @Override
+ public boolean encode() {
+
+ char[] controlChars = toControlChars(content);
+ int l = controlChars.length;
+
+ if (!content.matches("[\u0000-\u007F]+")) {
+ errorMsg.append("Invalid characters in input data");
+ return false;
+ }
+
+ int[] values = new int[controlChars.length + 2];
+ for (int i = 0; i < l; i++) {
+ values[i] = positionOf(controlChars[i], CODE_93_LOOKUP);
+ }
+
+ int c = calculateCheckDigitC(values, l);
+ values[l] = c;
+ l++;
+
+ int k = calculateCheckDigitK(values, l);
+ values[l] = k;
+
+ readable = new StringBuilder(content);
+ if (showCheckDigits) {
+ readable.append(CODE_93_LOOKUP[c]).append(CODE_93_LOOKUP[k]);
+ }
+ if (startStopDelimiter != null) {
+ readable = new StringBuilder(startStopDelimiter).append(readable).append(startStopDelimiter);
+ }
+
+ encodeInfo.append("Check Digit C: ").append(c).append("\n");
+ encodeInfo.append("Check Digit K: ").append(k).append("\n");
+ pattern = new String[]{toPattern(values)};
+ rowCount = 1;
+ rowHeight = new int[]{-1};
+
+ plotSymbol();
+
+ return true;
+ }
+
+ @Override
+ protected int[] getCodewords() {
+ return getPatternAsCodewords(6);
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/CodeOne.java b/barcode/src/main/java/org/xbib/graphics/barcode/CodeOne.java
new file mode 100755
index 0000000..78cb569
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/CodeOne.java
@@ -0,0 +1,1946 @@
+package org.xbib.graphics.barcode;
+
+import org.xbib.graphics.barcode.util.ReedSolomon;
+import java.io.UnsupportedEncodingException;
+import java.math.BigInteger;
+
+/**
+ * Implements Code One.
+ * Code One is able to encode the ISO 8859-1 (Latin-1) character set or GS1
+ * data. There are two types of Code One symbol - variable height symbols
+ * which are roughly square (versions A thought to H) and fixed-height
+ * versions (version S and T). Version S symbols can only encode numeric data.
+ * The width of version S and version T symbols is determined by the length
+ * of the input data.
+ */
+public class CodeOne extends Symbol {
+ private final int[] c40_shift = {
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3
+ };
+
+ private final int[] c40_value = {
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3, 0, 1, 2, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 14, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16,
+ 17, 18, 19, 20, 21, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+ 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 22, 23, 24, 25, 26,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+ };
+
+ private final int[] text_shift = {
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2,
+ 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 3, 3, 3, 3, 3
+ };
+
+ private final int[] text_value = {
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3, 0, 1, 2, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 14, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16,
+ 17, 18, 19, 20, 21, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 22, 23, 24, 25, 26, 0, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+ 33, 34, 35, 36, 37, 38, 39, 27, 28, 29, 30, 31
+ };
+
+ private final int[] c1_height = {
+ 16, 22, 28, 40, 52, 70, 104, 148
+ };
+ private final int[] c1_width = {
+ 18, 22, 32, 42, 54, 76, 98, 134
+ };
+ private final int[] c1_data_length = {
+ 10, 19, 44, 91, 182, 370, 732, 1480
+ };
+ private final int[] c1_ecc_length = {
+ 10, 16, 26, 44, 70, 140, 280, 560
+ };
+ private final int[] c1_blocks = {
+ 1, 1, 1, 1, 1, 2, 4, 8
+ };
+ private final int[] c1_data_blocks = {
+ 10, 19, 44, 91, 182, 185, 183, 185
+ };
+ private final int[] c1_ecc_blocks = {
+ 10, 16, 26, 44, 70, 70, 70, 70
+ };
+ private final int[] c1_grid_width = {
+ 4, 5, 7, 9, 12, 17, 22, 30
+ };
+ private final int[] c1_grid_height = {
+ 5, 7, 10, 15, 21, 30, 46, 68
+ };
+ private int[] data = new int[1500];
+
+ ;
+ private byte[] source;
+ private int[][] datagrid = new int[136][120];
+ private boolean[][] outputGrid = new boolean[148][134];
+ private Version preferredVersion = Version.NONE;
+
+ /**
+ * Set symbol size by "version". Versions A to H are square symbols.
+ * This value may be ignored if the input data does not fit in the
+ * specified version. Version S and T are fixed height symbols.
+ *
+ * @param version Symbol version
+ */
+ public void setPreferredVersion(Version version) {
+ preferredVersion = version;
+ }
+
+ @Override
+ public boolean encode() {
+ int size = 1, i, j, data_blocks;
+ int row, col;
+ int sub_version = 0;
+ int codewords;
+ BigInteger elreg;
+ BigInteger codewordValue;
+ int[] ecc = new int[600];
+ int[] stream = new int[2100];
+ int block_width;
+ int length = content.length();
+ ReedSolomon rs = new ReedSolomon();
+ int data_length;
+ int data_cw, ecc_cw;
+ int[] sub_data = new int[190];
+ StringBuilder bin;
+
+ if (!content.matches("[\u0000-\u00FF]+")) {
+ errorMsg.append("Invalid characters in input data");
+ return false;
+ }
+
+ if (preferredVersion == Version.S) {
+ /* Version S */
+
+ encodeInfo.append("Version: S");
+
+ if (length > 18) {
+ errorMsg.append("Input data too long");
+ return false;
+ }
+
+ if (!(content.matches("[0-9]+?"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ sub_version = 3;
+ codewords = 12;
+ block_width = 6; /* Version S-30 */
+ if (length <= 12) {
+ sub_version = 2;
+ codewords = 8;
+ block_width = 4;
+ } /* Version S-20 */
+ if (length <= 6) {
+ sub_version = 1;
+ codewords = 4;
+ block_width = 2;
+ } /* Version S-10 */
+
+ elreg = new BigInteger(content);
+
+ for (i = 0; i < codewords; i++) {
+ codewordValue = elreg.shiftRight(5 * i);
+ codewordValue = codewordValue.or(BigInteger.valueOf(32));
+ data[codewords - i - 1] = codewordValue.intValue();
+ }
+
+ rs.init_gf(0x25);
+ rs.init_code(codewords, 1);
+ rs.encode(codewords, data);
+
+ for (i = 0; i < codewords; i++) {
+ stream[i] = data[i];
+ stream[i + codewords] = rs.getResult(codewords - i - 1);
+ }
+
+ for (i = 0; i < 136; i++) {
+ for (j = 0; j < 120; j++) {
+ datagrid[i][j] = '0';
+ }
+ }
+
+ i = 0;
+ for (row = 0; row < 2; row++) {
+ for (col = 0; col < block_width; col++) {
+ if ((stream[i] & 0x10) != 0) {
+ datagrid[row * 2][col * 5] = '1';
+ }
+ if ((stream[i] & 0x08) != 0) {
+ datagrid[row * 2][(col * 5) + 1] = '1';
+ }
+ if ((stream[i] & 0x04) != 0) {
+ datagrid[row * 2][(col * 5) + 2] = '1';
+ }
+ if ((stream[i] & 0x02) != 0) {
+ datagrid[(row * 2) + 1][col * 5] = '1';
+ }
+ if ((stream[i] & 0x01) != 0) {
+ datagrid[(row * 2) + 1][(col * 5) + 1] = '1';
+ }
+ if ((stream[i + 1] & 0x10) != 0) {
+ datagrid[row * 2][(col * 5) + 3] = '1';
+ }
+ if ((stream[i + 1] & 0x08) != 0) {
+ datagrid[row * 2][(col * 5) + 4] = '1';
+ }
+ if ((stream[i + 1] & 0x04) != 0) {
+ datagrid[(row * 2) + 1][(col * 5) + 2] = '1';
+ }
+ if ((stream[i + 1] & 0x02) != 0) {
+ datagrid[(row * 2) + 1][(col * 5) + 3] = '1';
+ }
+ if ((stream[i + 1] & 0x01) != 0) {
+ datagrid[(row * 2) + 1][(col * 5) + 4] = '1';
+ }
+ i += 2;
+ }
+ }
+
+ size = 9;
+ rowCount = 8;
+ symbolWidth = 10 * sub_version + 1;
+ }
+
+ if (preferredVersion == Version.T) {
+ /* Version T */
+
+ encodeInfo.append("Version: T\n");
+
+ for (i = 0; i < 40; i++) {
+ data[i] = 0;
+ }
+ data_length = encodeAsCode1Data();
+
+ if (data_length == 0) {
+ errorMsg.append("Input data too long");
+ return false;
+ }
+
+ if (data_length > 38) {
+ errorMsg.append("Input data too long");
+ return false;
+ }
+
+ size = 10;
+ sub_version = 3;
+ data_cw = 38;
+ ecc_cw = 22;
+ block_width = 12;
+ if (data_length <= 24) {
+ sub_version = 2;
+ data_cw = 24;
+ ecc_cw = 16;
+ block_width = 8;
+ }
+ if (data_length <= 10) {
+ sub_version = 1;
+ data_cw = 10;
+ ecc_cw = 10;
+ block_width = 4;
+ }
+
+ for (i = data_length; i < data_cw; i++) {
+ data[i] = 129; /* Pad */
+ }
+
+ /* Calculate error correction data */
+ rs.init_gf(0x12d);
+ rs.init_code(ecc_cw, 1);
+ rs.encode(data_cw, data);
+
+ /* "Stream" combines data and error correction data */
+ for (i = 0; i < data_cw; i++) {
+ stream[i] = data[i];
+ }
+ for (i = 0; i < ecc_cw; i++) {
+ stream[data_cw + i] = rs.getResult(ecc_cw - i - 1);
+ }
+
+ for (i = 0; i < 136; i++) {
+ for (j = 0; j < 120; j++) {
+ datagrid[i][j] = '0';
+ }
+ }
+
+ i = 0;
+ for (row = 0; row < 5; row++) {
+ for (col = 0; col < block_width; col++) {
+ if ((stream[i] & 0x80) != 0) {
+ datagrid[row * 2][col * 4] = '1';
+ }
+ if ((stream[i] & 0x40) != 0) {
+ datagrid[row * 2][(col * 4) + 1] = '1';
+ }
+ if ((stream[i] & 0x20) != 0) {
+ datagrid[row * 2][(col * 4) + 2] = '1';
+ }
+ if ((stream[i] & 0x10) != 0) {
+ datagrid[row * 2][(col * 4) + 3] = '1';
+ }
+ if ((stream[i] & 0x08) != 0) {
+ datagrid[(row * 2) + 1][col * 4] = '1';
+ }
+ if ((stream[i] & 0x04) != 0) {
+ datagrid[(row * 2) + 1][(col * 4) + 1] = '1';
+ }
+ if ((stream[i] & 0x02) != 0) {
+ datagrid[(row * 2) + 1][(col * 4) + 2] = '1';
+ }
+ if ((stream[i] & 0x01) != 0) {
+ datagrid[(row * 2) + 1][(col * 4) + 3] = '1';
+ }
+ i++;
+ }
+ }
+
+ rowCount = 16;
+ symbolWidth = (sub_version * 16) + 1;
+ }
+
+ if ((preferredVersion != Version.S) && (preferredVersion != Version.T)) {
+ /* Version A to H */
+ for (i = 0; i < 1500; i++) {
+ data[i] = 0;
+ }
+ data_length = encodeAsCode1Data();
+
+ if (data_length == 0) {
+ errorMsg.append("Input data too long");
+ return false;
+ }
+
+ for (i = 7; i >= 0; i--) {
+ if (c1_data_length[i] >= data_length) {
+ size = i + 1;
+ }
+ }
+
+ if (getSize(preferredVersion) > size) {
+ size = getSize(preferredVersion);
+ }
+
+ encodeInfo.append("Version: ").append((char) ((size - 1) + 'A')).append("\n");
+
+ encodeInfo.append("Codewords: ");
+ for (i = 0; i < data_length; i++) {
+ encodeInfo.append(Integer.toString(data[i])).append(" ");
+ }
+ encodeInfo.append("\n");
+
+ for (i = data_length; i < c1_data_length[size - 1]; i++) {
+ data[i] = 129; /* Pad */
+ }
+
+ /* Calculate error correction data */
+ data_length = c1_data_length[size - 1];
+
+ data_blocks = c1_blocks[size - 1];
+
+ rs.init_gf(0x12d);
+ rs.init_code(c1_ecc_blocks[size - 1], 0);
+ for (i = 0; i < data_blocks; i++) {
+ for (j = 0; j < c1_data_blocks[size - 1]; j++) {
+
+ sub_data[j] = data[j * data_blocks + i];
+ }
+ rs.encode(c1_data_blocks[size - 1], sub_data);
+ for (j = 0; j < c1_ecc_blocks[size - 1]; j++) {
+ ecc[c1_ecc_length[size - 1] - (j * data_blocks + i) - 1]
+ = rs.getResult(j);
+ }
+ }
+
+ encodeInfo.append("ECC Codeword Count: ").append(c1_ecc_length[size - 1]).append("\n");
+
+ /* "Stream" combines data and error correction data */
+ for (i = 0; i < data_length; i++) {
+ stream[i] = data[i];
+ }
+ for (i = 0; i < c1_ecc_length[size - 1]; i++) {
+ stream[data_length + i] = ecc[i];
+ }
+
+ for (i = 0; i < 136; i++) {
+ for (j = 0; j < 120; j++) {
+ datagrid[i][j] = '0';
+ }
+ }
+
+ i = 0;
+ for (row = 0; row < c1_grid_height[size - 1]; row++) {
+ for (col = 0; col < c1_grid_width[size - 1]; col++) {
+ if ((stream[i] & 0x80) != 0) {
+ datagrid[row * 2][col * 4] = '1';
+ }
+ if ((stream[i] & 0x40) != 0) {
+ datagrid[row * 2][(col * 4) + 1] = '1';
+ }
+ if ((stream[i] & 0x20) != 0) {
+ datagrid[row * 2][(col * 4) + 2] = '1';
+ }
+ if ((stream[i] & 0x10) != 0) {
+ datagrid[row * 2][(col * 4) + 3] = '1';
+ }
+ if ((stream[i] & 0x08) != 0) {
+ datagrid[(row * 2) + 1][col * 4] = '1';
+ }
+ if ((stream[i] & 0x04) != 0) {
+ datagrid[(row * 2) + 1][(col * 4) + 1] = '1';
+ }
+ if ((stream[i] & 0x02) != 0) {
+ datagrid[(row * 2) + 1][(col * 4) + 2] = '1';
+ }
+ if ((stream[i] & 0x01) != 0) {
+ datagrid[(row * 2) + 1][(col * 4) + 3] = '1';
+ }
+ i++;
+ }
+ }
+
+ encodeInfo.append("Grid Size: ").append(c1_grid_width[size - 1]).append(" X ").append(c1_grid_height[size - 1]).append("\n");
+
+ rowCount = c1_height[size - 1];
+ symbolWidth = c1_width[size - 1];
+ }
+
+ for (i = 0; i < 148; i++) {
+ for (j = 0; j < 134; j++) {
+ outputGrid[i][j] = false;
+ }
+ }
+
+ switch (size) {
+ case 1:
+ /* Version A */
+ plotCentralFinder(6, 3, 1);
+ plotVerticalBar(4, 6, 1);
+ plotVerticalBar(12, 5, 0);
+ setGridModule(5, 12);
+ plotSpigot(0);
+ plotSpigot(15);
+ plotDataBlock(0, 0, 5, 4, 0, 0);
+ plotDataBlock(0, 4, 5, 12, 0, 2);
+ plotDataBlock(5, 0, 5, 12, 6, 0);
+ plotDataBlock(5, 12, 5, 4, 6, 2);
+ break;
+ case 2:
+ /* Version B */
+ plotCentralFinder(8, 4, 1);
+ plotVerticalBar(4, 8, 1);
+ plotVerticalBar(16, 7, 0);
+ setGridModule(7, 16);
+ plotSpigot(0);
+ plotSpigot(21);
+ plotDataBlock(0, 0, 7, 4, 0, 0);
+ plotDataBlock(0, 4, 7, 16, 0, 2);
+ plotDataBlock(7, 0, 7, 16, 8, 0);
+ plotDataBlock(7, 16, 7, 4, 8, 2);
+ break;
+ case 3:
+ /* Version C */
+ plotCentralFinder(11, 4, 2);
+ plotVerticalBar(4, 11, 1);
+ plotVerticalBar(26, 13, 1);
+ plotVerticalBar(4, 10, 0);
+ plotVerticalBar(26, 10, 0);
+ plotSpigot(0);
+ plotSpigot(27);
+ plotDataBlock(0, 0, 10, 4, 0, 0);
+ plotDataBlock(0, 4, 10, 20, 0, 2);
+ plotDataBlock(0, 24, 10, 4, 0, 4);
+ plotDataBlock(10, 0, 10, 4, 8, 0);
+ plotDataBlock(10, 4, 10, 20, 8, 2);
+ plotDataBlock(10, 24, 10, 4, 8, 4);
+ break;
+ case 4:
+ /* Version D */
+ plotCentralFinder(16, 5, 1);
+ plotVerticalBar(4, 16, 1);
+ plotVerticalBar(20, 16, 1);
+ plotVerticalBar(36, 16, 1);
+ plotVerticalBar(4, 15, 0);
+ plotVerticalBar(20, 15, 0);
+ plotVerticalBar(36, 15, 0);
+ plotSpigot(0);
+ plotSpigot(12);
+ plotSpigot(27);
+ plotSpigot(39);
+ plotDataBlock(0, 0, 15, 4, 0, 0);
+ plotDataBlock(0, 4, 15, 14, 0, 2);
+ plotDataBlock(0, 18, 15, 14, 0, 4);
+ plotDataBlock(0, 32, 15, 4, 0, 6);
+ plotDataBlock(15, 0, 15, 4, 10, 0);
+ plotDataBlock(15, 4, 15, 14, 10, 2);
+ plotDataBlock(15, 18, 15, 14, 10, 4);
+ plotDataBlock(15, 32, 15, 4, 10, 6);
+ break;
+ case 5:
+ /* Version E */
+ plotCentralFinder(22, 5, 2);
+ plotVerticalBar(4, 22, 1);
+ plotVerticalBar(26, 24, 1);
+ plotVerticalBar(48, 22, 1);
+ plotVerticalBar(4, 21, 0);
+ plotVerticalBar(26, 21, 0);
+ plotVerticalBar(48, 21, 0);
+ plotSpigot(0);
+ plotSpigot(12);
+ plotSpigot(39);
+ plotSpigot(51);
+ plotDataBlock(0, 0, 21, 4, 0, 0);
+ plotDataBlock(0, 4, 21, 20, 0, 2);
+ plotDataBlock(0, 24, 21, 20, 0, 4);
+ plotDataBlock(0, 44, 21, 4, 0, 6);
+ plotDataBlock(21, 0, 21, 4, 10, 0);
+ plotDataBlock(21, 4, 21, 20, 10, 2);
+ plotDataBlock(21, 24, 21, 20, 10, 4);
+ plotDataBlock(21, 44, 21, 4, 10, 6);
+ break;
+ case 6:
+ /* Version F */
+ plotCentralFinder(31, 5, 3);
+ plotVerticalBar(4, 31, 1);
+ plotVerticalBar(26, 35, 1);
+ plotVerticalBar(48, 31, 1);
+ plotVerticalBar(70, 35, 1);
+ plotVerticalBar(4, 30, 0);
+ plotVerticalBar(26, 30, 0);
+ plotVerticalBar(48, 30, 0);
+ plotVerticalBar(70, 30, 0);
+ plotSpigot(0);
+ plotSpigot(12);
+ plotSpigot(24);
+ plotSpigot(45);
+ plotSpigot(57);
+ plotSpigot(69);
+ plotDataBlock(0, 0, 30, 4, 0, 0);
+ plotDataBlock(0, 4, 30, 20, 0, 2);
+ plotDataBlock(0, 24, 30, 20, 0, 4);
+ plotDataBlock(0, 44, 30, 20, 0, 6);
+ plotDataBlock(0, 64, 30, 4, 0, 8);
+ plotDataBlock(30, 0, 30, 4, 10, 0);
+ plotDataBlock(30, 4, 30, 20, 10, 2);
+ plotDataBlock(30, 24, 30, 20, 10, 4);
+ plotDataBlock(30, 44, 30, 20, 10, 6);
+ plotDataBlock(30, 64, 30, 4, 10, 8);
+ break;
+ case 7:
+ /* Version G */
+ plotCentralFinder(47, 6, 2);
+ plotVerticalBar(6, 47, 1);
+ plotVerticalBar(27, 49, 1);
+ plotVerticalBar(48, 47, 1);
+ plotVerticalBar(69, 49, 1);
+ plotVerticalBar(90, 47, 1);
+ plotVerticalBar(6, 46, 0);
+ plotVerticalBar(27, 46, 0);
+ plotVerticalBar(48, 46, 0);
+ plotVerticalBar(69, 46, 0);
+ plotVerticalBar(90, 46, 0);
+ plotSpigot(0);
+ plotSpigot(12);
+ plotSpigot(24);
+ plotSpigot(36);
+ plotSpigot(67);
+ plotSpigot(79);
+ plotSpigot(91);
+ plotSpigot(103);
+ plotDataBlock(0, 0, 46, 6, 0, 0);
+ plotDataBlock(0, 6, 46, 19, 0, 2);
+ plotDataBlock(0, 25, 46, 19, 0, 4);
+ plotDataBlock(0, 44, 46, 19, 0, 6);
+ plotDataBlock(0, 63, 46, 19, 0, 8);
+ plotDataBlock(0, 82, 46, 6, 0, 10);
+ plotDataBlock(46, 0, 46, 6, 12, 0);
+ plotDataBlock(46, 6, 46, 19, 12, 2);
+ plotDataBlock(46, 25, 46, 19, 12, 4);
+ plotDataBlock(46, 44, 46, 19, 12, 6);
+ plotDataBlock(46, 63, 46, 19, 12, 8);
+ plotDataBlock(46, 82, 46, 6, 12, 10);
+ break;
+ case 8:
+ /* Version H */
+ plotCentralFinder(69, 6, 3);
+ plotVerticalBar(6, 69, 1);
+ plotVerticalBar(26, 73, 1);
+ plotVerticalBar(46, 69, 1);
+ plotVerticalBar(66, 73, 1);
+ plotVerticalBar(86, 69, 1);
+ plotVerticalBar(106, 73, 1);
+ plotVerticalBar(126, 69, 1);
+ plotVerticalBar(6, 68, 0);
+ plotVerticalBar(26, 68, 0);
+ plotVerticalBar(46, 68, 0);
+ plotVerticalBar(66, 68, 0);
+ plotVerticalBar(86, 68, 0);
+ plotVerticalBar(106, 68, 0);
+ plotVerticalBar(126, 68, 0);
+ plotSpigot(0);
+ plotSpigot(12);
+ plotSpigot(24);
+ plotSpigot(36);
+ plotSpigot(48);
+ plotSpigot(60);
+ plotSpigot(87);
+ plotSpigot(99);
+ plotSpigot(111);
+ plotSpigot(123);
+ plotSpigot(135);
+ plotSpigot(147);
+ plotDataBlock(0, 0, 68, 6, 0, 0);
+ plotDataBlock(0, 6, 68, 18, 0, 2);
+ plotDataBlock(0, 24, 68, 18, 0, 4);
+ plotDataBlock(0, 42, 68, 18, 0, 6);
+ plotDataBlock(0, 60, 68, 18, 0, 8);
+ plotDataBlock(0, 78, 68, 18, 0, 10);
+ plotDataBlock(0, 96, 68, 18, 0, 12);
+ plotDataBlock(0, 114, 68, 6, 0, 14);
+ plotDataBlock(68, 0, 68, 6, 12, 0);
+ plotDataBlock(68, 6, 68, 18, 12, 2);
+ plotDataBlock(68, 24, 68, 18, 12, 4);
+ plotDataBlock(68, 42, 68, 18, 12, 6);
+ plotDataBlock(68, 60, 68, 18, 12, 8);
+ plotDataBlock(68, 78, 68, 18, 12, 10);
+ plotDataBlock(68, 96, 68, 18, 12, 12);
+ plotDataBlock(68, 114, 68, 6, 12, 14);
+ break;
+ case 9:
+ /* Version S */
+ plotHorizontalBar(5, 1);
+ plotHorizontalBar(7, 1);
+ setGridModule(6, 0);
+ setGridModule(6, symbolWidth - 1);
+ resetGridModule(7, 1);
+ resetGridModule(7, symbolWidth - 2);
+ switch (sub_version) {
+ case 1:
+ /* Version S-10 */
+ setGridModule(0, 5);
+ plotDataBlock(0, 0, 4, 5, 0, 0);
+ plotDataBlock(0, 5, 4, 5, 0, 1);
+ break;
+ case 2:
+ /* Version S-20 */
+ setGridModule(0, 10);
+ setGridModule(4, 10);
+ plotDataBlock(0, 0, 4, 10, 0, 0);
+ plotDataBlock(0, 10, 4, 10, 0, 1);
+ break;
+ case 3:
+ /* Version S-30 */
+ setGridModule(0, 15);
+ setGridModule(4, 15);
+ setGridModule(6, 15);
+ plotDataBlock(0, 0, 4, 15, 0, 0);
+ plotDataBlock(0, 15, 4, 15, 0, 1);
+ break;
+ }
+ break;
+ case 10:
+ /* Version T */
+ plotHorizontalBar(11, 1);
+ plotHorizontalBar(13, 1);
+ plotHorizontalBar(15, 1);
+ setGridModule(12, 0);
+ setGridModule(12, symbolWidth - 1);
+ setGridModule(14, 0);
+ setGridModule(14, symbolWidth - 1);
+ resetGridModule(13, 1);
+ resetGridModule(13, symbolWidth - 2);
+ resetGridModule(15, 1);
+ resetGridModule(15, symbolWidth - 2);
+ switch (sub_version) {
+ case 1:
+ /* Version T-16 */
+ setGridModule(0, 8);
+ setGridModule(10, 8);
+ plotDataBlock(0, 0, 10, 8, 0, 0);
+ plotDataBlock(0, 8, 10, 8, 0, 1);
+ break;
+ case 2:
+ /* Version T-32 */
+ setGridModule(0, 16);
+ setGridModule(10, 16);
+ setGridModule(12, 16);
+ plotDataBlock(0, 0, 10, 16, 0, 0);
+ plotDataBlock(0, 16, 10, 16, 0, 1);
+ break;
+ case 3:
+ /* Verion T-48 */
+ setGridModule(0, 24);
+ setGridModule(10, 24);
+ setGridModule(12, 24);
+ setGridModule(14, 24);
+ plotDataBlock(0, 0, 10, 24, 0, 0);
+ plotDataBlock(0, 24, 10, 24, 0, 1);
+ break;
+ }
+ break;
+ }
+
+ readable = new StringBuilder();
+ pattern = new String[rowCount];
+ rowHeight = new int[rowCount];
+ for (i = 0; i < rowCount; i++) {
+ bin = new StringBuilder();
+ for (j = 0; j < symbolWidth; j++) {
+ if (outputGrid[i][j]) {
+ bin.append("1");
+ } else {
+ bin.append("0");
+ }
+ }
+ pattern[i] = bin2pat(bin.toString());
+ rowHeight[i] = 1;
+ }
+ plotSymbol();
+ return true;
+ }
+
+ private int encodeAsCode1Data() {
+ c1Mode current_mode, next_mode;
+ boolean latch;
+ boolean done;
+ int sourcePoint, targetPoint, i, j;
+ int c40_p;
+ int text_p;
+ int edi_p;
+ int byte_start = 0;
+ int[] c40_buffer = new int[6];
+ int[] text_buffer = new int[6];
+ int[] edi_buffer = new int[6];
+ StringBuilder decimal_binary = new StringBuilder();
+ int length = content.length();
+ int shift_set, value;
+ int data_left, decimal_count;
+ int sub_value;
+ int bits_left_in_byte, target_count;
+ boolean isTwoDigits;
+
+ try {
+ source = content.getBytes("ISO8859_1");
+ } catch (UnsupportedEncodingException e) {
+ errorMsg.append("Invalid character in input data");
+ return 0;
+ }
+
+ sourcePoint = 0;
+ targetPoint = 0;
+ c40_p = 0;
+ text_p = 0;
+ edi_p = 0;
+
+ if (inputDataType == DataType.GS1) {
+ data[targetPoint] = 232;
+ targetPoint++;
+ } /* FNC1 */
+
+ /* Step A */
+ current_mode = c1Mode.C1_ASCII;
+ next_mode = c1Mode.C1_ASCII;
+
+ do {
+ if (current_mode != next_mode) {
+ /* Change mode */
+ switch (next_mode) {
+ case C1_C40:
+ data[targetPoint] = 230;
+ targetPoint++;
+ break;
+ case C1_TEXT:
+ data[targetPoint] = 239;
+ targetPoint++;
+ break;
+ case C1_EDI:
+ data[targetPoint] = 238;
+ targetPoint++;
+ break;
+ case C1_BYTE:
+ data[targetPoint] = 231;
+ targetPoint++;
+ break;
+ }
+ }
+
+ if ((current_mode != c1Mode.C1_BYTE) && (next_mode == c1Mode.C1_BYTE)) {
+ byte_start = targetPoint;
+ }
+ current_mode = next_mode;
+
+ if (current_mode == c1Mode.C1_ASCII) { /* Step B - ASCII encodation */
+ next_mode = c1Mode.C1_ASCII;
+
+ if ((length - sourcePoint) >= 21) { /* Step B1 */
+ j = 0;
+
+ for (i = 0; i < 21; i++) {
+ if ((source[sourcePoint + i] >= '0') && (source[sourcePoint + i] <= '9')) {
+ j++;
+ }
+ }
+
+ if (j == 21) {
+ next_mode = c1Mode.C1_DECIMAL;
+ decimal_binary.append("1111");
+ }
+ }
+
+ if ((next_mode == c1Mode.C1_ASCII) && ((length - sourcePoint) >= 13)) { /* Step B2 */
+ j = 0;
+
+ for (i = 0; i < 13; i++) {
+ if ((source[sourcePoint + i] >= '0') && (source[sourcePoint + i] <= '9')) {
+ j++;
+ }
+ }
+
+ if (j == 13) {
+ latch = false;
+ for (i = sourcePoint + 13; i < length; i++) {
+ if (!((source[i] >= '0') &&
+ (source[i] <= '9'))) {
+ latch = true;
+ }
+ }
+
+ if (!(latch)) {
+ next_mode = c1Mode.C1_DECIMAL;
+ decimal_binary.append("1111");
+ }
+ }
+ }
+
+ if (next_mode == c1Mode.C1_ASCII) { /* Step B3 */
+ isTwoDigits = false;
+ if ((sourcePoint + 1) != length) {
+ if ((source[sourcePoint] >= '0') && (source[sourcePoint] <= '9')) {
+ if ((source[sourcePoint + 1] >= '0') && (source[sourcePoint + 1] <= '9')) {
+ // remaining data consists of two numeric digits
+ data[targetPoint] = (10 * (source[sourcePoint] - '0'))
+ + (source[sourcePoint + 1] - '0') + 130;
+ targetPoint++;
+ sourcePoint += 2;
+ isTwoDigits = true;
+ }
+ }
+ }
+
+ if (!(isTwoDigits)) {
+ if ((inputDataType == DataType.GS1) && (source[sourcePoint] == '[')) {
+ if ((length - sourcePoint) >= 15) { /* Step B4 */
+ j = 0;
+
+ for (i = 0; i < 15; i++) {
+ if ((source[sourcePoint + i] >= '0')
+ && (source[sourcePoint + i] <= '9')) {
+ j++;
+ }
+ }
+
+ if (j == 15) {
+ data[targetPoint] = 236; /* FNC1 and change to Decimal */
+ targetPoint++;
+ sourcePoint++;
+ next_mode = c1Mode.C1_DECIMAL;
+ }
+ }
+
+ if ((length - sourcePoint) >= 7) { /* Step B5 */
+ j = 0;
+
+ for (i = 0; i < 7; i++) {
+ if ((source[sourcePoint + i] >= '0')
+ && (source[sourcePoint + i] <= '9')) {
+ j++;
+ }
+ }
+
+ if (j == 7) {
+ latch = false;
+ for (i = sourcePoint + 7; i < length; i++) {
+ if (!((source[sourcePoint + i] >= '0')
+ && (source[sourcePoint + i] <= '9'))) {
+ latch = true;
+ }
+ }
+
+ if (!(latch)) {
+ data[targetPoint] = 236; /* FNC1 and change to Decimal */
+ targetPoint++;
+ sourcePoint++;
+ next_mode = c1Mode.C1_DECIMAL;
+ }
+ }
+ }
+ }
+
+ if (next_mode == c1Mode.C1_ASCII) {
+
+ /* Step B6 */
+ next_mode = lookAheadTest(length, sourcePoint, current_mode);
+
+ if (next_mode == c1Mode.C1_ASCII) {
+ if (source[sourcePoint] > 127) {
+ /* Step B7 */
+ data[targetPoint] = 235;
+ targetPoint++; /* FNC4 */
+ data[targetPoint] = (source[sourcePoint] - 128) + 1;
+ targetPoint++;
+ sourcePoint++;
+ } else {
+ /* Step B8 */
+ if ((inputDataType == DataType.GS1) && (source[sourcePoint] == '[')) {
+ data[targetPoint] = 232;
+ targetPoint++;
+ sourcePoint++; /* FNC1 */
+ } else {
+ data[targetPoint] = source[sourcePoint] + 1;
+ targetPoint++;
+ sourcePoint++;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (current_mode == c1Mode.C1_C40) { /* Step C - C40 encodation */
+ done = false;
+ next_mode = c1Mode.C1_C40;
+ if (c40_p == 0) {
+ if ((length - sourcePoint) >= 12) {
+ j = 0;
+
+ for (i = 0; i < 12; i++) {
+ if ((source[sourcePoint + i] >= '0')
+ && (source[sourcePoint + i] <= '9')) {
+ j++;
+ }
+ }
+
+ if (j == 12) {
+ next_mode = c1Mode.C1_ASCII;
+ done = true;
+ }
+ }
+
+ if ((length - sourcePoint) >= 8) {
+ j = 0;
+
+ for (i = 0; i < 8; i++) {
+ if ((source[sourcePoint + i] >= '0')
+ && (source[sourcePoint + i] <= '9')) {
+ j++;
+ }
+ }
+
+ if ((length - sourcePoint) == 8) {
+ latch = true;
+ } else {
+ latch = true;
+ for (j = sourcePoint + 8; j < length; j++) {
+ if ((source[j] <= '0') || (source[j] >= '9')) {
+ latch = false;
+ }
+ }
+ }
+
+ if ((j == 8) && latch) {
+ next_mode = c1Mode.C1_ASCII;
+ done = true;
+ }
+ }
+
+ if (!(done)) {
+ next_mode = lookAheadTest(length, sourcePoint, current_mode);
+ }
+ }
+
+ if (next_mode != c1Mode.C1_C40) {
+ data[targetPoint] = 255;
+ targetPoint++; /* Unlatch */
+ } else {
+ if (source[sourcePoint] > 127) {
+ c40_buffer[c40_p] = 1;
+ c40_p++;
+ c40_buffer[c40_p] = 30;
+ c40_p++; /* Upper Shift */
+ shift_set = c40_shift[source[sourcePoint] - 128];
+ value = c40_value[source[sourcePoint] - 128];
+ } else {
+ shift_set = c40_shift[source[sourcePoint]];
+ value = c40_value[source[sourcePoint]];
+ }
+
+ if ((inputDataType == DataType.GS1) && (source[sourcePoint] == '[')) {
+ shift_set = 2;
+ value = 27; /* FNC1 */
+ }
+
+ if (shift_set != 0) {
+ c40_buffer[c40_p] = shift_set - 1;
+ c40_p++;
+ }
+ c40_buffer[c40_p] = value;
+ c40_p++;
+
+ if (c40_p >= 3) {
+ int iv;
+
+ iv = (1600 * c40_buffer[0]) + (40 * c40_buffer[1])
+ + (c40_buffer[2]) + 1;
+ data[targetPoint] = iv / 256;
+ targetPoint++;
+ data[targetPoint] = iv % 256;
+ targetPoint++;
+
+ c40_buffer[0] = c40_buffer[3];
+ c40_buffer[1] = c40_buffer[4];
+ c40_buffer[2] = c40_buffer[5];
+ c40_buffer[3] = 0;
+ c40_buffer[4] = 0;
+ c40_buffer[5] = 0;
+ c40_p -= 3;
+ }
+ sourcePoint++;
+ }
+ }
+
+ if (current_mode == c1Mode.C1_TEXT) { /* Step D - Text encodation */
+ done = false;
+ next_mode = c1Mode.C1_TEXT;
+ if (text_p == 0) {
+ if ((length - sourcePoint) >= 12) {
+ j = 0;
+
+ for (i = 0; i < 12; i++) {
+ if ((source[sourcePoint + i] >= '0')
+ && (source[sourcePoint + i] <= '9')) {
+ j++;
+ }
+ }
+
+ if (j == 12) {
+ next_mode = c1Mode.C1_ASCII;
+ done = true;
+ }
+ }
+
+ if ((length - sourcePoint) >= 8) {
+ j = 0;
+
+ for (i = 0; i < 8; i++) {
+ if ((source[sourcePoint + i] >= '0')
+ && (source[sourcePoint + i] <= '9')) {
+ j++;
+ }
+ }
+
+ if ((length - sourcePoint) == 8) {
+ latch = true;
+ } else {
+ latch = true;
+ for (j = sourcePoint + 8; j < length; j++) {
+ if ((source[j] <= '0') || (source[j] >= '9')) {
+ latch = false;
+ }
+ }
+ }
+
+ if ((j == 8) && latch) {
+ next_mode = c1Mode.C1_ASCII;
+ done = true;
+ }
+ }
+
+ if (!(done)) {
+ next_mode = lookAheadTest(length, sourcePoint, current_mode);
+ }
+ }
+
+ if (next_mode != c1Mode.C1_TEXT) {
+ data[targetPoint] = 255;
+ targetPoint++; /* Unlatch */
+ } else {
+ if (source[sourcePoint] > 127) {
+ text_buffer[text_p] = 1;
+ text_p++;
+ text_buffer[text_p] = 30;
+ text_p++; /* Upper Shift */
+ shift_set = text_shift[source[sourcePoint] - 128];
+ value = text_value[source[sourcePoint] - 128];
+ } else {
+ shift_set = text_shift[source[sourcePoint]];
+ value = text_value[source[sourcePoint]];
+ }
+
+ if ((inputDataType == DataType.GS1) && (source[sourcePoint] == '[')) {
+ shift_set = 2;
+ value = 27; /* FNC1 */
+ }
+
+ if (shift_set != 0) {
+ text_buffer[text_p] = shift_set - 1;
+ text_p++;
+ }
+ text_buffer[text_p] = value;
+ text_p++;
+
+ if (text_p >= 3) {
+ int iv;
+
+ iv = (1600 * text_buffer[0]) + (40 * text_buffer[1])
+ + (text_buffer[2]) + 1;
+ data[targetPoint] = iv / 256;
+ targetPoint++;
+ data[targetPoint] = iv % 256;
+ targetPoint++;
+
+ text_buffer[0] = text_buffer[3];
+ text_buffer[1] = text_buffer[4];
+ text_buffer[2] = text_buffer[5];
+ text_buffer[3] = 0;
+ text_buffer[4] = 0;
+ text_buffer[5] = 0;
+ text_p -= 3;
+ }
+ sourcePoint++;
+ }
+ }
+
+ if (current_mode == c1Mode.C1_EDI) { /* Step E - EDI Encodation */
+
+ value = 0;
+ next_mode = c1Mode.C1_EDI;
+ if (edi_p == 0) {
+ if ((length - sourcePoint) >= 12) {
+ j = 0;
+
+ for (i = 0; i < 12; i++) {
+ if ((source[sourcePoint + i] >= '0')
+ && (source[sourcePoint + i] <= '9')) {
+ j++;
+ }
+ }
+
+ if (j == 12) {
+ next_mode = c1Mode.C1_ASCII;
+ }
+ }
+
+ if ((length - sourcePoint) >= 8) {
+ j = 0;
+
+ for (i = 0; i < 8; i++) {
+ if ((source[sourcePoint + i] >= '0') &&
+ (source[sourcePoint + i] <= '9')) {
+ j++;
+ }
+ }
+
+ if ((length - sourcePoint) == 8) {
+ latch = true;
+ } else {
+ latch = true;
+ for (j = sourcePoint + 8; j < length; j++) {
+ if ((source[j] <= '0') || (source[j] >= '9')) {
+ latch = false;
+ }
+ }
+ }
+
+ if ((j == 8) && latch) {
+ next_mode = c1Mode.C1_ASCII;
+ }
+ }
+
+ if (!((isEdiEncodable(source[sourcePoint])
+ && isEdiEncodable(source[sourcePoint + 1]))
+ && isEdiEncodable(source[sourcePoint + 2]))) {
+ next_mode = c1Mode.C1_ASCII;
+ }
+ }
+
+ if (next_mode != c1Mode.C1_EDI) {
+ data[targetPoint] = 255;
+ targetPoint++; /* Unlatch */
+ } else {
+ if (source[sourcePoint] == 13) {
+ value = 0;
+ }
+ if (source[sourcePoint] == '*') {
+ value = 1;
+ }
+ if (source[sourcePoint] == '>') {
+ value = 2;
+ }
+ if (source[sourcePoint] == ' ') {
+ value = 3;
+ }
+ if ((source[sourcePoint] >= '0') && (source[sourcePoint] <= '9')) {
+ value = source[sourcePoint] - '0' + 4;
+ }
+ if ((source[sourcePoint] >= 'A') && (source[sourcePoint] <= 'Z')) {
+ value = source[sourcePoint] - 'A' + 14;
+ }
+
+ edi_buffer[edi_p] = value;
+ edi_p++;
+
+ if (edi_p >= 3) {
+ int iv;
+
+ iv = (1600 * edi_buffer[0]) + (40 * edi_buffer[1])
+ + (edi_buffer[2]) + 1;
+ data[targetPoint] = iv / 256;
+ targetPoint++;
+ data[targetPoint] = iv % 256;
+ targetPoint++;
+
+ edi_buffer[0] = edi_buffer[3];
+ edi_buffer[1] = edi_buffer[4];
+ edi_buffer[2] = edi_buffer[5];
+ edi_buffer[3] = 0;
+ edi_buffer[4] = 0;
+ edi_buffer[5] = 0;
+ edi_p -= 3;
+ }
+ sourcePoint++;
+ }
+ }
+
+ if (current_mode == c1Mode.C1_DECIMAL) { /* Step F - Decimal encodation */
+
+ next_mode = c1Mode.C1_DECIMAL;
+
+ data_left = length - sourcePoint;
+ decimal_count = 0;
+
+ if (data_left >= 1) {
+ if ((source[sourcePoint] >= '0') && (source[sourcePoint] <= '9')) {
+ decimal_count = 1;
+ }
+ }
+ if (data_left >= 2) {
+ if ((decimal_count == 1) && ((source[sourcePoint + 1] >= '0')
+ && (source[sourcePoint + 1] <= '9'))) {
+ decimal_count = 2;
+ }
+ }
+ if (data_left >= 3) {
+ if ((decimal_count == 2) && ((source[sourcePoint + 2] >= '0')
+ && (source[sourcePoint + 2] <= '9'))) {
+ decimal_count = 3;
+ }
+ }
+
+ if (decimal_count != 3) {
+
+ /* Finish Decimal mode and go back to ASCII */
+
+ decimal_binary.append("111111"); /* Unlatch */
+
+ target_count = 3;
+ if (decimal_binary.length() <= 16) {
+ target_count = 2;
+ }
+ if (decimal_binary.length() <= 8) {
+ target_count = 1;
+ }
+ bits_left_in_byte = (8 * target_count) - decimal_binary.length();
+ if (bits_left_in_byte == 8) {
+ bits_left_in_byte = 0;
+ }
+
+ if (bits_left_in_byte == 2) {
+ decimal_binary.append("01");
+ }
+
+ if ((bits_left_in_byte == 4) || (bits_left_in_byte == 6)) {
+ if (decimal_count >= 1) {
+ sub_value = source[sourcePoint] - '0' + 1;
+
+ for (i = 0x08; i > 0; i = i >> 1) {
+ if ((sub_value & i) != 0) {
+ decimal_binary.append("1");
+ } else {
+ decimal_binary.append("0");
+ }
+ }
+ sourcePoint++;
+ } else {
+ decimal_binary.append("1111");
+ }
+ }
+
+ if (bits_left_in_byte == 6) {
+ decimal_binary.append("01");
+ }
+
+ /* Binary buffer is full - transfer to data */
+ if (target_count >= 1) {
+ for (i = 0; i < 8; i++) {
+ if (decimal_binary.charAt(i) == '1') {
+ data[targetPoint] += 128 >> i;
+ }
+ }
+ targetPoint++;
+ }
+ if (target_count >= 2) {
+ for (i = 0; i < 8; i++) {
+ if (decimal_binary.charAt(8 + i) == '1') {
+ data[targetPoint] += 128 >> i;
+ }
+
+ }
+ targetPoint++;
+ }
+ if (target_count == 3) {
+ for (i = 0; i < 8; i++) {
+ if (decimal_binary.charAt(16 + i) == '1') {
+ data[targetPoint] += 128 >> i;
+ }
+
+ }
+ targetPoint++;
+ }
+
+ next_mode = c1Mode.C1_ASCII;
+ } else {
+ /* There are three digits - convert the value to binary */
+ value = (100 * (source[sourcePoint] - '0'))
+ + (10 * (source[sourcePoint + 1] - '0'))
+ + (source[sourcePoint + 2] - '0') + 1;
+
+ for (i = 0x200; i > 0; i = i >> 1) {
+ if ((value & i) != 0) {
+ decimal_binary.append("1");
+ } else {
+ decimal_binary.append("0");
+ }
+ }
+ sourcePoint += 3;
+ }
+
+ if (decimal_binary.length() >= 24) {
+ /* Binary buffer is full - transfer to data */
+ for (i = 0; i < 8; i++) {
+ if (decimal_binary.charAt(i) == '1') {
+ data[targetPoint] += 128 >> i;
+ }
+
+ if (decimal_binary.charAt(8 + i) == '1') {
+ data[targetPoint + 1] += 128 >> i;
+ }
+
+ if (decimal_binary.charAt(16 + i) == '1') {
+ data[targetPoint + 2] += 128 >> i;
+ }
+
+ }
+ targetPoint += 3;
+
+ if (decimal_binary.length() > 24) {
+ decimal_binary = new StringBuilder(decimal_binary.substring(24));
+ }
+ }
+ }
+
+ if (current_mode == c1Mode.C1_BYTE) {
+ next_mode = c1Mode.C1_BYTE;
+
+ if ((inputDataType == DataType.GS1) && (source[sourcePoint] == '[')) {
+ next_mode = c1Mode.C1_ASCII;
+ } else {
+ if (source[sourcePoint] <= 127) {
+ next_mode = lookAheadTest(length, sourcePoint, current_mode);
+ }
+ }
+
+ if (next_mode != c1Mode.C1_BYTE) {
+ /* Insert byte field length */
+ if ((targetPoint - byte_start) <= 249) {
+ for (i = targetPoint; i >= byte_start; i--) {
+ data[i + 1] = data[i];
+ }
+ data[byte_start] = (targetPoint - byte_start);
+ targetPoint++;
+ } else {
+ for (i = targetPoint; i >= byte_start; i--) {
+ data[i + 2] = data[i];
+ }
+ data[byte_start] = 249 + ((targetPoint - byte_start) / 250);
+ data[byte_start + 1] = ((targetPoint - byte_start) % 250);
+ targetPoint += 2;
+ }
+ } else {
+ data[targetPoint] = source[sourcePoint];
+ targetPoint++;
+ sourcePoint++;
+ }
+ }
+
+ if (targetPoint > 1480) {
+ /* Data is too large for symbol */
+ errorMsg.append("Input data too long");
+ return 0;
+ }
+ } while (sourcePoint < length);
+
+ /* Empty buffers */
+ if (c40_p == 2) {
+ int iv;
+
+ c40_buffer[2] = 1;
+ iv = (1600 * c40_buffer[0]) + (40 * c40_buffer[1])
+ + (c40_buffer[2]) + 1;
+ data[targetPoint] = iv / 256;
+ targetPoint++;
+ data[targetPoint] = iv % 256;
+ targetPoint++;
+ data[targetPoint] = 255;
+ targetPoint++; /* Unlatch */
+ }
+ if (c40_p == 1) {
+ int iv;
+
+ c40_buffer[1] = 1;
+ c40_buffer[2] = 31; /* Pad */
+ iv = (1600 * c40_buffer[0]) + (40 * c40_buffer[1])
+ + (c40_buffer[2]) + 1;
+ data[targetPoint] = iv / 256;
+ targetPoint++;
+ data[targetPoint] = iv % 256;
+ targetPoint++;
+ data[targetPoint] = 255;
+ targetPoint++; /* Unlatch */
+ }
+ if (text_p == 2) {
+ int iv;
+
+ text_buffer[2] = 1;
+ iv = (1600 * text_buffer[0]) + (40 * text_buffer[1])
+ + (text_buffer[2]) + 1;
+ data[targetPoint] = iv / 256;
+ targetPoint++;
+ data[targetPoint] = iv % 256;
+ targetPoint++;
+ data[targetPoint] = 255;
+ targetPoint++; /* Unlatch */
+ }
+ if (text_p == 1) {
+ int iv;
+
+ text_buffer[1] = 1;
+ text_buffer[2] = 31; /* Pad */
+ iv = (1600 * text_buffer[0]) + (40 * text_buffer[1])
+ + (text_buffer[2]) + 1;
+ data[targetPoint] = iv / 256;
+ targetPoint++;
+ data[targetPoint] = iv % 256;
+ targetPoint++;
+ data[targetPoint] = 255;
+ targetPoint++; /* Unlatch */
+ }
+
+ if (current_mode == c1Mode.C1_DECIMAL) {
+ /* Finish Decimal mode and go back to ASCII */
+
+ decimal_binary.append("111111"); /* Unlatch */
+
+ target_count = 3;
+ if (decimal_binary.length() <= 16) {
+ target_count = 2;
+ }
+ if (decimal_binary.length() <= 8) {
+ target_count = 1;
+ }
+ bits_left_in_byte = (8 * target_count) - decimal_binary.length();
+ if (bits_left_in_byte == 8) {
+ bits_left_in_byte = 0;
+ }
+
+ if (bits_left_in_byte == 2) {
+ decimal_binary.append("01");
+ }
+
+ if ((bits_left_in_byte == 4) || (bits_left_in_byte == 6)) {
+ decimal_binary.append("1111");
+ }
+
+ if (bits_left_in_byte == 6) {
+ decimal_binary.append("01");
+ }
+
+ /* Binary buffer is full - transfer to data */
+ if (target_count >= 1) {
+ for (i = 0; i < 8; i++) {
+ if (decimal_binary.charAt(i) == '1') {
+ data[targetPoint] += 128 >> i;
+ }
+ }
+ targetPoint++;
+ }
+ if (target_count >= 2) {
+ for (i = 0; i < 8; i++) {
+ if (decimal_binary.charAt(8 + i) == '1') {
+ data[targetPoint] += 128 >> i;
+ }
+ }
+ targetPoint++;
+ }
+ if (target_count == 3) {
+ for (i = 0; i < 8; i++) {
+ if (decimal_binary.charAt(16 + i) == '1') {
+ data[targetPoint] += 128 >> i;
+ }
+ }
+ targetPoint++;
+ }
+ }
+
+ if (current_mode == c1Mode.C1_BYTE) {
+ /* Insert byte field length */
+ if ((targetPoint - byte_start) <= 249) {
+ for (i = targetPoint; i >= byte_start; i--) {
+ data[i + 1] = data[i];
+ }
+ data[byte_start] = (targetPoint - byte_start);
+ targetPoint++;
+ } else {
+ for (i = targetPoint; i >= byte_start; i--) {
+ data[i + 2] = data[i];
+ }
+ data[byte_start] = 249 + ((targetPoint - byte_start) / 250);
+ data[byte_start + 1] = ((targetPoint - byte_start) % 250);
+ targetPoint += 2;
+ }
+ }
+
+ /* Re-check length of data */
+ if (targetPoint > 1480) {
+ /* Data is too large for symbol */
+ errorMsg.append("Input data too long");
+ return 0;
+ }
+
+ return targetPoint;
+ }
+
+ private c1Mode lookAheadTest(int sourcelen, int position,
+ c1Mode current_mode) {
+ double ascii_count, c40_count, text_count, edi_count, byte_count;
+ int reduced_char;
+ int done, best_count, sp;
+ c1Mode best_scheme;
+
+ /* Step J */
+ if (current_mode == c1Mode.C1_ASCII) {
+ ascii_count = 0.0;
+ c40_count = 1.0;
+ text_count = 1.0;
+ edi_count = 1.0;
+ byte_count = 2.0;
+ } else {
+ ascii_count = 1.0;
+ c40_count = 2.0;
+ text_count = 2.0;
+ edi_count = 2.0;
+ byte_count = 3.0;
+ }
+
+ switch (current_mode) {
+ case C1_C40:
+ c40_count = 0.0;
+ break;
+ case C1_TEXT:
+ text_count = 0.0;
+ break;
+ case C1_BYTE:
+ byte_count = 0.0;
+ break;
+ case C1_EDI:
+ edi_count = 0.0;
+ break;
+ }
+
+ for (sp = position;
+ (sp < sourcelen) && (sp <= (position + 8)); sp++) {
+
+ if (source[sp] <= 127) {
+ reduced_char = source[sp];
+ } else {
+ reduced_char = source[sp] - 127;
+ }
+
+ /* Step L */
+ if ((source[sp] >= '0') && (source[sp] <= '9')) {
+ ascii_count += 0.5;
+ } else {
+ ascii_count = roundUpToNextInteger(ascii_count);
+ if (source[sp] > 127) {
+ ascii_count += 2.0;
+ } else {
+ ascii_count += 1.0;
+ }
+ }
+
+ /* Step M */
+ done = 0;
+ if (reduced_char == ' ') {
+ c40_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if ((reduced_char >= '0') && (reduced_char <= '9')) {
+ c40_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if ((reduced_char >= 'A') && (reduced_char <= 'Z')) {
+ c40_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if (source[sp] > 127) {
+ c40_count += (4.0 / 3.0);
+ }
+ if (done == 0) {
+ c40_count += (4.0 / 3.0);
+ }
+
+ /* Step N */
+ done = 0;
+ if (reduced_char == ' ') {
+ text_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if ((reduced_char >= '0') && (reduced_char <= '9')) {
+ text_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if ((reduced_char >= 'a') && (reduced_char <= 'z')) {
+ text_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if (source[sp] > 127) {
+ text_count += (4.0 / 3.0);
+ }
+ if (done == 0) {
+ text_count += (4.0 / 3.0);
+ }
+
+ /* Step O */
+ done = 0;
+ if (source[sp] == 13) {
+ edi_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if (source[sp] == '*') {
+ edi_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if (source[sp] == '>') {
+ edi_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if (source[sp] == ' ') {
+ edi_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if ((source[sp] >= '0') && (source[sp] <= '9')) {
+ edi_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if ((source[sp] >= 'A') && (source[sp] <= 'Z')) {
+ edi_count += (2.0 / 3.0);
+ done = 1;
+ }
+ if (source[sp] > 127) {
+ edi_count += (13.0 / 3.0);
+ } else {
+ if (done == 0) {
+ edi_count += (10.0 / 3.0);
+ }
+ }
+
+ /* Step P */
+ if ((inputDataType == DataType.GS1) && (source[sp] == '[')) {
+ byte_count += 3.0;
+ } else {
+ byte_count += 1.0;
+ }
+
+ }
+
+ ascii_count = roundUpToNextInteger(ascii_count);
+ c40_count = roundUpToNextInteger(c40_count);
+ text_count = roundUpToNextInteger(text_count);
+ edi_count = roundUpToNextInteger(edi_count);
+ byte_count = roundUpToNextInteger(byte_count);
+ best_scheme = c1Mode.C1_ASCII;
+
+ if (sp == sourcelen) {
+ /* Step K */
+ best_count = (int) edi_count;
+
+ if (text_count <= best_count) {
+ best_count = (int) text_count;
+ best_scheme = c1Mode.C1_TEXT;
+ }
+
+ if (c40_count <= best_count) {
+ best_count = (int) c40_count;
+ best_scheme = c1Mode.C1_C40;
+ }
+
+ if (ascii_count <= best_count) {
+ best_count = (int) ascii_count;
+ best_scheme = c1Mode.C1_ASCII;
+ }
+
+ if (byte_count <= best_count) {
+ best_scheme = c1Mode.C1_BYTE;
+ }
+ } else {
+ /* Step Q */
+
+ if (((edi_count + 1.0 <= ascii_count)
+ && (edi_count + 1.0 <= c40_count))
+ && ((edi_count + 1.0 <= byte_count)
+ && (edi_count + 1.0 <= text_count))) {
+ best_scheme = c1Mode.C1_EDI;
+ }
+
+ if ((c40_count + 1.0 <= ascii_count)
+ && (c40_count + 1.0 <= text_count)) {
+
+ if (c40_count < edi_count) {
+ best_scheme = c1Mode.C1_C40;
+ } else {
+ if (c40_count == edi_count) {
+ if (preferEdi(sourcelen, position)) {
+ best_scheme = c1Mode.C1_EDI;
+ } else {
+ best_scheme = c1Mode.C1_C40;
+ }
+ }
+ }
+ }
+
+ if (((text_count + 1.0 <= ascii_count)
+ && (text_count + 1.0 <= c40_count))
+ && ((text_count + 1.0 <= byte_count)
+ && (text_count + 1.0 <= edi_count))) {
+ best_scheme = c1Mode.C1_TEXT;
+ }
+
+ if (((ascii_count + 1.0 <= byte_count)
+ && (ascii_count + 1.0 <= c40_count))
+ && ((ascii_count + 1.0 <= text_count)
+ && (ascii_count + 1.0 <= edi_count))) {
+ best_scheme = c1Mode.C1_ASCII;
+ }
+
+ if (((byte_count + 1.0 <= ascii_count)
+ && (byte_count + 1.0 <= c40_count))
+ && ((byte_count + 1.0 <= text_count)
+ && (byte_count + 1.0 <= edi_count))) {
+ best_scheme = c1Mode.C1_BYTE;
+ }
+ }
+ return best_scheme;
+ }
+
+ private double roundUpToNextInteger(double input) {
+ double fraction, output;
+
+ fraction = input - (int) input;
+ if (fraction > 0.01) {
+ output = (input - fraction) + 1.0;
+ } else {
+ output = input;
+ }
+
+ return output;
+ }
+
+ private boolean preferEdi(int sourcelen, int position) {
+ int i;
+
+ for (i = position; isEdiEncodable(source[position + i])
+ && ((position + i) < sourcelen); i++) {
+ ;
+ }
+
+ if ((position + i) == sourcelen) {
+ /* Reached end of input */
+ return false;
+ }
+
+ if (source[position + i - 1] == 13) {
+ return true;
+ }
+ if (source[position + i - 1] == '*') {
+ return true;
+ }
+ if (source[position + i - 1] == '>') {
+ return true;
+ }
+
+ return false;
+ }
+
+ private boolean isEdiEncodable(int input) {
+ boolean result = false;
+
+ if (input == 13) {
+ result = true;
+ }
+ if (input == '*') {
+ result = true;
+ }
+ if (input == '>') {
+ result = true;
+ }
+ if (input == ' ') {
+ result = true;
+ }
+ if ((input >= '0') && (input <= '9')) {
+ result = true;
+ }
+ if ((input >= 'A') && (input <= 'Z')) {
+ result = true;
+ }
+
+ return result;
+ }
+
+ private void plotCentralFinder(int start_row, int row_count, int full_rows) {
+ int i;
+
+ for (i = 0; i < row_count; i++) {
+ if (i < full_rows) {
+ plotHorizontalBar(start_row + (i * 2), 1);
+ } else {
+ plotHorizontalBar(start_row + (i * 2), 0);
+ if (i != row_count - 1) {
+ setGridModule(start_row + (i * 2) + 1, 1);
+ setGridModule(start_row + (i * 2) + 1, symbolWidth - 2);
+ }
+ }
+ }
+ }
+
+ private void plotHorizontalBar(int row_no, int full) {
+ int i;
+
+ if (full != 0) {
+ for (i = 0; i < symbolWidth; i++) {
+ setGridModule(row_no, i);
+ }
+ } else {
+ for (i = 1; i < symbolWidth - 1; i++) {
+ setGridModule(row_no, i);
+ }
+ }
+ }
+
+ private void plotVerticalBar(int column, int height, int top) {
+ int i;
+
+ if (top != 0) {
+ for (i = 0; i < height; i++) {
+ setGridModule(i, column);
+ }
+ } else {
+ for (i = 0; i < height; i++) {
+ setGridModule(rowCount - i - 1, column);
+ }
+ }
+ }
+
+ private void plotSpigot(int row_no) {
+ int i;
+
+ for (i = symbolWidth - 1; i > 0; i--) {
+ if (outputGrid[row_no][i - 1]) {
+ setGridModule(row_no, i);
+ }
+ }
+ }
+
+ private void plotDataBlock(int start_row, int start_col, int height,
+ int width, int row_offset, int col_offset) {
+ int i, j;
+
+ for (i = start_row; i < (start_row + height); i++) {
+ for (j = start_col; j < (start_col + width); j++) {
+ if (datagrid[i][j] == '1') {
+ setGridModule(i + row_offset, j + col_offset);
+ }
+ }
+ }
+ }
+
+ private void setGridModule(int row, int column) {
+ outputGrid[row][column] = true;
+ }
+
+ private void resetGridModule(int row, int column) {
+ outputGrid[row][column] = false;
+ }
+
+ private int getSize(Version version) {
+ int size = 0;
+
+ switch (version) {
+ case A:
+ size = 1;
+ break;
+ case B:
+ size = 2;
+ break;
+ case C:
+ size = 3;
+ break;
+ case D:
+ size = 4;
+ break;
+ case E:
+ size = 5;
+ break;
+ case F:
+ size = 6;
+ break;
+ case G:
+ size = 7;
+ break;
+ case H:
+ size = 8;
+ break;
+ }
+
+ return size;
+ }
+
+ private enum c1Mode {
+ C1_ASCII, C1_C40, C1_DECIMAL, C1_TEXT, C1_EDI, C1_BYTE
+ }
+
+ public enum Version {
+ NONE, A, B, C, D, E, F, G, H, S, T
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/Composite.java b/barcode/src/main/java/org/xbib/graphics/barcode/Composite.java
new file mode 100755
index 0000000..fd0ef27
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/Composite.java
@@ -0,0 +1,2846 @@
+package org.xbib.graphics.barcode;
+
+import org.xbib.graphics.barcode.util.TextBox;
+import java.awt.geom.Rectangle2D;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Implements GS1 Composite symbology according to ISO/IEC 24723:2010.
+ * Composite symbols comprise a 2D element which encodes GS1 data
+ * and a "linear" element which can be UPC, EAN, Code 128 or
+ * GS1 DataBar symbol.
+ */
+public class Composite extends Symbol {
+ /* CC-A component coefficients from ISO/IEC 24728:2006 Annex F */
+ private int[] ccaCoeffs = {
+ /* k = 4 */
+ 522, 568, 723, 809,
+ /* k = 5 */
+ 427, 919, 460, 155, 566,
+ /* k = 6 */
+ 861, 285, 19, 803, 17, 766,
+ /* k = 7 */
+ 76, 925, 537, 597, 784, 691, 437,
+ /* k = 8 */
+ 237, 308, 436, 284, 646, 653, 428, 379
+ };
+ private int[] coefrs = {
+ /* k = 2 */
+ 27, 917,
+ /* k = 4 */
+ 522, 568, 723, 809,
+ /* k = 8 */
+ 237, 308, 436, 284, 646, 653, 428, 379,
+ /* k = 16 */
+ 274, 562, 232, 755, 599, 524, 801, 132, 295, 116, 442, 428, 295, 42, 176, 65,
+ /* k = 32 */
+ 361, 575, 922, 525, 176, 586, 640, 321, 536, 742, 677, 742, 687, 284, 193, 517,
+ 273, 494, 263, 147, 593, 800, 571, 320, 803, 133, 231, 390, 685, 330, 63, 410,
+ /* k = 64 */
+ 539, 422, 6, 93, 862, 771, 453, 106, 610, 287, 107, 505, 733, 877, 381, 612,
+ 723, 476, 462, 172, 430, 609, 858, 822, 543, 376, 511, 400, 672, 762, 283, 184,
+ 440, 35, 519, 31, 460, 594, 225, 535, 517, 352, 605, 158, 651, 201, 488, 502,
+ 648, 733, 717, 83, 404, 97, 280, 771, 840, 629, 4, 381, 843, 623, 264, 543,
+ /* k = 128 */
+ 521, 310, 864, 547, 858, 580, 296, 379, 53, 779, 897, 444, 400, 925, 749, 415,
+ 822, 93, 217, 208, 928, 244, 583, 620, 246, 148, 447, 631, 292, 908, 490, 704,
+ 516, 258, 457, 907, 594, 723, 674, 292, 272, 96, 684, 432, 686, 606, 860, 569,
+ 193, 219, 129, 186, 236, 287, 192, 775, 278, 173, 40, 379, 712, 463, 646, 776,
+ 171, 491, 297, 763, 156, 732, 95, 270, 447, 90, 507, 48, 228, 821, 808, 898,
+ 784, 663, 627, 378, 382, 262, 380, 602, 754, 336, 89, 614, 87, 432, 670, 616,
+ 157, 374, 242, 726, 600, 269, 375, 898, 845, 454, 354, 130, 814, 587, 804, 34,
+ 211, 330, 539, 297, 827, 865, 37, 517, 834, 315, 550, 86, 801, 4, 108, 539,
+ /* k = 256 */
+ 524, 894, 75, 766, 882, 857, 74, 204, 82, 586, 708, 250, 905, 786, 138, 720,
+ 858, 194, 311, 913, 275, 190, 375, 850, 438, 733, 194, 280, 201, 280, 828, 757,
+ 710, 814, 919, 89, 68, 569, 11, 204, 796, 605, 540, 913, 801, 700, 799, 137,
+ 439, 418, 592, 668, 353, 859, 370, 694, 325, 240, 216, 257, 284, 549, 209, 884,
+ 315, 70, 329, 793, 490, 274, 877, 162, 749, 812, 684, 461, 334, 376, 849, 521,
+ 307, 291, 803, 712, 19, 358, 399, 908, 103, 511, 51, 8, 517, 225, 289, 470,
+ 637, 731, 66, 255, 917, 269, 463, 830, 730, 433, 848, 585, 136, 538, 906, 90,
+ 2, 290, 743, 199, 655, 903, 329, 49, 802, 580, 355, 588, 188, 462, 10, 134,
+ 628, 320, 479, 130, 739, 71, 263, 318, 374, 601, 192, 605, 142, 673, 687, 234,
+ 722, 384, 177, 752, 607, 640, 455, 193, 689, 707, 805, 641, 48, 60, 732, 621,
+ 895, 544, 261, 852, 655, 309, 697, 755, 756, 60, 231, 773, 434, 421, 726, 528,
+ 503, 118, 49, 795, 32, 144, 500, 238, 836, 394, 280, 566, 319, 9, 647, 550,
+ 73, 914, 342, 126, 32, 681, 331, 792, 620, 60, 609, 441, 180, 791, 893, 754,
+ 605, 383, 228, 749, 760, 213, 54, 297, 134, 54, 834, 299, 922, 191, 910, 532,
+ 609, 829, 189, 20, 167, 29, 872, 449, 83, 402, 41, 656, 505, 579, 481, 173,
+ 404, 251, 688, 95, 497, 555, 642, 543, 307, 159, 924, 558, 648, 55, 497, 10,
+ /* k = 512 */
+ 352, 77, 373, 504, 35, 599, 428, 207, 409, 574, 118, 498, 285, 380, 350, 492,
+ 197, 265, 920, 155, 914, 299, 229, 643, 294, 871, 306, 88, 87, 193, 352, 781,
+ 846, 75, 327, 520, 435, 543, 203, 666, 249, 346, 781, 621, 640, 268, 794, 534,
+ 539, 781, 408, 390, 644, 102, 476, 499, 290, 632, 545, 37, 858, 916, 552, 41,
+ 542, 289, 122, 272, 383, 800, 485, 98, 752, 472, 761, 107, 784, 860, 658, 741,
+ 290, 204, 681, 407, 855, 85, 99, 62, 482, 180, 20, 297, 451, 593, 913, 142,
+ 808, 684, 287, 536, 561, 76, 653, 899, 729, 567, 744, 390, 513, 192, 516, 258,
+ 240, 518, 794, 395, 768, 848, 51, 610, 384, 168, 190, 826, 328, 596, 786, 303,
+ 570, 381, 415, 641, 156, 237, 151, 429, 531, 207, 676, 710, 89, 168, 304, 402,
+ 40, 708, 575, 162, 864, 229, 65, 861, 841, 512, 164, 477, 221, 92, 358, 785,
+ 288, 357, 850, 836, 827, 736, 707, 94, 8, 494, 114, 521, 2, 499, 851, 543,
+ 152, 729, 771, 95, 248, 361, 578, 323, 856, 797, 289, 51, 684, 466, 533, 820,
+ 669, 45, 902, 452, 167, 342, 244, 173, 35, 463, 651, 51, 699, 591, 452, 578,
+ 37, 124, 298, 332, 552, 43, 427, 119, 662, 777, 475, 850, 764, 364, 578, 911,
+ 283, 711, 472, 420, 245, 288, 594, 394, 511, 327, 589, 777, 699, 688, 43, 408,
+ 842, 383, 721, 521, 560, 644, 714, 559, 62, 145, 873, 663, 713, 159, 672, 729,
+ 624, 59, 193, 417, 158, 209, 563, 564, 343, 693, 109, 608, 563, 365, 181, 772,
+ 677, 310, 248, 353, 708, 410, 579, 870, 617, 841, 632, 860, 289, 536, 35, 777,
+ 618, 586, 424, 833, 77, 597, 346, 269, 757, 632, 695, 751, 331, 247, 184, 45,
+ 787, 680, 18, 66, 407, 369, 54, 492, 228, 613, 830, 922, 437, 519, 644, 905,
+ 789, 420, 305, 441, 207, 300, 892, 827, 141, 537, 381, 662, 513, 56, 252, 341,
+ 242, 797, 838, 837, 720, 224, 307, 631, 61, 87, 560, 310, 756, 665, 397, 808,
+ 851, 309, 473, 795, 378, 31, 647, 915, 459, 806, 590, 731, 425, 216, 548, 249,
+ 321, 881, 699, 535, 673, 782, 210, 815, 905, 303, 843, 922, 281, 73, 469, 791,
+ 660, 162, 498, 308, 155, 422, 907, 817, 187, 62, 16, 425, 535, 336, 286, 437,
+ 375, 273, 610, 296, 183, 923, 116, 667, 751, 353, 62, 366, 691, 379, 687, 842,
+ 37, 357, 720, 742, 330, 5, 39, 923, 311, 424, 242, 749, 321, 54, 669, 316,
+ 342, 299, 534, 105, 667, 488, 640, 672, 576, 540, 316, 486, 721, 610, 46, 656,
+ 447, 171, 616, 464, 190, 531, 297, 321, 762, 752, 533, 175, 134, 14, 381, 433,
+ 717, 45, 111, 20, 596, 284, 736, 138, 646, 411, 877, 669, 141, 919, 45, 780,
+ 407, 164, 332, 899, 165, 726, 600, 325, 498, 655, 357, 752, 768, 223, 849, 647,
+ 63, 310, 863, 251, 366, 304, 282, 738, 675, 410, 389, 244, 31, 121, 303, 263
+ };
+
+ /* rows, error codewords, k-offset of valid CC-A sizes from ISO/IEC 24723:2006 Table 9 */
+ private int[] ccaVariants = {
+ 5, 6, 7, 8, 9, 10, 12, 4, 5, 6, 7, 8, 3, 4, 5, 6, 7, 4, 4, 5, 5, 6, 6, 7, 4, 5, 6, 7, 7, 4, 5, 6, 7, 8, 0, 0, 4, 4, 9, 9, 15, 0, 4, 9, 15, 15, 0, 4, 9, 15, 22
+ };
+
+ /* following is Left RAP, Centre RAP, Right RAP and Start Cluster from ISO/IEC 24723:2006 tables 10 and 11 */
+ private int[] aRAPTable = {
+ 39, 1, 32, 8, 14, 43, 20, 11, 1, 5, 15, 21, 40, 43, 46, 34, 29, 0, 0, 0, 0, 0, 0, 0, 43, 33, 37, 47, 1, 20, 23, 26, 14, 9, 19, 33, 12, 40, 46, 23, 52, 23, 13, 17, 27, 33, 52, 3, 6, 46, 41, 6, 0, 3, 3, 3, 0, 3, 3, 0, 3, 6, 6, 0, 0, 0, 0, 3
+ };
+ private String[] codagemc = {
+ "urA", "xfs", "ypy", "unk", "xdw", "yoz", "pDA", "uls", "pBk", "eBA",
+ "pAs", "eAk", "prA", "uvs", "xhy", "pnk", "utw", "xgz", "fDA", "pls", "fBk", "frA", "pvs",
+ "uxy", "fnk", "ptw", "uwz", "fls", "psy", "fvs", "pxy", "ftw", "pwz", "fxy", "yrx", "ufk",
+ "xFw", "ymz", "onA", "uds", "xEy", "olk", "ucw", "dBA", "oks", "uci", "dAk", "okg", "dAc",
+ "ovk", "uhw", "xaz", "dnA", "ots", "ugy", "dlk", "osw", "ugj", "dks", "osi", "dvk", "oxw",
+ "uiz", "dts", "owy", "dsw", "owj", "dxw", "oyz", "dwy", "dwj", "ofA", "uFs", "xCy", "odk",
+ "uEw", "xCj", "clA", "ocs", "uEi", "ckk", "ocg", "ckc", "ckE", "cvA", "ohs", "uay", "ctk",
+ "ogw", "uaj", "css", "ogi", "csg", "csa", "cxs", "oiy", "cww", "oij", "cwi", "cyy", "oFk",
+ "uCw", "xBj", "cdA", "oEs", "uCi", "cck", "oEg", "uCb", "ccc", "oEa", "ccE", "oED", "chk",
+ "oaw", "uDj", "cgs", "oai", "cgg", "oab", "cga", "cgD", "obj", "cib", "cFA", "oCs", "uBi",
+ "cEk", "oCg", "uBb", "cEc", "oCa", "cEE", "oCD", "cEC", "cas", "cag", "caa", "cCk", "uAr",
+ "oBa", "oBD", "cCB", "tfk", "wpw", "yez", "mnA", "tds", "woy", "mlk", "tcw", "woj", "FBA",
+ "mks", "FAk", "mvk", "thw", "wqz", "FnA", "mts", "tgy", "Flk", "msw", "Fks", "Fkg", "Fvk",
+ "mxw", "tiz", "Fts", "mwy", "Fsw", "Fsi", "Fxw", "myz", "Fwy", "Fyz", "vfA", "xps", "yuy",
+ "vdk", "xow", "yuj", "qlA", "vcs", "xoi", "qkk", "vcg", "xob", "qkc", "vca", "mfA", "tFs",
+ "wmy", "qvA", "mdk", "tEw", "wmj", "qtk", "vgw", "xqj", "hlA", "Ekk", "mcg", "tEb", "hkk",
+ "qsg", "hkc", "EvA", "mhs", "tay", "hvA", "Etk", "mgw", "taj", "htk", "qww", "vij", "hss",
+ "Esg", "hsg", "Exs", "miy", "hxs", "Eww", "mij", "hww", "qyj", "hwi", "Eyy", "hyy", "Eyj",
+ "hyj", "vFk", "xmw", "ytj", "qdA", "vEs", "xmi", "qck", "vEg", "xmb", "qcc", "vEa", "qcE",
+ "qcC", "mFk", "tCw", "wlj", "qhk", "mEs", "tCi", "gtA", "Eck", "vai", "tCb", "gsk", "Ecc",
+ "mEa", "gsc", "qga", "mED", "EcC", "Ehk", "maw", "tDj", "gxk", "Egs", "mai", "gws", "qii",
+ "mab", "gwg", "Ega", "EgD", "Eiw", "mbj", "gyw", "Eii", "gyi", "Eib", "gyb", "gzj", "qFA",
+ "vCs", "xli", "qEk", "vCg", "xlb", "qEc", "vCa", "qEE", "vCD", "qEC", "qEB", "EFA", "mCs",
+ "tBi", "ghA", "EEk", "mCg", "tBb", "ggk", "qag", "vDb", "ggc", "EEE", "mCD", "ggE", "qaD",
+ "ggC", "Eas", "mDi", "gis", "Eag", "mDb", "gig", "qbb", "gia", "EaD", "giD", "gji", "gjb",
+ "qCk", "vBg", "xkr", "qCc", "vBa", "qCE", "vBD", "qCC", "qCB", "ECk", "mBg", "tAr", "gak",
+ "ECc", "mBa", "gac", "qDa", "mBD", "gaE", "ECC", "gaC", "ECB", "EDg", "gbg", "gba", "gbD",
+ "vAq", "vAn", "qBB", "mAq", "EBE", "gDE", "gDC", "gDB", "lfA", "sps", "wey", "ldk", "sow",
+ "ClA", "lcs", "soi", "Ckk", "lcg", "Ckc", "CkE", "CvA", "lhs", "sqy", "Ctk", "lgw", "sqj",
+ "Css", "lgi", "Csg", "Csa", "Cxs", "liy", "Cww", "lij", "Cwi", "Cyy", "Cyj", "tpk", "wuw",
+ "yhj", "ndA", "tos", "wui", "nck", "tog", "wub", "ncc", "toa", "ncE", "toD", "lFk", "smw",
+ "wdj", "nhk", "lEs", "smi", "atA", "Cck", "tqi", "smb", "ask", "ngg", "lEa", "asc", "CcE",
+ "asE", "Chk", "law", "snj", "axk", "Cgs", "trj", "aws", "nii", "lab", "awg", "Cga", "awa",
+ "Ciw", "lbj", "ayw", "Cii", "ayi", "Cib", "Cjj", "azj", "vpA", "xus", "yxi", "vok", "xug",
+ "yxb", "voc", "xua", "voE", "xuD", "voC", "nFA", "tms", "wti", "rhA", "nEk", "xvi", "wtb",
+ "rgk", "vqg", "xvb", "rgc", "nEE", "tmD", "rgE", "vqD", "nEB", "CFA", "lCs", "sli", "ahA",
+ "CEk", "lCg", "slb", "ixA", "agk", "nag", "tnb", "iwk", "rig", "vrb", "lCD", "iwc", "agE",
+ "naD", "iwE", "CEB", "Cas", "lDi", "ais", "Cag", "lDb", "iys", "aig", "nbb", "iyg", "rjb",
+ "CaD", "aiD", "Cbi", "aji", "Cbb", "izi", "ajb", "vmk", "xtg", "ywr", "vmc", "xta", "vmE",
+ "xtD", "vmC", "vmB", "nCk", "tlg", "wsr", "rak", "nCc", "xtr", "rac", "vna", "tlD", "raE",
+ "nCC", "raC", "nCB", "raB", "CCk", "lBg", "skr", "aak", "CCc", "lBa", "iik", "aac", "nDa",
+ "lBD", "iic", "rba", "CCC", "iiE", "aaC", "CCB", "aaB", "CDg", "lBr", "abg", "CDa", "ijg",
+ "aba", "CDD", "ija", "abD", "CDr", "ijr", "vlc", "xsq", "vlE", "xsn", "vlC", "vlB", "nBc",
+ "tkq", "rDc", "nBE", "tkn", "rDE", "vln", "rDC", "nBB", "rDB", "CBc", "lAq", "aDc", "CBE",
+ "lAn", "ibc", "aDE", "nBn", "ibE", "rDn", "CBB", "ibC", "aDB", "ibB", "aDq", "ibq", "ibn",
+ "xsf", "vkl", "tkf", "nAm", "nAl", "CAo", "aBo", "iDo", "CAl", "aBl", "kpk", "BdA", "kos",
+ "Bck", "kog", "seb", "Bcc", "koa", "BcE", "koD", "Bhk", "kqw", "sfj", "Bgs", "kqi", "Bgg",
+ "kqb", "Bga", "BgD", "Biw", "krj", "Bii", "Bib", "Bjj", "lpA", "sus", "whi", "lok", "sug",
+ "loc", "sua", "loE", "suD", "loC", "BFA", "kms", "sdi", "DhA", "BEk", "svi", "sdb", "Dgk",
+ "lqg", "svb", "Dgc", "BEE", "kmD", "DgE", "lqD", "BEB", "Bas", "kni", "Dis", "Bag", "knb",
+ "Dig", "lrb", "Dia", "BaD", "Bbi", "Dji", "Bbb", "Djb", "tuk", "wxg", "yir", "tuc", "wxa",
+ "tuE", "wxD", "tuC", "tuB", "lmk", "stg", "nqk", "lmc", "sta", "nqc", "tva", "stD", "nqE",
+ "lmC", "nqC", "lmB", "nqB", "BCk", "klg", "Dak", "BCc", "str", "bik", "Dac", "lna", "klD",
+ "bic", "nra", "BCC", "biE", "DaC", "BCB", "DaB", "BDg", "klr", "Dbg", "BDa", "bjg", "Dba",
+ "BDD", "bja", "DbD", "BDr", "Dbr", "bjr", "xxc", "yyq", "xxE", "yyn", "xxC", "xxB", "ttc",
+ "wwq", "vvc", "xxq", "wwn", "vvE", "xxn", "vvC", "ttB", "vvB", "llc", "ssq", "nnc", "llE",
+ "ssn", "rrc", "nnE", "ttn", "rrE", "vvn", "llB", "rrC", "nnB", "rrB", "BBc", "kkq", "DDc",
+ "BBE", "kkn", "bbc", "DDE", "lln", "jjc", "bbE", "nnn", "BBB", "jjE", "rrn", "DDB", "jjC",
+ "BBq", "DDq", "BBn", "bbq", "DDn", "jjq", "bbn", "jjn", "xwo", "yyf", "xwm", "xwl", "tso",
+ "wwf", "vto", "xwv", "vtm", "tsl", "vtl", "lko", "ssf", "nlo", "lkm", "rno", "nlm", "lkl",
+ "rnm", "nll", "rnl", "BAo", "kkf", "DBo", "lkv", "bDo", "DBm", "BAl", "jbo", "bDm", "DBl",
+ "jbm", "bDl", "jbl", "DBv", "jbv", "xwd", "vsu", "vst", "nku", "rlu", "rlt", "DAu", "bBu",
+ "jDu", "jDt", "ApA", "Aok", "keg", "Aoc", "AoE", "AoC", "Aqs", "Aqg", "Aqa", "AqD", "Ari",
+ "Arb", "kuk", "kuc", "sha", "kuE", "shD", "kuC", "kuB", "Amk", "kdg", "Bqk", "kvg", "kda",
+ "Bqc", "kva", "BqE", "kvD", "BqC", "AmB", "BqB", "Ang", "kdr", "Brg", "kvr", "Bra", "AnD",
+ "BrD", "Anr", "Brr", "sxc", "sxE", "sxC", "sxB", "ktc", "lvc", "sxq", "sgn", "lvE", "sxn",
+ "lvC", "ktB", "lvB", "Alc", "Bnc", "AlE", "kcn", "Drc", "BnE", "AlC", "DrE", "BnC", "AlB",
+ "DrC", "BnB", "Alq", "Bnq", "Aln", "Drq", "Bnn", "Drn", "wyo", "wym", "wyl", "swo", "txo",
+ "wyv", "txm", "swl", "txl", "kso", "sgf", "lto", "swv", "nvo", "ltm", "ksl", "nvm", "ltl",
+ "nvl", "Ako", "kcf", "Blo", "ksv", "Dno", "Blm", "Akl", "bro", "Dnm", "Bll", "brm", "Dnl",
+ "Akv", "Blv", "Dnv", "brv", "yze", "yzd", "wye", "xyu", "wyd", "xyt", "swe", "twu", "swd",
+ "vxu", "twt", "vxt", "kse", "lsu", "ksd", "ntu", "lst", "rvu", "ypk", "zew", "xdA", "yos",
+ "zei", "xck", "yog", "zeb", "xcc", "yoa", "xcE", "yoD", "xcC", "xhk", "yqw", "zfj", "utA",
+ "xgs", "yqi", "usk", "xgg", "yqb", "usc", "xga", "usE", "xgD", "usC", "uxk", "xiw", "yrj",
+ "ptA", "uws", "xii", "psk", "uwg", "xib", "psc", "uwa", "psE", "uwD", "psC", "pxk", "uyw",
+ "xjj", "ftA", "pws", "uyi", "fsk", "pwg", "uyb", "fsc", "pwa", "fsE", "pwD", "fxk", "pyw",
+ "uzj", "fws", "pyi", "fwg", "pyb", "fwa", "fyw", "pzj", "fyi", "fyb", "xFA", "yms", "zdi",
+ "xEk", "ymg", "zdb", "xEc", "yma", "xEE", "ymD", "xEC", "xEB", "uhA", "xas", "yni", "ugk",
+ "xag", "ynb", "ugc", "xaa", "ugE", "xaD", "ugC", "ugB", "oxA", "uis", "xbi", "owk", "uig",
+ "xbb", "owc", "uia", "owE", "uiD", "owC", "owB", "dxA", "oys", "uji", "dwk", "oyg", "ujb",
+ "dwc", "oya", "dwE", "oyD", "dwC", "dys", "ozi", "dyg", "ozb", "dya", "dyD", "dzi", "dzb",
+ "xCk", "ylg", "zcr", "xCc", "yla", "xCE", "ylD", "xCC", "xCB", "uak", "xDg", "ylr", "uac",
+ "xDa", "uaE", "xDD", "uaC", "uaB", "oik", "ubg", "xDr", "oic", "uba", "oiE", "ubD", "oiC",
+ "oiB", "cyk", "ojg", "ubr", "cyc", "oja", "cyE", "ojD", "cyC", "cyB", "czg", "ojr", "cza",
+ "czD", "czr", "xBc", "ykq", "xBE", "ykn", "xBC", "xBB", "uDc", "xBq", "uDE", "xBn", "uDC",
+ "uDB", "obc", "uDq", "obE", "uDn", "obC", "obB", "cjc", "obq", "cjE", "obn", "cjC", "cjB",
+ "cjq", "cjn", "xAo", "ykf", "xAm", "xAl", "uBo", "xAv", "uBm", "uBl", "oDo", "uBv", "oDm",
+ "oDl", "cbo", "oDv", "cbm", "cbl", "xAe", "xAd", "uAu", "uAt", "oBu", "oBt", "wpA", "yes",
+ "zFi", "wok", "yeg", "zFb", "woc", "yea", "woE", "yeD", "woC", "woB", "thA", "wqs", "yfi",
+ "tgk", "wqg", "yfb", "tgc", "wqa", "tgE", "wqD", "tgC", "tgB", "mxA", "tis", "wri", "mwk",
+ "tig", "wrb", "mwc", "tia", "mwE", "tiD", "mwC", "mwB", "FxA", "mys", "tji", "Fwk", "myg",
+ "tjb", "Fwc", "mya", "FwE", "myD", "FwC", "Fys", "mzi", "Fyg", "mzb", "Fya", "FyD", "Fzi",
+ "Fzb", "yuk", "zhg", "hjs", "yuc", "zha", "hbw", "yuE", "zhD", "hDy", "yuC", "yuB", "wmk",
+ "ydg", "zEr", "xqk", "wmc", "zhr", "xqc", "yva", "ydD", "xqE", "wmC", "xqC", "wmB", "xqB",
+ "tak", "wng", "ydr", "vik", "tac", "wna", "vic", "xra", "wnD", "viE", "taC", "viC", "taB",
+ "viB", "mik", "tbg", "wnr", "qyk", "mic", "tba", "qyc", "vja", "tbD", "qyE", "miC", "qyC",
+ "miB", "qyB", "Eyk", "mjg", "tbr", "hyk", "Eyc", "mja", "hyc", "qza", "mjD", "hyE", "EyC",
+ "hyC", "EyB", "Ezg", "mjr", "hzg", "Eza", "hza", "EzD", "hzD", "Ezr", "ytc", "zgq", "grw",
+ "ytE", "zgn", "gny", "ytC", "glz", "ytB", "wlc", "ycq", "xnc", "wlE", "ycn", "xnE", "ytn",
+ "xnC", "wlB", "xnB", "tDc", "wlq", "vbc", "tDE", "wln", "vbE", "xnn", "vbC", "tDB", "vbB",
+ "mbc", "tDq", "qjc", "mbE", "tDn", "qjE", "vbn", "qjC", "mbB", "qjB", "Ejc", "mbq", "gzc",
+ "EjE", "mbn", "gzE", "qjn", "gzC", "EjB", "gzB", "Ejq", "gzq", "Ejn", "gzn", "yso", "zgf",
+ "gfy", "ysm", "gdz", "ysl", "wko", "ycf", "xlo", "ysv", "xlm", "wkl", "xll", "tBo", "wkv",
+ "vDo", "tBm", "vDm", "tBl", "vDl", "mDo", "tBv", "qbo", "vDv", "qbm", "mDl", "qbl", "Ebo",
+ "mDv", "gjo", "Ebm", "gjm", "Ebl", "gjl", "Ebv", "gjv", "yse", "gFz", "ysd", "wke", "xku",
+ "wkd", "xkt", "tAu", "vBu", "tAt", "vBt", "mBu", "qDu", "mBt", "qDt", "EDu", "gbu", "EDt",
+ "gbt", "ysF", "wkF", "xkh", "tAh", "vAx", "mAx", "qBx", "wek", "yFg", "zCr", "wec", "yFa",
+ "weE", "yFD", "weC", "weB", "sqk", "wfg", "yFr", "sqc", "wfa", "sqE", "wfD", "sqC", "sqB",
+ "lik", "srg", "wfr", "lic", "sra", "liE", "srD", "liC", "liB", "Cyk", "ljg", "srr", "Cyc",
+ "lja", "CyE", "ljD", "CyC", "CyB", "Czg", "ljr", "Cza", "CzD", "Czr", "yhc", "zaq", "arw",
+ "yhE", "zan", "any", "yhC", "alz", "yhB", "wdc", "yEq", "wvc", "wdE", "yEn", "wvE", "yhn",
+ "wvC", "wdB", "wvB", "snc", "wdq", "trc", "snE", "wdn", "trE", "wvn", "trC", "snB", "trB",
+ "lbc", "snq", "njc", "lbE", "snn", "njE", "trn", "njC", "lbB", "njB", "Cjc", "lbq", "azc",
+ "CjE", "lbn", "azE", "njn", "azC", "CjB", "azB", "Cjq", "azq", "Cjn", "azn", "zio", "irs",
+ "rfy", "zim", "inw", "rdz", "zil", "ily", "ikz", "ygo", "zaf", "afy", "yxo", "ziv", "ivy",
+ "adz", "yxm", "ygl", "itz", "yxl", "wco", "yEf", "wto", "wcm", "xvo", "yxv", "wcl", "xvm",
+ "wtl", "xvl", "slo", "wcv", "tno", "slm", "vro", "tnm", "sll", "vrm", "tnl", "vrl", "lDo",
+ "slv", "nbo", "lDm", "rjo", "nbm", "lDl", "rjm", "nbl", "rjl", "Cbo", "lDv", "ajo", "Cbm",
+ "izo", "ajm", "Cbl", "izm", "ajl", "izl", "Cbv", "ajv", "zie", "ifw", "rFz", "zid", "idy",
+ "icz", "yge", "aFz", "ywu", "ygd", "ihz", "ywt", "wce", "wsu", "wcd", "xtu", "wst", "xtt",
+ "sku", "tlu", "skt", "vnu", "tlt", "vnt", "lBu", "nDu", "lBt", "rbu", "nDt", "rbt", "CDu",
+ "abu", "CDt", "iju", "abt", "ijt", "ziF", "iFy", "iEz", "ygF", "ywh", "wcF", "wsh", "xsx",
+ "skh", "tkx", "vlx", "lAx", "nBx", "rDx", "CBx", "aDx", "ibx", "iCz", "wFc", "yCq", "wFE",
+ "yCn", "wFC", "wFB", "sfc", "wFq", "sfE", "wFn", "sfC", "sfB", "krc", "sfq", "krE", "sfn",
+ "krC", "krB", "Bjc", "krq", "BjE", "krn", "BjC", "BjB", "Bjq", "Bjn", "yao", "zDf", "Dfy",
+ "yam", "Ddz", "yal", "wEo", "yCf", "who", "wEm", "whm", "wEl", "whl", "sdo", "wEv", "svo",
+ "sdm", "svm", "sdl", "svl", "kno", "sdv", "lro", "knm", "lrm", "knl", "lrl", "Bbo", "knv",
+ "Djo", "Bbm", "Djm", "Bbl", "Djl", "Bbv", "Djv", "zbe", "bfw", "npz", "zbd", "bdy", "bcz",
+ "yae", "DFz", "yiu", "yad", "bhz", "yit", "wEe", "wgu", "wEd", "wxu", "wgt", "wxt", "scu",
+ "stu", "sct", "tvu", "stt", "tvt", "klu", "lnu", "klt", "nru", "lnt", "nrt", "BDu", "Dbu",
+ "BDt", "bju", "Dbt", "bjt", "jfs", "rpy", "jdw", "roz", "jcy", "jcj", "zbF", "bFy", "zjh",
+ "jhy", "bEz", "jgz", "yaF", "yih", "yyx", "wEF", "wgh", "wwx", "xxx", "sch", "ssx", "ttx",
+ "vvx", "kkx", "llx", "nnx", "rrx", "BBx", "DDx", "bbx", "jFw", "rmz", "jEy", "jEj", "bCz",
+ "jaz", "jCy", "jCj", "jBj", "wCo", "wCm", "wCl", "sFo", "wCv", "sFm", "sFl", "kfo", "sFv",
+ "kfm", "kfl", "Aro", "kfv", "Arm", "Arl", "Arv", "yDe", "Bpz", "yDd", "wCe", "wau", "wCd",
+ "wat", "sEu", "shu", "sEt", "sht", "kdu", "kvu", "kdt", "kvt", "Anu", "Bru", "Ant", "Brt",
+ "zDp", "Dpy", "Doz", "yDF", "ybh", "wCF", "wah", "wix", "sEh", "sgx", "sxx", "kcx", "ktx",
+ "lvx", "Alx", "Bnx", "Drx", "bpw", "nuz", "boy", "boj", "Dmz", "bqz", "jps", "ruy", "jow",
+ "ruj", "joi", "job", "bmy", "jqy", "bmj", "jqj", "jmw", "rtj", "jmi", "jmb", "blj", "jnj",
+ "jli", "jlb", "jkr", "sCu", "sCt", "kFu", "kFt", "Afu", "Aft", "wDh", "sCh", "sax", "kEx",
+ "khx", "Adx", "Avx", "Buz", "Duy", "Duj", "buw", "nxj", "bui", "bub", "Dtj", "bvj", "jus",
+ "rxi", "jug", "rxb", "jua", "juD", "bti", "jvi", "btb", "jvb", "jtg", "rwr", "jta", "jtD",
+ "bsr", "jtr", "jsq", "jsn", "Bxj", "Dxi", "Dxb", "bxg", "nyr", "bxa", "bxD", "Dwr", "bxr",
+ "bwq", "bwn", "pjk", "urw", "ejA", "pbs", "uny", "ebk", "pDw", "ulz", "eDs", "pBy", "eBw",
+ "zfc", "fjk", "prw", "zfE", "fbs", "pny", "zfC", "fDw", "plz", "zfB", "fBy", "yrc", "zfq",
+ "frw", "yrE", "zfn", "fny", "yrC", "flz", "yrB", "xjc", "yrq", "xjE", "yrn", "xjC", "xjB",
+ "uzc", "xjq", "uzE", "xjn", "uzC", "uzB", "pzc", "uzq", "pzE", "uzn", "pzC", "djA", "ors",
+ "ufy", "dbk", "onw", "udz", "dDs", "oly", "dBw", "okz", "dAy", "zdo", "drs", "ovy", "zdm",
+ "dnw", "otz", "zdl", "dly", "dkz", "yno", "zdv", "dvy", "ynm", "dtz", "ynl", "xbo", "ynv",
+ "xbm", "xbl", "ujo", "xbv", "ujm", "ujl", "ozo", "ujv", "ozm", "ozl", "crk", "ofw", "uFz",
+ "cns", "ody", "clw", "ocz", "cky", "ckj", "zcu", "cvw", "ohz", "zct", "cty", "csz", "ylu",
+ "cxz", "ylt", "xDu", "xDt", "ubu", "ubt", "oju", "ojt", "cfs", "oFy", "cdw", "oEz", "ccy",
+ "ccj", "zch", "chy", "cgz", "ykx", "xBx", "uDx", "cFw", "oCz", "cEy", "cEj", "caz", "cCy",
+ "cCj", "FjA", "mrs", "tfy", "Fbk", "mnw", "tdz", "FDs", "mly", "FBw", "mkz", "FAy", "zFo",
+ "Frs", "mvy", "zFm", "Fnw", "mtz", "zFl", "Fly", "Fkz", "yfo", "zFv", "Fvy", "yfm", "Ftz",
+ "yfl", "wro", "yfv", "wrm", "wrl", "tjo", "wrv", "tjm", "tjl", "mzo", "tjv", "mzm", "mzl",
+ "qrk", "vfw", "xpz", "hbA", "qns", "vdy", "hDk", "qlw", "vcz", "hBs", "qky", "hAw", "qkj",
+ "hAi", "Erk", "mfw", "tFz", "hrk", "Ens", "mdy", "hns", "qty", "mcz", "hlw", "Eky", "hky",
+ "Ekj", "hkj", "zEu", "Evw", "mhz", "zhu", "zEt", "hvw", "Ety", "zht", "hty", "Esz", "hsz",
+ "ydu", "Exz", "yvu", "ydt", "hxz", "yvt", "wnu", "xru", "wnt", "xrt", "tbu", "vju", "tbt",
+ "vjt", "mju", "mjt", "grA", "qfs", "vFy", "gnk", "qdw", "vEz", "gls", "qcy", "gkw", "qcj",
+ "gki", "gkb", "Efs", "mFy", "gvs", "Edw", "mEz", "gtw", "qgz", "gsy", "Ecj", "gsj", "zEh",
+ "Ehy", "zgx", "gxy", "Egz", "gwz", "ycx", "ytx", "wlx", "xnx", "tDx", "vbx", "mbx", "gfk",
+ "qFw", "vCz", "gds", "qEy", "gcw", "qEj", "gci", "gcb", "EFw", "mCz", "ghw", "EEy", "ggy",
+ "EEj", "ggj", "Eaz", "giz", "gFs", "qCy", "gEw", "qCj", "gEi", "gEb", "ECy", "gay", "ECj",
+ "gaj", "gCw", "qBj", "gCi", "gCb", "EBj", "gDj", "gBi", "gBb", "Crk", "lfw", "spz", "Cns",
+ "ldy", "Clw", "lcz", "Cky", "Ckj", "zCu", "Cvw", "lhz", "zCt", "Cty", "Csz", "yFu", "Cxz",
+ "yFt", "wfu", "wft", "sru", "srt", "lju", "ljt", "arA", "nfs", "tpy", "ank", "ndw", "toz",
+ "als", "ncy", "akw", "ncj", "aki", "akb", "Cfs", "lFy", "avs", "Cdw", "lEz", "atw", "ngz",
+ "asy", "Ccj", "asj", "zCh", "Chy", "zax", "axy", "Cgz", "awz", "yEx", "yhx", "wdx", "wvx",
+ "snx", "trx", "lbx", "rfk", "vpw", "xuz", "inA", "rds", "voy", "ilk", "rcw", "voj", "iks",
+ "rci", "ikg", "rcb", "ika", "afk", "nFw", "tmz", "ivk", "ads", "nEy", "its", "rgy", "nEj",
+ "isw", "aci", "isi", "acb", "isb", "CFw", "lCz", "ahw", "CEy", "ixw", "agy", "CEj", "iwy",
+ "agj", "iwj", "Caz", "aiz", "iyz", "ifA", "rFs", "vmy", "idk", "rEw", "vmj", "ics", "rEi",
+ "icg", "rEb", "ica", "icD", "aFs", "nCy", "ihs", "aEw", "nCj", "igw", "raj", "igi", "aEb",
+ "igb", "CCy", "aay", "CCj", "iiy", "aaj", "iij", "iFk", "rCw", "vlj", "iEs", "rCi", "iEg",
+ "rCb", "iEa", "iED", "aCw", "nBj", "iaw", "aCi", "iai", "aCb", "iab", "CBj", "aDj", "ibj",
+ "iCs", "rBi", "iCg", "rBb", "iCa", "iCD", "aBi", "iDi", "aBb", "iDb", "iBg", "rAr", "iBa",
+ "iBD", "aAr", "iBr", "iAq", "iAn", "Bfs", "kpy", "Bdw", "koz", "Bcy", "Bcj", "Bhy", "Bgz",
+ "yCx", "wFx", "sfx", "krx", "Dfk", "lpw", "suz", "Dds", "loy", "Dcw", "loj", "Dci", "Dcb",
+ "BFw", "kmz", "Dhw", "BEy", "Dgy", "BEj", "Dgj", "Baz", "Diz", "bfA", "nps", "tuy", "bdk",
+ "now", "tuj", "bcs", "noi", "bcg", "nob", "bca", "bcD", "DFs", "lmy", "bhs", "DEw", "lmj",
+ "bgw", "DEi", "bgi", "DEb", "bgb", "BCy", "Day", "BCj", "biy", "Daj", "bij", "rpk", "vuw",
+ "xxj", "jdA", "ros", "vui", "jck", "rog", "vub", "jcc", "roa", "jcE", "roD", "jcC", "bFk",
+ "nmw", "ttj", "jhk", "bEs", "nmi", "jgs", "rqi", "nmb", "jgg", "bEa", "jga", "bED", "jgD",
+ "DCw", "llj", "baw", "DCi", "jiw", "bai", "DCb", "jii", "bab", "jib", "BBj", "DDj", "bbj",
+ "jjj", "jFA", "rms", "vti", "jEk", "rmg", "vtb", "jEc", "rma", "jEE", "rmD", "jEC", "jEB",
+ "bCs", "nli", "jas", "bCg", "nlb", "jag", "rnb", "jaa", "bCD", "jaD", "DBi", "bDi", "DBb",
+ "jbi", "bDb", "jbb", "jCk", "rlg", "vsr", "jCc", "rla", "jCE", "rlD", "jCC", "jCB", "bBg",
+ "nkr", "jDg", "bBa", "jDa", "bBD", "jDD", "DAr", "bBr", "jDr", "jBc", "rkq", "jBE", "rkn",
+ "jBC", "jBB", "bAq", "jBq", "bAn", "jBn", "jAo", "rkf", "jAm", "jAl", "bAf", "jAv", "Apw",
+ "kez", "Aoy", "Aoj", "Aqz", "Bps", "kuy", "Bow", "kuj", "Boi", "Bob", "Amy", "Bqy", "Amj",
+ "Bqj", "Dpk", "luw", "sxj", "Dos", "lui", "Dog", "lub", "Doa", "DoD", "Bmw", "ktj", "Dqw",
+ "Bmi", "Dqi", "Bmb", "Dqb", "Alj", "Bnj", "Drj", "bpA", "nus", "txi", "bok", "nug", "txb",
+ "boc", "nua", "boE", "nuD", "boC", "boB", "Dms", "lti", "bqs", "Dmg", "ltb", "bqg", "nvb",
+ "bqa", "DmD", "bqD", "Bli", "Dni", "Blb", "bri", "Dnb", "brb", "ruk", "vxg", "xyr", "ruc",
+ "vxa", "ruE", "vxD", "ruC", "ruB", "bmk", "ntg", "twr", "jqk", "bmc", "nta", "jqc", "rva",
+ "ntD", "jqE", "bmC", "jqC", "bmB", "jqB", "Dlg", "lsr", "bng", "Dla", "jrg", "bna", "DlD",
+ "jra", "bnD", "jrD", "Bkr", "Dlr", "bnr", "jrr", "rtc", "vwq", "rtE", "vwn", "rtC", "rtB",
+ "blc", "nsq", "jnc", "blE", "nsn", "jnE", "rtn", "jnC", "blB", "jnB", "Dkq", "blq", "Dkn",
+ "jnq", "bln", "jnn", "rso", "vwf", "rsm", "rsl", "bko", "nsf", "jlo", "bkm", "jlm", "bkl",
+ "jll", "Dkf", "bkv", "jlv", "rse", "rsd", "bke", "jku", "bkd", "jkt", "Aey", "Aej", "Auw",
+ "khj", "Aui", "Aub", "Adj", "Avj", "Bus", "kxi", "Bug", "kxb", "Bua", "BuD", "Ati", "Bvi",
+ "Atb", "Bvb", "Duk", "lxg", "syr", "Duc", "lxa", "DuE", "lxD", "DuC", "DuB", "Btg", "kwr",
+ "Dvg", "lxr", "Dva", "BtD", "DvD", "Asr", "Btr", "Dvr", "nxc", "tyq", "nxE", "tyn", "nxC",
+ "nxB", "Dtc", "lwq", "bvc", "nxq", "lwn", "bvE", "DtC", "bvC", "DtB", "bvB", "Bsq", "Dtq",
+ "Bsn", "bvq", "Dtn", "bvn", "vyo", "xzf", "vym", "vyl", "nwo", "tyf", "rxo", "nwm", "rxm",
+ "nwl", "rxl", "Dso", "lwf", "bto", "Dsm", "jvo", "btm", "Dsl", "jvm", "btl", "jvl", "Bsf",
+ "Dsv", "btv", "jvv", "vye", "vyd", "nwe", "rwu", "nwd", "rwt", "Dse", "bsu", "Dsd", "jtu",
+ "bst", "jtt", "vyF", "nwF", "rwh", "DsF", "bsh", "jsx", "Ahi", "Ahb", "Axg", "kir", "Axa",
+ "AxD", "Agr", "Axr", "Bxc", "kyq", "BxE", "kyn", "BxC", "BxB", "Awq", "Bxq", "Awn", "Bxn",
+ "lyo", "szf", "lym", "lyl", "Bwo", "kyf", "Dxo", "lyv", "Dxm", "Bwl", "Dxl", "Awf", "Bwv",
+ "Dxv", "tze", "tzd", "lye", "nyu", "lyd", "nyt", "Bwe", "Dwu", "Bwd", "bxu", "Dwt", "bxt",
+ "tzF", "lyF", "nyh", "BwF", "Dwh", "bwx", "Aiq", "Ain", "Ayo", "kjf", "Aym", "Ayl", "Aif",
+ "Ayv", "kze", "kzd", "Aye", "Byu", "Ayd", "Byt", "szp"
+ };
+ private char[] brSet = {
+ 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+ 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '*', '+', '-'
+ };
+ private String[] PDFttf = {
+ "00000", "00001", "00010", "00011", "00100", "00101", "00110", "00111",
+ "01000", "01001", "01010", "01011", "01100", "01101", "01110", "01111", "10000", "10001",
+ "10010", "10011", "10100", "10101", "10110", "10111", "11000", "11001", "11010",
+ "11011", "11100", "11101", "11110", "11111", "01", "1111111101010100", "11111101000101001"
+ };
+ /* Left and Right Row Address Pattern from Table 2 */
+ private String[] RAPLR = {"", "221311", "311311", "312211", "222211", "213211", "214111", "223111",
+ "313111", "322111", "412111", "421111", "331111", "241111", "232111", "231211", "321211",
+ "411211", "411121", "411112", "321112", "312112", "311212", "311221", "311131", "311122",
+ "311113", "221113", "221122", "221131", "221221", "222121", "312121", "321121", "231121",
+ "231112", "222112", "213112", "212212", "212221", "212131", "212122", "212113", "211213",
+ "211123", "211132", "211141", "211231", "211222", "211312", "211321", "211411", "212311"};
+
+ /* Centre Row Address Pattern from Table 2 */
+ private String[] RAPC = {"", "112231", "121231", "122131", "131131", "131221", "132121", "141121",
+ "141211", "142111", "133111", "132211", "131311", "122311", "123211", "124111", "115111",
+ "114211", "114121", "123121", "123112", "122212", "122221", "121321", "121411", "112411",
+ "113311", "113221", "113212", "113122", "122122", "131122", "131113", "122113", "113113",
+ "112213", "112222", "112312", "112321", "111421", "111331", "111322", "111232", "111223",
+ "111133", "111124", "111214", "112114", "121114", "121123", "121132", "112132", "112141"};
+ private int[] MicroVariants = {1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 11, 14, 17, 20, 24, 28, 8, 11, 14, 17, 20, 23, 26, 6, 8, 10, 12, 15, 20, 26, 32, 38, 44, 4, 6, 8, 10, 12, 15, 20, 26, 32, 38, 44,
+ 7, 7, 7, 8, 8, 8, 8, 9, 9, 10, 11, 13, 15, 12, 14, 16, 18, 21, 26, 32, 38, 44, 50, 8, 12, 14, 16, 18, 21, 26, 32, 38, 44, 50,
+ 0, 0, 0, 7, 7, 7, 7, 15, 15, 24, 34, 57, 84, 45, 70, 99, 115, 133, 154, 180, 212, 250, 294, 7, 45, 70, 99, 115, 133, 154, 180, 212, 250, 294};
+ /* rows, columns, error codewords, k-offset */
+ /* MicroPDF417 coefficients from ISO/IEC 24728:2006 Annex F */
+ private int[] Microcoeffs = {
+ /* k = 7 */
+ 76, 925, 537, 597, 784, 691, 437,
+ /* k = 8 */
+ 237, 308, 436, 284, 646, 653, 428, 379,
+ /* k = 9 */
+ 567, 527, 622, 257, 289, 362, 501, 441, 205,
+ /* k = 10 */
+ 377, 457, 64, 244, 826, 841, 818, 691, 266, 612,
+ /* k = 11 */
+ 462, 45, 565, 708, 825, 213, 15, 68, 327, 602, 904,
+ /* k = 12 */
+ 597, 864, 757, 201, 646, 684, 347, 127, 388, 7, 69, 851,
+ /* k = 13 */
+ 764, 713, 342, 384, 606, 583, 322, 592, 678, 204, 184, 394, 692,
+ /* k = 14 */
+ 669, 677, 154, 187, 241, 286, 274, 354, 478, 915, 691, 833, 105, 215,
+ /* k = 15 */
+ 460, 829, 476, 109, 904, 664, 230, 5, 80, 74, 550, 575, 147, 868, 642,
+ /* k = 16 */
+ 274, 562, 232, 755, 599, 524, 801, 132, 295, 116, 442, 428, 295, 42, 176, 65,
+ /* k = 18 */
+ 279, 577, 315, 624, 37, 855, 275, 739, 120, 297, 312, 202, 560, 321, 233, 756,
+ 760, 573,
+ /* k = 21 */
+ 108, 519, 781, 534, 129, 425, 681, 553, 422, 716, 763, 693, 624, 610, 310, 691,
+ 347, 165, 193, 259, 568,
+ /* k = 26 */
+ 443, 284, 887, 544, 788, 93, 477, 760, 331, 608, 269, 121, 159, 830, 446, 893,
+ 699, 245, 441, 454, 325, 858, 131, 847, 764, 169,
+ /* k = 32 */
+ 361, 575, 922, 525, 176, 586, 640, 321, 536, 742, 677, 742, 687, 284, 193, 517,
+ 273, 494, 263, 147, 593, 800, 571, 320, 803, 133, 231, 390, 685, 330, 63, 410,
+ /* k = 38 */
+ 234, 228, 438, 848, 133, 703, 529, 721, 788, 322, 280, 159, 738, 586, 388, 684,
+ 445, 680, 245, 595, 614, 233, 812, 32, 284, 658, 745, 229, 95, 689, 920, 771,
+ 554, 289, 231, 125, 117, 518,
+ /* k = 44 */
+ 476, 36, 659, 848, 678, 64, 764, 840, 157, 915, 470, 876, 109, 25, 632, 405,
+ 417, 436, 714, 60, 376, 97, 413, 706, 446, 21, 3, 773, 569, 267, 272, 213,
+ 31, 560, 231, 758, 103, 271, 572, 436, 339, 730, 82, 285,
+ /* k = 50 */
+ 923, 797, 576, 875, 156, 706, 63, 81, 257, 874, 411, 416, 778, 50, 205, 303,
+ 188, 535, 909, 155, 637, 230, 534, 96, 575, 102, 264, 233, 919, 593, 865, 26,
+ 579, 623, 766, 146, 10, 739, 246, 127, 71, 244, 211, 477, 920, 876, 427, 820,
+ 718, 435};
+
+ /* following is Left RAP, Centre RAP, Right RAP and Start Cluster from ISO/IEC 24728:2006 tables 10, 11 and 12 */
+ private int[] RAPTable = {1, 8, 36, 19, 9, 25, 1, 1, 8, 36, 19, 9, 27, 1, 7, 15, 25, 37, 1, 1, 21, 15, 1, 47, 1, 7, 15, 25, 37, 1, 1, 21, 15, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 7, 15, 25, 37, 17, 9, 29, 31, 25, 19, 1, 7, 15, 25, 37, 17, 9, 29, 31, 25,
+ 9, 8, 36, 19, 17, 33, 1, 9, 8, 36, 19, 17, 35, 1, 7, 15, 25, 37, 33, 17, 37, 47, 49, 43, 1, 7, 15, 25, 37, 33, 17, 37, 47, 49,
+ 0, 3, 6, 0, 6, 0, 0, 0, 3, 6, 0, 6, 6, 0, 0, 6, 0, 0, 0, 0, 6, 6, 0, 3, 0, 0, 6, 0, 0, 0, 0, 6, 6, 0};
+
+ private StringBuilder binaryString;
+ private int ecc;
+ private LinearEncoding symbology = LinearEncoding.CODE_128;
+ private String generalField;
+ private gfMode[] generalFieldType;
+
+ ;
+ private int ccWidth;
+ private int[][] pwr928 = new int[69][7];
+ private int[] codeWords = new int[180];
+ private int codeWordCount;
+ private int[] bitStr = new int[13];
+ private int[] inputData;
+ private CompositeMode ccMode;
+ private String linearContent;
+ private CompositeMode userPreferredMode = CompositeMode.CC_A;
+ private int targetBitsize;
+ private int remainder;
+ private int linearWidth; // Width of Code 128 linear
+
+ public Composite() {
+ inputDataType = DataType.GS1;
+ }
+
+ @Override
+ public void setDataType(DataType dummy) {
+ // Do nothing!
+ }
+
+ /**
+ * Set the type of linear component included in the composite symbol,
+ * this will determine how the lower part of the symbol is encoded.
+ *
+ * @param linearSymbology The symbology of the linear component
+ */
+ public void setSymbology(LinearEncoding linearSymbology) {
+ symbology = linearSymbology;
+ }
+
+ /**
+ * Set the data to be encoded in the linear component of the composite
+ * symbol.
+ *
+ * @param input The linear data in GS1 format
+ */
+ public void setLinear(String input) {
+ linearContent = input;
+ }
+
+ /**
+ * Set the preferred encoding method for the 2D component of the
+ * composite symbol. This value may be ignored if the amount of data
+ * supplied is too big for the selected encoding. Mode CC-C can only be
+ * used with a Code 128 linear component.
+ *
+ * @param userMode Preferred mode
+ */
+ public void setPreferredMode(CompositeMode userMode) {
+ userPreferredMode = userMode;
+ }
+
+ @Override
+ public boolean encode() {
+ Listfalse the
+ * symbol will be the smallest available for the amount of data given. When
+ * set as true the encoding will not use rectangular symbols.
+ *
+ * @param input Forces a square symbol when set to true
+ */
+ public void forceSquare(boolean input) {
+ isSquare = input;
+ }
+
+ /**
+ * Set the prefereed symbol size according to the values in the following
+ * table. Values may be ignored if the data is too big to fit in the
+ * specified symbol, or if forceSquare mode has been invoked.
+ * + * Input |
+ * + * Symbol Size |
+ * + * Input |
+ * + * Symbol Size |
+ *
|---|---|---|---|
+ * 1 |
+ * + * 10 x 10 |
+ * + * 16 |
+ * + * 64 x 64 |
+ *
+ * 2 |
+ * + * 12 x 12 |
+ * + * 17 |
+ * + * 72 x 72 |
+ *
+ * 3 |
+ * + * 14 x 14 |
+ * + * 18 |
+ * + * 80 x 80 |
+ *
+ * 4 |
+ * + * 16 x 16 |
+ * + * 19 |
+ * + * 88 x 88 |
+ *
+ * 5 |
+ * + * 18 x 18 |
+ * + * 20 |
+ * + * 96 x 96 |
+ *
+ * 6 |
+ * + * 20 x 20 |
+ * + * 21 |
+ * + * 104 x 104 |
+ *
+ * 7 |
+ * + * 22 x 22 |
+ * + * 22 |
+ * + * 120 x 120 |
+ *
+ * 8 |
+ * + * 24 x 24 |
+ * + * 23 |
+ * + * 132 x 132 |
+ *
+ * 9 |
+ * + * 26 x 26 |
+ * + * 24 |
+ * + * 144 x 144 |
+ *
+ * 10 |
+ * + * 32 x 32 |
+ * + * 25 |
+ * + * 8 x 18 |
+ *
+ * 11 |
+ * + * 36 x 36 |
+ * + * 26 |
+ * + * 8 x 32 |
+ *
+ * 12 |
+ * + * 40 x 40 |
+ * + * 27 |
+ * + * 12 x 26 |
+ *
+ * 13 |
+ * + * 44 x 44 |
+ * + * 28 |
+ * + * 12 x 36 |
+ *
+ * 14 |
+ * + * 48 x 48 |
+ * + * 29 |
+ * + * 16 x 36 |
+ *
+ * 15 |
+ * + * 52 x 52 |
+ * + * 30 |
+ * + * 16 x 48 |
+ *
+ * Input |
+ * + * Size |
+ *
|---|---|
+ * 1 |
+ * + * 18 x 18 |
+ *
+ * 2 |
+ * + * 30 x 30 |
+ *
+ * 3 |
+ * + * 42 x 42 |
+ *
+ * 4 |
+ * + * 54 x 54 |
+ *
+ * 5 |
+ * + * 66 x 66 |
+ *
+ * 6 |
+ * + * 78 x 78 |
+ *
+ * 7 |
+ * + * 90x 90 |
+ *
+ * 8 |
+ * + * 102 x 102 |
+ *
+ * 9 |
+ * + * 114 x 114 |
+ *
+ * 10 |
+ * + * 126 x 126 |
+ *
+ * 11 |
+ * + * 138 x 138 |
+ *
+ * 12 |
+ * + * 150 x 150 |
+ *
+ * 13 |
+ * + * 162 x 162 |
+ *
+ * Mode |
+ * + * Error Correction Capacity |
+ *
|---|---|
+ * 1 |
+ * + * Approximately 10% |
+ *
+ * 2 |
+ * + * Approximately 20% |
+ *
+ * 3 |
+ * + * Approximately 30% |
+ *
+ * 4 |
+ * + * Approximately 40% |
+ *
+ * 5 |
+ * + * Approximately 50% |
+ *
1.
+ *
+ * @return the position of this MaxiCode symbol in a series of symbols using structured append
+ */
+ public int getStructuredAppendPosition() {
+ return structuredAppendPosition;
+ }
+
+ /**
+ * If this MaxiCode symbol is part of a series of MaxiCode symbols appended in a structured format, this method sets the
+ * position of this symbol in the series. Valid values are 1 through 8 inclusive.
+ *
+ * @param position the position of this MaxiCode symbol in the structured append series
+ */
+ public void setStructuredAppendPosition(int position) {
+ if (position < 1 || position > 8) {
+ throw new IllegalArgumentException("Invalid MaxiCode structured append position: " + position);
+ }
+ this.structuredAppendPosition = position;
+ }
+
+ /**
+ * Returns the size of the series of MaxiCode symbols using structured append that this symbol is part of. If this symbol is
+ * not part of a structured append series, this method will return 1.
+ *
+ * @return size of the series that this symbol is part of
+ */
+ public int getStructuredAppendTotal() {
+ return structuredAppendTotal;
+ }
+
+ /**
+ * If this MaxiCode symbol is part of a series of MaxiCode symbols appended in a structured format, this method sets the total
+ * number of symbols in the series. Valid values are 1 through 8 inclusive. A value of 1 indicates that this symbol is not
+ * part of a structured append series.
+ *
+ * @param total the total number of MaxiCode symbols in the structured append series
+ */
+ public void setStructuredAppendTotal(int total) {
+ if (total < 1 || total > 8) {
+ throw new IllegalArgumentException("Invalid MaxiCode structured append total: " + total);
+ }
+ this.structuredAppendTotal = total;
+ }
+
+ /**
+ * Returns the primary data for this MaxiCode symbol. Should only be used for modes 2 and 3.
+ *
+ * @return the primary data for this MaxiCode symbol
+ */
+ public String getPrimary() {
+ return primaryData;
+ }
+
+ /**
+ * Sets the primary data. Should only be used for modes 2 and 3. Must conform to the following structure:
+ * | Characters | Meaning |
|---|---|
| 1-9 | Postal code data which can consist of up to 9 digits (for mode 2) or up to 6 + * alphanumeric characters (for mode 3). Remaining unused characters should be + * filled with the SPACE character (ASCII 32). |
| 10-12 | Three-digit country code according to ISO-3166. |
| 13-15 | Three digit service code. This depends on your parcel courier. |
| Input | + *Version | + *Symbol Size | + *
|---|---|---|
| 1 | + *M1 | + *11 x 11 | + *
| 2 | + *M2 | + *13 x 13 | + *
| 3 | + *M3 | + *15 x 15 | + *
| 4 | + *M4 | + *17 x 17 | + *
| ECC Level | + *Error Correction Capacity | + *Recovery Capacity | + *
|---|---|---|
| L (default) | + *Approx 20% of symbol | + *Approx 7% | + *
| M | + *Approx 37% of symbol | + *Approx 15% | + *
| Q | + *Approx 55% of symbol | + *Approx 25% | + *
| H | + *Approx 65% of symbol | + *Approx 30% | + *
3).
+ *
+ * @param barHeight the default bar height for this symbol
+ */
+ @Override
+ public void setBarHeight(int barHeight) {
+ super.setBarHeight(barHeight);
+ }
+
+ /**
+ * Returns the number of data columns used by this symbol, or {@code null}
+ * if the number of data columns has not been set.
+ *
+ * @return the number of data columns used by this symbol
+ */
+ public Integer getDataColumns() {
+ return columns;
+ }
+
+ /**
+ * Sets the width of the symbol by specifying the number of columns
+ * of data codewords. Valid values are 1-30 for PDF417 and 1-4
+ * for MicroPDF417.
+ *
+ * @param columns the number of data columns in the symbol
+ */
+ public void setDataColumns(int columns) {
+ this.columns = columns;
+ }
+
+ /**
+ * Returns the number of rows used by this symbol, or {@code null} if
+ * the number of rows has not been set.
+ *
+ * @return the number of rows used by this symbol
+ */
+ public Integer getRows() {
+ return rows;
+ }
+
+ /**
+ * Sets the height of the symbol by specifying the number of rows
+ * of data codewords. Valid values are 3-90 for PDF417 and 4-44
+ * for MicroPDF417.
+ *
+ * @param rows the number of rows in the symbol
+ */
+ public void setRows(int rows) {
+ this.rows = rows;
+ }
+
+ /**
+ * Set the amount of the symbol which is dedicated to error correction
+ * codewords. The number of codewords of error correction data is
+ * determined by 2(eccLevel + 1). This attribute is ignored
+ * when using {@link Mode#MICRO micro} mode.
+ *
+ * @param eccLevel level of error correction (0-8)
+ */
+ public void setPreferredEccLevel(int eccLevel) {
+ if (eccLevel < 0 || eccLevel > 8) {
+ throw new IllegalArgumentException("ECC level must be between 0 and 8.");
+ }
+ preferredEccLevel = eccLevel;
+ }
+
+ /**
+ * Forces the use of the specified MicroPDF417 variant. Only valid
+ * when using {@link Mode#MICRO micro} mode.
+ *
+ * @param variant the MicroPDF417 variant to use
+ */
+ public void setVariant(int variant) {
+ if (symbolMode != Mode.MICRO) {
+ throw new IllegalArgumentException("Can only set variant when using MICRO mode.");
+ }
+ if (variant < 1 || variant > 34) {
+ throw new IllegalArgumentException("Variant must be between 1 and 34.");
+ }
+ this.columns = MICRO_VARIANTS[variant - 1];
+ this.rows = MICRO_VARIANTS[variant - 1 + 34];
+ }
+
+ /**
+ * Returns the position of this PDF417 symbol in a series of symbols using structured append
+ * (Macro PDF417). If this symbol is not part of such a series, this method will return 1.
+ *
+ * @return the position of this PDF417 symbol in a series of symbols using structured append
+ */
+ public int getStructuredAppendPosition() {
+ return structuredAppendPosition;
+ }
+
+ /**
+ * If this PDF417 symbol is part of a series of PDF417 symbols appended in a structured format
+ * (Macro PDF417), this method sets the position of this symbol in the series. Valid values are
+ * 1 through 99,999 inclusive.
+ *
+ * @param position the position of this PDF417 symbol in the structured append series
+ */
+ public void setStructuredAppendPosition(int position) {
+ if (position < 1 || position > 99_999) {
+ throw new IllegalArgumentException("Invalid PDF417 structured append position: " + position);
+ }
+ this.structuredAppendPosition = position;
+ }
+
+ /**
+ * Returns the size of the series of PDF417 symbols using structured append (Macro PDF417) that
+ * this symbol is part of. If this symbol is not part of a structured append series, this method
+ * will return 1.
+ *
+ * @return size of the series that this symbol is part of
+ */
+ public int getStructuredAppendTotal() {
+ return structuredAppendTotal;
+ }
+
+ /**
+ * If this PDF417 symbol is part of a series of PDF417 symbols appended in a structured format
+ * (Macro PDF417), this method sets the total number of symbols in the series. Valid values are
+ * 1 through 99,999 inclusive. A value of 1 indicates that this symbol is not part of a structured
+ * append series.
+ *
+ * @param total the total number of PDF417 symbols in the structured append series
+ */
+ public void setStructuredAppendTotal(int total) {
+ if (total < 1 || total > 99_999) {
+ throw new IllegalArgumentException("Invalid PDF417 structured append total: " + total);
+ }
+ this.structuredAppendTotal = total;
+ }
+
+ /**
+ * Returns the unique file ID of the series of PDF417 symbols using structured append (Macro PDF417)
+ * that this symbol is part of. If this symbol is not part of a structured append series, this method
+ * will return 0.
+ *
+ * @return the unique file ID for the series that this symbol is part of
+ */
+ public int getStructuredAppendFileId() {
+ return structuredAppendFileId;
+ }
+
+ /**
+ * If this PDF417 symbol is part of a series of PDF417 symbols appended in a structured format
+ * (Macro PDF417), this method sets the unique file ID for the series. Valid values are 0 through
+ * 899 inclusive.
+ *
+ * @param fileId the unique file ID for the series that this symbol is part of
+ */
+ public void setStructuredAppendFileId(int fileId) {
+ if (fileId < 0 || fileId > 899) {
+ throw new IllegalArgumentException("Invalid PDF417 structured append file ID: " + fileId);
+ }
+ this.structuredAppendFileId = fileId;
+ }
+
+ public Mode getMode() {
+ return symbolMode;
+ }
+
+ public void setMode(Mode mode) {
+ symbolMode = mode;
+ }
+
+ @Override
+ public boolean encode() {
+
+ eciProcess();
+
+ int sourceLength = inputBytes.length;
+ inputData = new int[sourceLength];
+ for (int i = 0; i < sourceLength; i++) {
+ inputData[i] = inputBytes[i] & 0xFF;
+ }
+
+ boolean ok;
+ switch (symbolMode) {
+ case MICRO:
+ ok = processMicroPdf417();
+ break;
+ case NORMAL:
+ case TRUNCATED:
+ default:
+ ok = processPdf417();
+ break;
+ }
+
+ if (ok) {
+ plotSymbol();
+ }
+
+ return ok;
+ }
+
+ private boolean processPdf417() {
+ int j, loop, offset;
+ int[] mccorrection = new int[520];
+ int total;
+ int c1, c2, c3;
+ int[] dummy = new int[35];
+ StringBuilder codebarre;
+ int selectedECCLevel;
+ String bin;
+
+ List+ * Input |
+ * + * Symbol Size |
+ * + * Input |
+ * + * Symbol Size |
+ *
|---|---|---|---|
+ * 1 |
+ * + * 21 x 21 |
+ * + * 21 |
+ * + * 101 x 101 |
+ *
+ * 2 |
+ * + * 25 x 25 |
+ * + * 22 |
+ * + * 105 x 105 |
+ *
+ * 3 |
+ * + * 29 x 29 |
+ * + * 23 |
+ * + * 109 x 109 |
+ *
+ * 4 |
+ * + * 33 x 33 |
+ * + * 24 |
+ * + * 113 x 113 |
+ *
+ * 5 |
+ * + * 37 x 37 |
+ * + * 25 |
+ * + * 117 x 117 |
+ *
+ * 6 |
+ * + * 41 x 41 |
+ * + * 26 |
+ * + * 121 x 121 |
+ *
+ * 7 |
+ * + * 45 x 45 |
+ * + * 27 |
+ * + * 125 x 125 |
+ *
+ * 8 |
+ * + * 49 x 49 |
+ * + * 28 |
+ * + * 129 x 129 |
+ *
+ * 9 |
+ * + * 53 x 53 |
+ * + * 29 |
+ * + * 133 x 133 |
+ *
+ * 10 |
+ * + * 57 x 57 |
+ * + * 30 |
+ * + * 137 x 137 |
+ *
+ * 11 |
+ * + * 61 x 61 |
+ * + * 31 |
+ * + * 141 x 141 |
+ *
+ * 12 |
+ * + * 65 x 65 |
+ * + * 32 |
+ * + * 145 x 145 |
+ *
+ * 13 |
+ * + * 69 x 69 |
+ * + * 33 |
+ * + * 149 x 149 |
+ *
+ * 14 |
+ * + * 73 x 73 |
+ * + * 34 |
+ * + * 153 x 153 |
+ *
+ * 15 |
+ * + * 77 x 77 |
+ * + * 35 |
+ * + * 157 x 157 |
+ *
+ * 16 |
+ * + * 81 x 81 |
+ * + * 36 |
+ * + * 161 x 161 |
+ *
+ * 17 |
+ * + * 85 x 85 |
+ * + * 37 |
+ * + * 165 x 165 |
+ *
+ * 18 |
+ * + * 89 x 89 |
+ * + * 38 |
+ * + * 169 x 169 |
+ *
+ * 19 |
+ * + * 93 x 93 |
+ * + * 39 |
+ * + * 173 x 173 |
+ *
+ * 20 |
+ * + * 97 x 97 |
+ * + * 40 |
+ * + * 177 x 177 |
+ *
| ECC Level | + *Error Correction Capacity | + *Recovery Capacity | + *
|---|---|---|
| L (default) | + *Approx 20% of symbol | + *Approx 7% | + *
| M | + *Approx 37% of symbol | + *Approx 15% | + *
| Q | + *Approx 55% of symbol | + *Approx 25% | + *
| H | + *Approx 65% of symbol | + *Approx 30% | + *
GS1 mode the AI data will be used to
+ * calculate the position of 'FNC1' characters.
+ * Valid values are:
+ * UTF8 (default) Unicode encoding
+ * LATIN1 ISO 8859-1 (Latin-1) encoding
+ * BINARY Byte encoding mode
+ * GS1 Application Identifier and data pairs in "[AI]DATA" format
+ * HIBC Health Industry Bar Code number (without check digit)
+ * ECI Extended Channel Interpretations
+ * DataType value which specifies the type of data
+ */
+ public void setDataType(DataType dataType) {
+ inputDataType = dataType;
+ }
+
+ /**
+ * Prefixes symbol data with a "Reader Initialisation" or "Reader
+ * Programming" instruction.
+ */
+ public final void setReaderInit() {
+ readerInit = true;
+ }
+
+ /**
+ * Removes "Reader Initialisation" or "Reader Programming" instruction
+ * from symbol data.
+ */
+ private void unsetReaderInit() {
+ readerInit = false;
+ }
+
+ /**
+ * Returns the default bar height for this symbol.
+ *
+ * @return the default bar height for this symbol
+ */
+ public int getBarHeight() {
+ return defaultHeight;
+ }
+
+ /**
+ * Sets the default bar height for this symbol (default value is 40).
+ *
+ * @param barHeight the default bar height for this symbol
+ */
+ public void setBarHeight(int barHeight) {
+ this.defaultHeight = barHeight;
+ }
+
+ /**
+ * Returns the module width for this symbol.
+ *
+ * @return the module width for this symbol
+ */
+ public int getModuleWidth() {
+ return moduleWidth;
+ }
+
+ /**
+ * Sets the module width for this symbol (default value is 1).
+ *
+ * @param moduleWidth the module width for this symbol
+ */
+ public void setModuleWidth(int moduleWidth) {
+ this.moduleWidth = moduleWidth;
+ }
+
+ /**
+ * Returns the horizontal quiet zone (white space) added to the left and to the right of this symbol.
+ *
+ * @return the horizontal quiet zone (white space) added to the left and to the right of this symbol
+ */
+ public int getQuietZoneHorizontal() {
+ return quietZoneHorizontal;
+ }
+
+ /**
+ * Sets the horizontal quiet zone (white space) added to the left and to the right of this symbol.
+ *
+ * @param quietZoneHorizontal the horizontal quiet zone (white space) added to the left and to the right of this symbol
+ */
+ public void setQuietZoneHorizontal(int quietZoneHorizontal) {
+ this.quietZoneHorizontal = quietZoneHorizontal;
+ }
+
+ /**
+ * Returns the vertical quiet zone (white space) added above and below this symbol.
+ *
+ * @return the vertical quiet zone (white space) added above and below this symbol
+ */
+ public int getQuietZoneVertical() {
+ return quietZoneVertical;
+ }
+
+ /**
+ * Sets the vertical quiet zone (white space) added above and below this symbol.
+ *
+ * @param quietZoneVertical the vertical quiet zone (white space) added above and below this symbol
+ */
+ public void setQuietZoneVertical(int quietZoneVertical) {
+ this.quietZoneVertical = quietZoneVertical;
+ }
+
+ /**
+ * Returns the name of the font to use to render the human-readable text.
+ *
+ * @return the name of the font to use to render the human-readable text
+ */
+ public String getFontName() {
+ return fontName;
+ }
+
+ /**
+ * Sets the name of the font to use to render the human-readable text (default value is Helvetica).
+ *
+ * @param fontName the name of the font to use to render the human-readable text
+ */
+ public void setFontName(String fontName) {
+ this.fontName = fontName;
+ }
+
+ /**
+ * Returns the size of the font to use to render the human-readable text.
+ *
+ * @return the size of the font to use to render the human-readable text
+ */
+ public double getFontSize() {
+ return fontSize;
+ }
+
+ /**
+ * Sets the size of the font to use to render the human-readable text (default value is 8).
+ *
+ * @param fontSize the size of the font to use to render the human-readable text
+ */
+ public void setFontSize(double fontSize) {
+ this.fontSize = fontSize;
+ }
+
+ /**
+ * Gets the width of the encoded symbol, including the horizontal quiet zone.
+ *
+ * @return the width of the encoded symbol
+ */
+ public int getWidth() {
+ return symbolWidth + (2 * quietZoneHorizontal);
+ }
+
+ /**
+ * Returns the height of the symbol, including the human-readable text, if any, as well as the vertical
+ * quiet zone. This height is an approximation, since it is calculated without access to a font engine.
+ *
+ * @return the height of the symbol, including the human-readable text, if any, as well as the vertical
+ * quiet zone
+ */
+ public int getHeight() {
+ return symbolHeight + getHumanReadableHeight() + (2 * quietZoneVertical);
+ }
+
+ /**
+ * Returns the height of the human-readable text, including the space between the text and other symbols.
+ * This height is an approximation, since it is calculated without access to a font engine.
+ *
+ * @return the height of the human-readable text
+ */
+ public int getHumanReadableHeight() {
+ if (texts.isEmpty()) {
+ return 0;
+ } else {
+ return getTheoreticalHumanReadableHeight();
+ }
+ }
+
+ /**
+ * Returns the height of the human-readable text, assuming this symbol had human-readable text.
+ *
+ * @return the height of the human-readable text, assuming this symbol had human-readable text
+ */
+ int getTheoreticalHumanReadableHeight() {
+ return (int) Math.ceil(fontSize * 1.2); // 0.2 space between bars and text
+ }
+
+ /**
+ * Returns a human readable summary of the decisions made by the encoder when creating a symbol.
+ *
+ * @return a human readable summary of the decisions made by the encoder when creating a symbol
+ */
+ public String getEncodeInfo() {
+ return encodeInfo.toString();
+ }
+
+ /**
+ * Returns the location of the human-readable text.
+ *
+ * @return the location of the human-readable text
+ */
+ public HumanReadableLocation getHumanReadableLocation() {
+ return humanReadableLocation;
+ }
+
+ /**
+ * Sets the location of the human-readable text (default value is {@link HumanReadableLocation#BOTTOM}).
+ *
+ * @param humanReadableLocation the location of the human-readable text
+ */
+ public void setHumanReadableLocation(HumanReadableLocation humanReadableLocation) {
+ this.humanReadableLocation = humanReadableLocation;
+ }
+
+ protected int positionOf(char thischar, char[] LookUp) {
+ int i, outval = 0;
+
+ for (i = 0; i < LookUp.length; i++) {
+ if (thischar == LookUp[i]) {
+ outval = i;
+ }
+ }
+ return outval;
+ }
+
+ protected String bin2pat(String bin) {
+ boolean black;
+ int i, l;
+ StringBuilder pat = new StringBuilder();
+
+ black = true;
+ l = 0;
+ for (i = 0; i < bin.length(); i++) {
+ if (black) {
+ if (bin.charAt(i) == '1') {
+ l++;
+ } else {
+ black = false;
+ pat.append((char) (l + '0'));
+ l = 1;
+ }
+ } else {
+ if (bin.charAt(i) == '0') {
+ l++;
+ } else {
+ black = true;
+ pat.append((char) (l + '0'));
+ l = 1;
+ }
+ }
+ }
+ pat.append((char) (l + '0'));
+
+ return pat.toString();
+ }
+
+ public String getContent() {
+ return content;
+ }
+
+ /**
+ * Set the data to be encoded. Input data will be assumed to be of
+ * the type set by setDataType.
+ *
+ * @param inputData A String containing the data to encode
+ */
+ public void setContent(String inputData) {
+ int i;
+ content = inputData;
+ if (inputDataType == DataType.GS1) {
+ content = gs1SanityCheck(inputData);
+ }
+ if (inputDataType == DataType.GS1) {
+ readable = new StringBuilder();
+ for (i = 0; i < inputData.length(); i++) {
+ switch (inputData.charAt(i)) {
+ case '[':
+ readable.append('(');
+ break;
+ case ']':
+ readable.append(')');
+ break;
+ default:
+ readable.append(inputData.charAt(i));
+ break;
+ }
+ }
+ }
+ if (inputDataType == DataType.HIBC) {
+ content = hibcProcess(inputData);
+ }
+ if (!content.isEmpty()) {
+ if (!encode()) {
+ throw new IllegalStateException(errorMsg.toString());
+ }
+ } else {
+ throw new IllegalStateException("No input data");
+ }
+ }
+
+ void eciProcess() {
+ int qmarksBefore, qmarksAfter;
+ int i;
+
+ qmarksBefore = 0;
+ for (i = 0; i < content.length(); i++) {
+ if (content.charAt(i) == '?') {
+ qmarksBefore++;
+ }
+ }
+
+ qmarksAfter = eciEncode("ISO8859_1");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 3;
+ encodeInfo.append("Encoding in ISO 8859-1 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_2");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 4;
+ encodeInfo.append("Encoding in ISO 8859-2 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_3");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 5;
+ encodeInfo.append("Encoding in ISO 8859-3 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_4");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 6;
+ encodeInfo.append("Encoding in ISO 8859-4 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_5");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 7;
+ encodeInfo.append("Encoding in ISO 8859-5 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_6");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 8;
+ encodeInfo.append("Encoding in ISO 8859-6 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_7");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 9;
+ encodeInfo.append("Encoding in ISO 8859-7 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_8");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 10;
+ encodeInfo.append("Encoding in ISO 8859-8 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_9");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 11;
+ encodeInfo.append("Encoding in ISO 8859-9 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_10");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 12;
+ encodeInfo.append("Encoding in ISO 8859-10 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_11");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 13;
+ encodeInfo.append("Encoding in ISO 8859-11 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_13");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 15;
+ encodeInfo.append("Encoding in ISO 8859-13 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_14");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 16;
+ encodeInfo.append("Encoding in ISO 8859-14 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_15");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 17;
+ encodeInfo.append("Encoding in ISO 8859-15 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("ISO8859_16");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 18;
+ encodeInfo.append("Encoding in ISO 8859-16 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("Windows_1250");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 21;
+ encodeInfo.append("Encoding in Windows-1250 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("Windows_1251");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 22;
+ encodeInfo.append("Encoding in Windows-1251 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("Windows_1252");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 23;
+ encodeInfo.append("Encoding in Windows-1252 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("Windows_1256");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 24;
+ encodeInfo.append("Encoding in Windows-1256 character set\n");
+ return;
+ }
+
+ qmarksAfter = eciEncode("SJIS");
+ if (qmarksAfter == qmarksBefore) {
+ eciMode = 20;
+ encodeInfo.append("Encoding in Shift-JIS character set\n");
+ return;
+ }
+
+ /* default */
+ qmarksAfter = eciEncode("UTF8");
+ eciMode = 26;
+ encodeInfo.append("Encoding in UTF-8 character set\n");
+ }
+
+ private int eciEncode(String charset) {
+ /* getBytes replaces unconverted characters to '?', so count
+ the number of question marks to find if conversion was sucessful.
+ */
+ int i, qmarksAfter;
+
+ try {
+ inputBytes = content.getBytes(charset);
+ } catch (UnsupportedEncodingException e) {
+ return -1;
+ }
+
+ qmarksAfter = 0;
+ for (i = 0; i < inputBytes.length; i++) {
+ if (inputBytes[i] == '?') {
+ qmarksAfter++;
+ }
+ }
+
+ return qmarksAfter;
+ }
+
+ abstract boolean encode();
+
+ protected void plotSymbol() {
+ int xBlock, yBlock;
+ double x, y, w, h;
+ boolean black;
+ rectangles.clear();
+ texts.clear();
+ int baseY;
+ if (humanReadableLocation == TOP) {
+ baseY = getTheoreticalHumanReadableHeight();
+ } else {
+ baseY = 0;
+ }
+ h = 0;
+ y = baseY;
+ for (yBlock = 0; yBlock < rowCount; yBlock++) {
+ black = true;
+ x = 0;
+ for (xBlock = 0; xBlock < pattern[yBlock].length(); xBlock++) {
+ char c = pattern[yBlock].charAt(xBlock);
+ w = getModuleWidth(c - '0') * moduleWidth;
+ if (black) {
+ if (rowHeight[yBlock] == -1) {
+ h = defaultHeight;
+ } else {
+ h = rowHeight[yBlock];
+ }
+ if (w != 0 && h != 0) {
+ Rectangle2D.Double rect = new Rectangle2D.Double(x, y, w, h);
+ rectangles.add(rect);
+ }
+ if (x + w > symbolWidth) {
+ symbolWidth = (int) Math.ceil(x + w);
+ }
+ }
+ black = !black;
+ x += w;
+ }
+ if ((y - baseY + h) > symbolHeight) {
+ symbolHeight = (int) Math.ceil(y - baseY + h);
+ }
+ y += h;
+ }
+ mergeVerticalBlocks();
+ if (humanReadableLocation != NONE && readable.length() > 0) {
+ double baseline;
+ if (humanReadableLocation == TOP) {
+ baseline = fontSize;
+ } else {
+ baseline = getHeight() + fontSize;
+ }
+ double centerX = getWidth() / 2.0;
+ texts.add(new TextBox(centerX, baseline, readable.toString()));
+ }
+ }
+
+ /**
+ * Returns the module width to use for the specified original module width, taking into account any module width ratio
+ * customizations. Intended to be overridden by subclasses that support such module width ratio customization.
+ *
+ * @param originalWidth the original module width
+ * @return the module width to use for the specified original module width
+ */
+ protected double getModuleWidth(int originalWidth) {
+ return originalWidth;
+ }
+
+ /**
+ * Search for rectangles which have the same width and x position, and
+ * which join together vertically and merge them together to reduce the
+ * number of rectangles needed to describe a symbol.
+ */
+ void mergeVerticalBlocks() {
+ for (int i = 0; i < rectangles.size() - 1; i++) {
+ for (int j = i + 1; j < rectangles.size(); j++) {
+ Rectangle2D.Double firstRect = rectangles.get(i);
+ Rectangle2D.Double secondRect = rectangles.get(j);
+ if (roughlyEqual(firstRect.x, secondRect.x) && roughlyEqual(firstRect.width, secondRect.width)) {
+ if (roughlyEqual(firstRect.y + firstRect.height, secondRect.y)) {
+ firstRect.height += secondRect.height;
+ rectangles.set(i, firstRect);
+ rectangles.remove(j);
+ }
+ }
+ }
+ }
+ }
+
+ private String gs1SanityCheck(String source) {
+ // Enforce compliance with GS1 General Specification
+ // http://www.gs1.org/docs/gsmp/barcodes/GS1_General_Specifications.pdf
+
+ StringBuilder reduced = new StringBuilder();
+
+ int i, j, lastAi;
+ boolean aiLatch;
+ int bracketLevel, maxBracketLevel, aiLength, maxAiLength, minAiLength;
+ int[] aiValue = new int[100];
+ int[] aiLocation = new int[100];
+ int aiCount;
+ int[] dataLocation = new int[100];
+ int[] dataLength = new int[100];
+ int srcLen = source.length();
+ int errorLatch;
+
+ /* Detect extended ASCII characters */
+ for (i = 0; i < srcLen; i++) {
+ if (source.charAt(i) >= 128) {
+ errorMsg.append("Extended ASCII characters are not supported by GS1");
+ return "";
+ }
+ if (source.charAt(i) < 32) {
+ errorMsg.append("Control characters are not supported by GS1");
+ return "";
+ }
+ }
+
+ if (source.charAt(0) != '[') {
+ errorMsg.append("Data does not start with an AI");
+ return "";
+ }
+
+ /* Check the position of the brackets */
+ bracketLevel = 0;
+ maxBracketLevel = 0;
+ aiLength = 0;
+ maxAiLength = 0;
+ minAiLength = 5;
+ j = 0;
+ aiLatch = false;
+ for (i = 0; i < srcLen; i++) {
+ aiLength += j;
+ if (((j == 1) && (source.charAt(i) != ']'))
+ && ((source.charAt(i) < '0') || (source.charAt(i) > '9'))) {
+ aiLatch = true;
+ }
+ if (source.charAt(i) == '[') {
+ bracketLevel++;
+ j = 1;
+ }
+ if (source.charAt(i) == ']') {
+ bracketLevel--;
+ if (aiLength < minAiLength) {
+ minAiLength = aiLength;
+ }
+ j = 0;
+ aiLength = 0;
+ }
+ if (bracketLevel > maxBracketLevel) {
+ maxBracketLevel = bracketLevel;
+ }
+ if (aiLength > maxAiLength) {
+ maxAiLength = aiLength;
+ }
+ }
+ minAiLength--;
+
+ if (bracketLevel != 0) {
+ /* Not all brackets are closed */
+ errorMsg.append("Malformed AI in input data (brackets don't match)");
+ return "";
+ }
+
+ if (maxBracketLevel > 1) {
+ /* Nested brackets */
+ errorMsg.append("Found nested brackets in input data");
+ return "";
+ }
+
+ if (maxAiLength > 4) {
+ /* AI is too long */
+ errorMsg.append("Invalid AI in input data (AI too long)");
+ return "";
+ }
+
+ if (minAiLength <= 1) {
+ /* AI is too short */
+ errorMsg.append("Invalid AI in input data (AI too short)");
+ return "";
+ }
+
+ if (aiLatch) {
+ /* Non-numeric data in AI */
+ errorMsg.append("Invalid AI in input data (non-numeric characters in AI)");
+ return "";
+ }
+
+ aiCount = 0;
+ for (i = 1; i < srcLen; i++) {
+ if (source.charAt(i - 1) == '[') {
+ aiLocation[aiCount] = i;
+ aiValue[aiCount] = 0;
+ for (j = 0; source.charAt(i + j) != ']'; j++) {
+ aiValue[aiCount] *= 10;
+ aiValue[aiCount] += Character.getNumericValue(source.charAt(i + j));
+ }
+ aiCount++;
+ }
+ }
+
+ for (i = 0; i < aiCount; i++) {
+ dataLocation[i] = aiLocation[i] + 3;
+ if (aiValue[i] >= 100) {
+ dataLocation[i]++;
+ }
+ if (aiValue[i] >= 1000) {
+ dataLocation[i]++;
+ }
+ dataLength[i] = source.length() - dataLocation[i];
+ for (j = source.length() - 1; j >= dataLocation[i]; j--) {
+ if (source.charAt(j) == '[') {
+ dataLength[i] = j - dataLocation[i];
+ }
+ }
+ }
+
+ for (i = 0; i < aiCount; i++) {
+ if (dataLength[i] == 0) {
+ /* No data for given AI */
+ errorMsg.append("Empty data field in input data");
+ return "";
+ }
+ }
+
+ errorLatch = 0;
+ for (i = 0; i < aiCount; i++) {
+ switch (aiValue[i]) {
+ case 0:
+ if (dataLength[i] != 18) {
+ errorLatch = 1;
+ }
+ break;
+ case 1:
+ case 2:
+ case 3:
+ if (dataLength[i] != 14) {
+ errorLatch = 1;
+ }
+ break;
+ case 4:
+ if (dataLength[i] != 16) {
+ errorLatch = 1;
+ }
+ break;
+ case 11:
+ case 12:
+ case 13:
+ case 14:
+ case 15:
+ case 16:
+ case 17:
+ case 18:
+ case 19:
+ if (dataLength[i] != 6) {
+ errorLatch = 1;
+ }
+ break;
+ case 20:
+ if (dataLength[i] != 2) {
+ errorLatch = 1;
+ }
+ break;
+ case 23:
+ case 24:
+ case 25:
+ case 39:
+ case 40:
+ case 41:
+ case 42:
+ case 70:
+ case 80:
+ case 81:
+ errorLatch = 2;
+ break;
+ }
+ if (
+ ((aiValue[i] >= 100) && (aiValue[i] <= 179))
+ || ((aiValue[i] >= 1000) && (aiValue[i] <= 1799))
+ || ((aiValue[i] >= 200) && (aiValue[i] <= 229))
+ || ((aiValue[i] >= 2000) && (aiValue[i] <= 2299))
+ || ((aiValue[i] >= 300) && (aiValue[i] <= 309))
+ || ((aiValue[i] >= 3000) && (aiValue[i] <= 3099))
+ || ((aiValue[i] >= 31) && (aiValue[i] <= 36))
+ || ((aiValue[i] >= 310) && (aiValue[i] <= 369))) {
+ errorLatch = 2;
+ }
+ if ((aiValue[i] >= 3100) && (aiValue[i] <= 3699) && dataLength[i] != 6) {
+ errorLatch = 1;
+ }
+ if (
+ ((aiValue[i] >= 370) && (aiValue[i] <= 379))
+ || ((aiValue[i] >= 3700) && (aiValue[i] <= 3799))) {
+ errorLatch = 2;
+ }
+ if ((aiValue[i] >= 410) && (aiValue[i] <= 415)) {
+ if (dataLength[i] != 13) {
+ errorLatch = 1;
+ }
+ }
+ if (
+ ((aiValue[i] >= 4100) && (aiValue[i] <= 4199))
+ || ((aiValue[i] >= 700) && (aiValue[i] <= 703))
+ || ((aiValue[i] >= 800) && (aiValue[i] <= 810))
+ || ((aiValue[i] >= 900) && (aiValue[i] <= 999))
+ || ((aiValue[i] >= 9000) && (aiValue[i] <= 9999))) {
+ errorLatch = 2;
+ }
+
+ if (errorLatch == 1) {
+ errorMsg = new StringBuilder("Invalid data length for AI");
+ return "";
+ }
+
+ if (errorLatch == 2) {
+ errorMsg = new StringBuilder("Invalid AI value");
+ return "";
+ }
+ }
+
+ /* Resolve AI data - put resulting string in 'reduced' */
+ aiLatch = false;
+ for (i = 0; i < srcLen; i++) {
+ if ((source.charAt(i) != '[') && (source.charAt(i) != ']')) {
+ reduced.append(source.charAt(i));
+ }
+ if (source.charAt(i) == '[') {
+ /* Start of an AI string */
+ if (aiLatch) {
+ reduced.append('[');
+ }
+ lastAi = (10 * Character.getNumericValue(source.charAt(i + 1)))
+ + Character.getNumericValue(source.charAt(i + 2));
+ aiLatch = ((lastAi < 0) || (lastAi > 4))
+ && ((lastAi < 11) || (lastAi > 20))
+ && (lastAi != 23) /* legacy support - see 5.3.8.2.2 */
+ && ((lastAi < 31) || (lastAi > 36))
+ && (lastAi != 41);
+ }
+ /* The ']' character is simply dropped from the input */
+ }
+
+ /* the character '[' in the reduced string refers to the FNC1 character */
+ return reduced.toString();
+ }
+
+ private String hibcProcess(String source) {
+ char[] hibcCharTable = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+ 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+ 'U', 'V', 'W', 'X', 'Y', 'Z', '-', '.', ' ', '$',
+ '/', '+', '%'};
+
+ int counter, i;
+ String toProcess;
+ char checkDigit;
+
+ if (source.length() > 36) {
+ errorMsg = new StringBuilder("Data too long for HIBC LIC");
+ return "";
+ }
+ source = source.toUpperCase();
+ if (!(source.matches("[A-Z0-9-\\. \\$/+\\%]+?"))) {
+ errorMsg = new StringBuilder("Invalid characters in input");
+ return "";
+ }
+
+ counter = 41;
+ for (i = 0; i < source.length(); i++) {
+ counter += positionOf(source.charAt(i), hibcCharTable);
+ }
+ counter = counter % 43;
+
+ if (counter < 10) {
+ checkDigit = (char) (counter + '0');
+ } else {
+ if (counter < 36) {
+ checkDigit = (char) ((counter - 10) + 'A');
+ } else {
+ switch (counter) {
+ case 36:
+ checkDigit = '-';
+ break;
+ case 37:
+ checkDigit = '.';
+ break;
+ case 38:
+ checkDigit = ' ';
+ break;
+ case 39:
+ checkDigit = '$';
+ break;
+ case 40:
+ checkDigit = '/';
+ break;
+ case 41:
+ checkDigit = '+';
+ break;
+ case 42:
+ checkDigit = '%';
+ break;
+ default:
+ checkDigit = ' ';
+ break; /* Keep compiler happy */
+ }
+ }
+ }
+
+ encodeInfo.append("HIBC Check Digit: ").append(counter).append(" (").append(checkDigit).append(")\n");
+
+ toProcess = "+" + source + checkDigit;
+ return toProcess;
+ }
+
+ /**
+ * Returns the intermediate coding of this bar code. Symbol types that use the test
+ * infrastructure should override this method.
+ *
+ * @return the intermediate coding of this bar code
+ */
+ protected int[] getCodewords() {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Returns this bar code's pattern, converted into a set of corresponding codewords.
+ * Useful for bar codes that encode their content as a pattern.
+ *
+ * @param size the number of digits in each codeword
+ * @return this bar code's pattern, converted into a set of corresponding codewords
+ */
+ int[] getPatternAsCodewords(int size) {
+ if (pattern == null || pattern.length == 0) {
+ return new int[0];
+ } else {
+ int count = (int) Math.ceil(pattern[0].length() / (double) size);
+ int[] codewords = new int[pattern.length * count];
+ for (int i = 0; i < pattern.length; i++) {
+ String row = pattern[i];
+ for (int j = 0; j < count; j++) {
+ int substringStart = j * size;
+ int substringEnd = Math.min((j + 1) * size, row.length());
+ codewords[(i * count) + j] = Integer.parseInt(row.substring(substringStart, substringEnd));
+ }
+ }
+ return codewords;
+ }
+ }
+
+ public enum DataType {
+ UTF8, LATIN1, BINARY, GS1, HIBC, ECI
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/Telepen.java b/barcode/src/main/java/org/xbib/graphics/barcode/Telepen.java
new file mode 100755
index 0000000..39f11a1
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/Telepen.java
@@ -0,0 +1,177 @@
+package org.xbib.graphics.barcode;
+
+/**
+ * Telepen (also known as Telepen Alpha) can encode ASCII text input and
+ * includes a modulo-127 check digit. Telepen Numeric allows compression of
+ * numeric data into a Telepen symbol. Data can consist of pairs of numbers
+ * or pairs consisting of a numerical digit followed an X character.
+ * Telepen Numeric also includes a modulo-127 check digit.
+ */
+public class Telepen extends Symbol {
+
+ public tp_mode mode;
+ private String[] TeleTable = {
+ "1111111111111111", "1131313111", "33313111", "1111313131",
+ "3111313111", "11333131", "13133131", "111111313111", "31333111",
+ "1131113131", "33113131", "1111333111", "3111113131", "1113133111",
+ "1311133111", "111111113131", "3131113111", "11313331", "333331",
+ "111131113111", "31113331", "1133113111", "1313113111", "1111113331",
+ "31131331", "113111113111", "3311113111", "1111131331", "311111113111",
+ "1113111331", "1311111331", "11111111113111", "31313311", "1131311131",
+ "33311131", "1111313311", "3111311131", "11333311", "13133311",
+ "111111311131", "31331131", "1131113311", "33113311", "1111331131",
+ "3111113311", "1113131131", "1311131131", "111111113311", "3131111131",
+ "1131131311", "33131311", "111131111131", "3111131311", "1133111131",
+ "1313111131", "111111131311", "3113111311", "113111111131",
+ "3311111131", "111113111311", "311111111131", "111311111311",
+ "131111111311", "11111111111131", "3131311111", "11313133", "333133",
+ "111131311111", "31113133", "1133311111", "1313311111", "1111113133",
+ "313333", "113111311111", "3311311111", "11113333", "311111311111",
+ "11131333", "13111333", "11111111311111", "31311133", "1131331111",
+ "33331111", "1111311133", "3111331111", "11331133", "13131133",
+ "111111331111", "3113131111", "1131111133", "33111133", "111113131111",
+ "3111111133", "111311131111", "131111131111", "111111111133",
+ "31311313", "113131111111", "3331111111", "1111311313", "311131111111",
+ "11331313", "13131313", "11111131111111", "3133111111", "1131111313",
+ "33111313", "111133111111", "3111111313", "111313111111",
+ "131113111111", "111111111313", "313111111111", "1131131113",
+ "33131113", "11113111111111", "3111131113", "113311111111",
+ "131311111111", "111111131113", "3113111113", "11311111111111",
+ "331111111111", "111113111113", "31111111111111", "111311111113",
+ "131111111113"
+ };
+
+ public Telepen() {
+ mode = tp_mode.NORMAL;
+ }
+
+ public void setNormalMode() {
+ mode = tp_mode.NORMAL;
+ }
+
+ public void setNumericMode() {
+ mode = tp_mode.NUMERIC;
+ }
+
+ @Override
+ public boolean encode() {
+ if (mode == tp_mode.NORMAL) {
+ return normal_mode();
+ } else {
+ return numeric_mode();
+ }
+ }
+
+ private boolean normal_mode() {
+ int count = 0, asciicode, check_digit;
+ StringBuilder p = new StringBuilder();
+ String dest;
+
+ int l = content.length();
+
+ if (!content.matches("[\u0000-\u007F]+")) {
+ errorMsg.append("Invalid characters in input data");
+ return false;
+ }
+
+ dest = TeleTable['_']; // Start
+ for (int i = 0; i < l; i++) {
+ asciicode = content.charAt(i);
+ p.append(TeleTable[asciicode]);
+ count += asciicode;
+ }
+
+ check_digit = 127 - (count % 127);
+ if (check_digit == 127) {
+ check_digit = 0;
+ }
+
+ p.append(TeleTable[check_digit]);
+
+ encodeInfo.append("Check Digit: ").append(check_digit).append("\n");
+
+ dest += p;
+ dest += TeleTable['z']; // Stop
+
+ readable = new StringBuilder(content);
+ pattern = new String[1];
+ pattern[0] = dest;
+ rowCount = 1;
+ rowHeight = new int[1];
+ rowHeight[0] = -1;
+ plotSymbol();
+ return true;
+ }
+
+ public boolean numeric_mode() {
+ int count = 0, check_digit;
+ StringBuilder p = new StringBuilder();
+ String t;
+ String dest;
+ int l = content.length();
+ int tl, glyph;
+ char c1, c2;
+
+ //FIXME: Ensure no extended ASCII or Unicode charcters are entered
+ if (!(content.matches("[0-9X]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ /* If input is an odd length, add a leading zero */
+ if ((l & 1) == 1) {
+ t = "0" + content;
+ tl = l + 1;
+ } else {
+ t = content;
+ tl = l;
+ }
+
+ dest = TeleTable['_']; // Start
+ for (int i = 0; i < tl; i += 2) {
+
+ c1 = t.charAt(i);
+ c2 = t.charAt(i + 1);
+
+ /* Input nX is allowed, but Xn is not */
+ if (c1 == 'X') {
+ errorMsg.append("Invalid position of X in data");
+ return false;
+ }
+
+ if (c2 == 'X') {
+ glyph = (c1 - '0') + 17;
+ count += glyph;
+ } else {
+ glyph = ((10 * (c1 - '0')) + (c2 - '0')) + 27;
+ count += glyph;
+ }
+
+ p.append(TeleTable[glyph]);
+ }
+
+ check_digit = 127 - (count % 127);
+ if (check_digit == 127) {
+ check_digit = 0;
+ }
+
+ p.append(TeleTable[check_digit]);
+
+ encodeInfo.append("Check Digit: ").append(check_digit).append("\n");
+
+ dest += p;
+ dest += TeleTable['z']; // Stop
+ readable = new StringBuilder(content);
+ pattern = new String[1];
+ pattern[0] = dest;
+ rowCount = 1;
+ rowHeight = new int[1];
+ rowHeight[0] = -1;
+ plotSymbol();
+ return true;
+ }
+
+ public enum tp_mode {
+ NORMAL, NUMERIC
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/Upc.java b/barcode/src/main/java/org/xbib/graphics/barcode/Upc.java
new file mode 100755
index 0000000..43ca5dc
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/Upc.java
@@ -0,0 +1,445 @@
+package org.xbib.graphics.barcode;
+
+import static org.xbib.graphics.barcode.HumanReadableLocation.NONE;
+import static org.xbib.graphics.barcode.HumanReadableLocation.TOP;
+import org.xbib.graphics.barcode.util.AddOn;
+import org.xbib.graphics.barcode.util.TextBox;
+import java.awt.geom.Rectangle2D;
+
+/**
+ * Implements UPC bar code symbology.
+ * According to BS EN 797:1996
+ * UPC-A requires an 11 digit article number. The check digit is calculated.
+ * UPC-E is a zero-compressed version of UPC-A developed for smaller packages.
+ * The code requires a 6 digit article number (digits 0-9). The check digit
+ * is calculated. Also supports Number System 1 encoding by entering a 7-digit
+ * article number stating with the digit 1. In addition EAN-2 and EAN-5 add-on
+ * symbols can be added using the + character followed by the add-on data.
+ *
+ * @author Robert Elliott
+ */
+public class Upc extends Symbol {
+
+ private boolean useAddOn;
+
+ ;
+ private String addOnContent;
+ private Mode mode;
+ private boolean linkageFlag;
+ private String[] setAC = {
+ "3211", "2221", "2122", "1411", "1132", "1231", "1114", "1312",
+ "1213", "3112"
+ };
+ private String[] setB = {
+ "1123", "1222", "2212", "1141", "2311", "1321", "4111", "2131",
+ "3121", "2113"
+ };
+ private String[] UPCParity0 = {
+ "BBBAAA", "BBABAA", "BBAABA", "BBAAAB", "BABBAA", "BAABBA", "BAAABB",
+ "BABABA", "BABAAB", "BAABAB"
+ }; /* Number set for UPC-E symbol (EN Table 4) */
+ private String[] UPCParity1 = {
+ "AAABBB", "AABABB", "AABBAB", "AABBBA", "ABAABB", "ABBAAB", "ABBBAA",
+ "ABABAB", "ABABBA", "ABBABA"
+ }; /* Not covered by BS EN 797 */
+
+ public Upc() {
+ mode = Mode.UPCA;
+ linkageFlag = false;
+ }
+
+ public Mode getMode() {
+ return mode;
+ }
+
+ public void setMode(Mode mode) {
+ this.mode = mode;
+ }
+
+ public void setLinkageFlag() {
+ linkageFlag = true;
+ }
+
+ public void unsetLinkageFlag() {
+ linkageFlag = false;
+ }
+
+ @Override
+ public void setHumanReadableLocation(HumanReadableLocation humanReadableLocation) {
+ if (humanReadableLocation == TOP) {
+ throw new IllegalArgumentException("Cannot display human-readable text above UPC bar codes.");
+ } else {
+ super.setHumanReadableLocation(humanReadableLocation);
+ }
+ }
+
+ @Override
+ public boolean encode() {
+ boolean retval;
+ AddOn addOn = new AddOn();
+ String addOnData = "";
+
+ separateContent();
+ if (content.length() == 0) {
+ errorMsg.append("Missing UPC data");
+ retval = false;
+ } else {
+ if (mode == Mode.UPCA) {
+ retval = upca();
+ } else {
+ retval = upce();
+ }
+ }
+
+ if (useAddOn) {
+ addOnData = addOn.calcAddOn(addOnContent);
+ if (addOnData.length() == 0) {
+ errorMsg.append("Invalid Add-On data");
+ retval = false;
+ } else {
+ pattern[0] = pattern[0] + "9" + addOnData;
+
+ //add leading zeroes to add-on text
+ if (addOnContent.length() == 1) {
+ addOnContent = "0" + addOnContent;
+ }
+ if (addOnContent.length() == 3) {
+ addOnContent = "0" + addOnContent;
+ }
+ if (addOnContent.length() == 4) {
+ addOnContent = "0" + addOnContent;
+ }
+ }
+ }
+
+ if (retval) {
+ plotSymbol();
+ }
+ return retval;
+ }
+
+ private void separateContent() {
+ int splitPoint;
+
+ splitPoint = content.indexOf('+');
+ if (splitPoint != -1) {
+ // There is a '+' in the input data, use an add-on EAN2 or EAN5
+ useAddOn = true;
+ addOnContent = content.substring(splitPoint + 1);
+ content = content.substring(0, splitPoint);
+ }
+ }
+
+ private boolean upca() {
+ StringBuilder accumulator;
+ StringBuilder dest;
+ int i;
+ char check;
+
+ if (!(content.matches("[0-9]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ if (content.length() > 11) {
+ errorMsg.append("Input data too long");
+ return false;
+ }
+
+ accumulator = new StringBuilder();
+ for (i = content.length(); i < 11; i++) {
+ accumulator.append("0");
+ }
+ accumulator.append(content);
+ check = calcDigit(accumulator.toString());
+ accumulator.append(check);
+ dest = new StringBuilder("111");
+ for (i = 0; i < 12; i++) {
+ if (i == 6) {
+ dest.append("11111");
+ }
+ dest.append(setAC[Character.getNumericValue(accumulator.charAt(i))]);
+ }
+ dest.append("111");
+
+ encodeInfo.append("Check Digit: ").append(check).append("\n");
+
+ readable = accumulator;
+ pattern = new String[1];
+ pattern[0] = dest.toString();
+ rowCount = 1;
+ rowHeight = new int[1];
+ rowHeight[0] = -1;
+ return true;
+ }
+
+ private boolean upce() {
+ int i, num_system;
+ char emode, check;
+ StringBuilder source;
+ String parity;
+ StringBuilder dest;
+ char[] equivalent = new char[12];
+ StringBuilder equiv = new StringBuilder();
+
+ if (!(content.matches("[0-9]+"))) {
+ errorMsg.append("Invalid characters in input");
+ return false;
+ }
+
+ if (content.length() > 7) {
+ errorMsg.append("Input data too long");
+ return false;
+ }
+
+ source = new StringBuilder();
+ for (i = content.length(); i < 7; i++) {
+ source.append("0");
+ }
+ source.append(content);
+
+ /* Two number systems can be used - system 0 and system 1 */
+ switch (source.charAt(0)) {
+ case '0':
+ num_system = 0;
+ break;
+ case '1':
+ num_system = 1;
+ break;
+ default:
+ errorMsg.append("Invalid input data");
+ return false;
+ }
+
+ /* Expand the zero-compressed UPCE code to make a UPCA equivalent (EN Table 5) */
+ emode = source.charAt(6);
+ for (i = 0; i < 11; i++) {
+ equivalent[i] = '0';
+ }
+ equivalent[0] = source.charAt(0);
+ equivalent[1] = source.charAt(1);
+ equivalent[2] = source.charAt(2);
+
+ switch (emode) {
+ case '0':
+ case '1':
+ case '2':
+ equivalent[3] = emode;
+ equivalent[8] = source.charAt(3);
+ equivalent[9] = source.charAt(4);
+ equivalent[10] = source.charAt(5);
+ break;
+ case '3':
+ equivalent[3] = source.charAt(3);
+ equivalent[9] = source.charAt(4);
+ equivalent[10] = source.charAt(5);
+ if (((source.charAt(3) == '0') || (source.charAt(3) == '1'))
+ || (source.charAt(3) == '2')) {
+ /* Note 1 - "X3 shall not be equal to 0, 1 or 2" */
+ errorMsg.append("Invalid UPC-E data");
+ return false;
+ }
+ break;
+ case '4':
+ equivalent[3] = source.charAt(3);
+ equivalent[4] = source.charAt(4);
+ equivalent[10] = source.charAt(5);
+ if (source.charAt(4) == '0') {
+ /* Note 2 - "X4 shall not be equal to 0" */
+ errorMsg.append("Invalid UPC-E data");
+ return false;
+ }
+ break;
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ equivalent[3] = source.charAt(3);
+ equivalent[4] = source.charAt(4);
+ equivalent[5] = source.charAt(5);
+ equivalent[10] = emode;
+ if (source.charAt(5) == '0') {
+ /* Note 3 - "X5 shall not be equal to 0" */
+ errorMsg.append("Invalid UPC-E data");
+ return false;
+ }
+ break;
+ }
+
+ for (i = 0; i < 11; i++) {
+ equiv.append(equivalent[i]);
+ }
+
+ /* Get the check digit from the expanded UPCA code */
+ check = calcDigit(equiv.toString());
+
+ encodeInfo.append("Check Digit: ").append(check).append("\n");
+
+ /* Use the number system and check digit information to choose a parity scheme */
+ if (num_system == 1) {
+ parity = UPCParity1[check - '0'];
+ } else {
+ parity = UPCParity0[check - '0'];
+ }
+
+ /* Take all this information and make the barcode pattern */
+
+ /* start character */
+ dest = new StringBuilder("111");
+
+ for (i = 0; i <= 5; i++) {
+ switch (parity.charAt(i)) {
+ case 'A':
+ dest.append(setAC[source.charAt(i + 1) - '0']);
+ break;
+ case 'B':
+ dest.append(setB[source.charAt(i + 1) - '0']);
+ break;
+ }
+ }
+
+ /* stop character */
+ dest.append("111111");
+
+ readable = new StringBuilder(source.toString()).append(check);
+ pattern = new String[1];
+ pattern[0] = dest.toString();
+ rowCount = 1;
+ rowHeight = new int[1];
+ rowHeight[0] = -1;
+ return true;
+ }
+
+ private char calcDigit(String x) {
+ int count = 0;
+ int c, cdigit;
+ for (int i = 0; i < 11; i++) {
+ c = Character.getNumericValue(x.charAt(i));
+ if ((i % 2) == 0) {
+ c = c * 3;
+ }
+ count = count + c;
+ }
+ cdigit = 10 - (count % 10);
+ if (cdigit == 10) {
+ cdigit = 0;
+ }
+
+ return (char) (cdigit + '0');
+ }
+
+ @Override
+ protected void plotSymbol() {
+ int xBlock;
+ int x, y, w, h;
+ boolean black;
+ int compositeOffset = 0;
+ int shortLongDiff = 5;
+ getRectangles().clear();
+ getTexts().clear();
+ black = true;
+ x = 0;
+ if (linkageFlag) {
+ compositeOffset = 6;
+ }
+ for (xBlock = 0; xBlock < pattern[0].length(); xBlock++) {
+ if (black) {
+ y = 0;
+ black = false;
+ w = pattern[0].charAt(xBlock) - '0';
+ h = defaultHeight;
+ /* Add extension to guide bars */
+ if (mode == Mode.UPCA) {
+ if ((x < 10) || (x > 84)) {
+ h += shortLongDiff;
+ }
+ if ((x > 45) && (x < 49)) {
+ h += shortLongDiff;
+ }
+ if (x > 95) {
+ // Drop add-on
+ h -= 8;
+ y = 8;
+ }
+ if (linkageFlag && (x == 0) || (x == 94)) {
+ h += 2;
+ y -= 2;
+ }
+ } else {
+ if ((x < 4) || (x > 45)) {
+ h += shortLongDiff;
+ }
+ if (x > 52) {
+ // Drop add-on
+ h -= 8;
+ y = 8;
+ }
+ if (linkageFlag && (x == 0) || (x == 50)) {
+ h += 2;
+ y -= 2;
+ }
+ }
+ Rectangle2D.Double rect = new Rectangle2D.Double(x + 6, y + compositeOffset, w, h);
+ getRectangles().add(rect);
+ if ((x + w + 12) > symbolWidth) {
+ symbolWidth = x + w + 12;
+ }
+ } else {
+ black = true;
+ }
+ x += pattern[0].charAt(xBlock) - '0';
+ }
+
+ if (linkageFlag) {
+ // Add separator for composite symbology
+ if (mode == Mode.UPCA) {
+ getRectangles().add(new Rectangle2D.Double(6, 0, 1, 2));
+ getRectangles().add(new Rectangle2D.Double(94 + 6, 0, 1, 2));
+ getRectangles().add(new Rectangle2D.Double(-1 + 6, 2, 1, 2));
+ getRectangles().add(new Rectangle2D.Double(95 + 6, 2, 1, 2));
+ } else { // UPCE
+ getRectangles().add(new Rectangle2D.Double(0 + 6, 0, 1, 2));
+ getRectangles().add(new Rectangle2D.Double(50 + 6, 0, 1, 2));
+ getRectangles().add(new Rectangle2D.Double(-1 + 6, 2, 1, 2));
+ getRectangles().add(new Rectangle2D.Double(51 + 6, 2, 1, 2));
+ }
+ }
+
+ symbolHeight = defaultHeight + 5;
+
+ /* Now add the text */
+ if (getHumanReadableLocation() != NONE) {
+ double baseline = getHeight() + fontSize - shortLongDiff + compositeOffset;
+ double addOnBaseline = 6.0 + compositeOffset;
+ if (mode == Mode.UPCA) {
+ getTexts().add(new TextBox(3, baseline, readable.substring(0, 1)));
+ getTexts().add(new TextBox(34, baseline, readable.substring(1, 6)));
+ getTexts().add(new TextBox(73, baseline, readable.substring(6, 11)));
+ getTexts().add(new TextBox(104, baseline, readable.substring(11, 12)));
+ if (useAddOn) {
+ if (addOnContent.length() == 2) {
+ getTexts().add(new TextBox(118, addOnBaseline, addOnContent));
+ } else {
+ getTexts().add(new TextBox(133, addOnBaseline, addOnContent));
+ }
+ }
+ } else { // UPCE
+ getTexts().add(new TextBox(3, baseline, readable.substring(0, 1)));
+ getTexts().add(new TextBox(30, baseline, readable.substring(1, 7)));
+ getTexts().add(new TextBox(61, baseline, readable.substring(7, 8)));
+ if (useAddOn) {
+ if (addOnContent.length() == 2) {
+ getTexts().add(new TextBox(75, addOnBaseline, addOnContent));
+ } else {
+ getTexts().add(new TextBox(90, addOnBaseline, addOnContent));
+ }
+ }
+ }
+ }
+ }
+
+ public enum Mode {
+ UPCA, UPCE
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/UspsOneCode.java b/barcode/src/main/java/org/xbib/graphics/barcode/UspsOneCode.java
new file mode 100755
index 0000000..e3461b8
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/UspsOneCode.java
@@ -0,0 +1,451 @@
+package org.xbib.graphics.barcode;
+
+import static org.xbib.graphics.barcode.HumanReadableLocation.NONE;
+import static org.xbib.graphics.barcode.HumanReadableLocation.TOP;
+import org.xbib.graphics.barcode.util.TextBox;
+import java.awt.geom.Rectangle2D;
+import java.math.BigInteger;
+
+/**
+ * USPS OneCode (also known as Intelligent Mail Barcode)
+ * According to USPS-B-3200F
+ * Specification at https://ribbs.usps.gov/intelligentmail_mailpieces/documents/tech_guides/SPUSPSG.pdf
+ * OneCode is a fixed length (65-bar) symbol which combines routing and
+ * customer information in a single symbol. Input data consists of a 20 digit
+ * tracking code, followed by a dash (-), followed by a delivery point
+ * zip-code which can be 0, 5, 9 or 11 digits in length.
+ */
+public class UspsOneCode extends Symbol {
+
+ /* The following lookup tables were generated using the code in Appendix C */
+
+ private int[] byte_array = new int[13];
+
+ private int[] AppxD_I = { /* Appendix D Table 1 - 5 of 13 characters */
+ 0x001F, 0x1F00, 0x002F, 0x1E80, 0x0037, 0x1D80, 0x003B, 0x1B80, 0x003D, 0x1780,
+ 0x003E, 0x0F80, 0x004F, 0x1E40, 0x0057, 0x1D40, 0x005B, 0x1B40, 0x005D, 0x1740,
+ 0x005E, 0x0F40, 0x0067, 0x1CC0, 0x006B, 0x1AC0, 0x006D, 0x16C0, 0x006E, 0x0EC0,
+ 0x0073, 0x19C0, 0x0075, 0x15C0, 0x0076, 0x0DC0, 0x0079, 0x13C0, 0x007A, 0x0BC0,
+ 0x007C, 0x07C0, 0x008F, 0x1E20, 0x0097, 0x1D20, 0x009B, 0x1B20, 0x009D, 0x1720,
+ 0x009E, 0x0F20, 0x00A7, 0x1CA0, 0x00AB, 0x1AA0, 0x00AD, 0x16A0, 0x00AE, 0x0EA0,
+ 0x00B3, 0x19A0, 0x00B5, 0x15A0, 0x00B6, 0x0DA0, 0x00B9, 0x13A0, 0x00BA, 0x0BA0,
+ 0x00BC, 0x07A0, 0x00C7, 0x1C60, 0x00CB, 0x1A60, 0x00CD, 0x1660, 0x00CE, 0x0E60,
+ 0x00D3, 0x1960, 0x00D5, 0x1560, 0x00D6, 0x0D60, 0x00D9, 0x1360, 0x00DA, 0x0B60,
+ 0x00DC, 0x0760, 0x00E3, 0x18E0, 0x00E5, 0x14E0, 0x00E6, 0x0CE0, 0x00E9, 0x12E0,
+ 0x00EA, 0x0AE0, 0x00EC, 0x06E0, 0x00F1, 0x11E0, 0x00F2, 0x09E0, 0x00F4, 0x05E0,
+ 0x00F8, 0x03E0, 0x010F, 0x1E10, 0x0117, 0x1D10, 0x011B, 0x1B10, 0x011D, 0x1710,
+ 0x011E, 0x0F10, 0x0127, 0x1C90, 0x012B, 0x1A90, 0x012D, 0x1690, 0x012E, 0x0E90,
+ 0x0133, 0x1990, 0x0135, 0x1590, 0x0136, 0x0D90, 0x0139, 0x1390, 0x013A, 0x0B90,
+ 0x013C, 0x0790, 0x0147, 0x1C50, 0x014B, 0x1A50, 0x014D, 0x1650, 0x014E, 0x0E50,
+ 0x0153, 0x1950, 0x0155, 0x1550, 0x0156, 0x0D50, 0x0159, 0x1350, 0x015A, 0x0B50,
+ 0x015C, 0x0750, 0x0163, 0x18D0, 0x0165, 0x14D0, 0x0166, 0x0CD0, 0x0169, 0x12D0,
+ 0x016A, 0x0AD0, 0x016C, 0x06D0, 0x0171, 0x11D0, 0x0172, 0x09D0, 0x0174, 0x05D0,
+ 0x0178, 0x03D0, 0x0187, 0x1C30, 0x018B, 0x1A30, 0x018D, 0x1630, 0x018E, 0x0E30,
+ 0x0193, 0x1930, 0x0195, 0x1530, 0x0196, 0x0D30, 0x0199, 0x1330, 0x019A, 0x0B30,
+ 0x019C, 0x0730, 0x01A3, 0x18B0, 0x01A5, 0x14B0, 0x01A6, 0x0CB0, 0x01A9, 0x12B0,
+ 0x01AA, 0x0AB0, 0x01AC, 0x06B0, 0x01B1, 0x11B0, 0x01B2, 0x09B0, 0x01B4, 0x05B0,
+ 0x01B8, 0x03B0, 0x01C3, 0x1870, 0x01C5, 0x1470, 0x01C6, 0x0C70, 0x01C9, 0x1270,
+ 0x01CA, 0x0A70, 0x01CC, 0x0670, 0x01D1, 0x1170, 0x01D2, 0x0970, 0x01D4, 0x0570,
+ 0x01D8, 0x0370, 0x01E1, 0x10F0, 0x01E2, 0x08F0, 0x01E4, 0x04F0, 0x01E8, 0x02F0,
+ 0x020F, 0x1E08, 0x0217, 0x1D08, 0x021B, 0x1B08, 0x021D, 0x1708, 0x021E, 0x0F08,
+ 0x0227, 0x1C88, 0x022B, 0x1A88, 0x022D, 0x1688, 0x022E, 0x0E88, 0x0233, 0x1988,
+ 0x0235, 0x1588, 0x0236, 0x0D88, 0x0239, 0x1388, 0x023A, 0x0B88, 0x023C, 0x0788,
+ 0x0247, 0x1C48, 0x024B, 0x1A48, 0x024D, 0x1648, 0x024E, 0x0E48, 0x0253, 0x1948,
+ 0x0255, 0x1548, 0x0256, 0x0D48, 0x0259, 0x1348, 0x025A, 0x0B48, 0x025C, 0x0748,
+ 0x0263, 0x18C8, 0x0265, 0x14C8, 0x0266, 0x0CC8, 0x0269, 0x12C8, 0x026A, 0x0AC8,
+ 0x026C, 0x06C8, 0x0271, 0x11C8, 0x0272, 0x09C8, 0x0274, 0x05C8, 0x0278, 0x03C8,
+ 0x0287, 0x1C28, 0x028B, 0x1A28, 0x028D, 0x1628, 0x028E, 0x0E28, 0x0293, 0x1928,
+ 0x0295, 0x1528, 0x0296, 0x0D28, 0x0299, 0x1328, 0x029A, 0x0B28, 0x029C, 0x0728,
+ 0x02A3, 0x18A8, 0x02A5, 0x14A8, 0x02A6, 0x0CA8, 0x02A9, 0x12A8, 0x02AA, 0x0AA8,
+ 0x02AC, 0x06A8, 0x02B1, 0x11A8, 0x02B2, 0x09A8, 0x02B4, 0x05A8, 0x02B8, 0x03A8,
+ 0x02C3, 0x1868, 0x02C5, 0x1468, 0x02C6, 0x0C68, 0x02C9, 0x1268, 0x02CA, 0x0A68,
+ 0x02CC, 0x0668, 0x02D1, 0x1168, 0x02D2, 0x0968, 0x02D4, 0x0568, 0x02D8, 0x0368,
+ 0x02E1, 0x10E8, 0x02E2, 0x08E8, 0x02E4, 0x04E8, 0x0307, 0x1C18, 0x030B, 0x1A18,
+ 0x030D, 0x1618, 0x030E, 0x0E18, 0x0313, 0x1918, 0x0315, 0x1518, 0x0316, 0x0D18,
+ 0x0319, 0x1318, 0x031A, 0x0B18, 0x031C, 0x0718, 0x0323, 0x1898, 0x0325, 0x1498,
+ 0x0326, 0x0C98, 0x0329, 0x1298, 0x032A, 0x0A98, 0x032C, 0x0698, 0x0331, 0x1198,
+ 0x0332, 0x0998, 0x0334, 0x0598, 0x0338, 0x0398, 0x0343, 0x1858, 0x0345, 0x1458,
+ 0x0346, 0x0C58, 0x0349, 0x1258, 0x034A, 0x0A58, 0x034C, 0x0658, 0x0351, 0x1158,
+ 0x0352, 0x0958, 0x0354, 0x0558, 0x0361, 0x10D8, 0x0362, 0x08D8, 0x0364, 0x04D8,
+ 0x0383, 0x1838, 0x0385, 0x1438, 0x0386, 0x0C38, 0x0389, 0x1238, 0x038A, 0x0A38,
+ 0x038C, 0x0638, 0x0391, 0x1138, 0x0392, 0x0938, 0x0394, 0x0538, 0x03A1, 0x10B8,
+ 0x03A2, 0x08B8, 0x03A4, 0x04B8, 0x03C1, 0x1078, 0x03C2, 0x0878, 0x03C4, 0x0478,
+ 0x040F, 0x1E04, 0x0417, 0x1D04, 0x041B, 0x1B04, 0x041D, 0x1704, 0x041E, 0x0F04,
+ 0x0427, 0x1C84, 0x042B, 0x1A84, 0x042D, 0x1684, 0x042E, 0x0E84, 0x0433, 0x1984,
+ 0x0435, 0x1584, 0x0436, 0x0D84, 0x0439, 0x1384, 0x043A, 0x0B84, 0x043C, 0x0784,
+ 0x0447, 0x1C44, 0x044B, 0x1A44, 0x044D, 0x1644, 0x044E, 0x0E44, 0x0453, 0x1944,
+ 0x0455, 0x1544, 0x0456, 0x0D44, 0x0459, 0x1344, 0x045A, 0x0B44, 0x045C, 0x0744,
+ 0x0463, 0x18C4, 0x0465, 0x14C4, 0x0466, 0x0CC4, 0x0469, 0x12C4, 0x046A, 0x0AC4,
+ 0x046C, 0x06C4, 0x0471, 0x11C4, 0x0472, 0x09C4, 0x0474, 0x05C4, 0x0487, 0x1C24,
+ 0x048B, 0x1A24, 0x048D, 0x1624, 0x048E, 0x0E24, 0x0493, 0x1924, 0x0495, 0x1524,
+ 0x0496, 0x0D24, 0x0499, 0x1324, 0x049A, 0x0B24, 0x049C, 0x0724, 0x04A3, 0x18A4,
+ 0x04A5, 0x14A4, 0x04A6, 0x0CA4, 0x04A9, 0x12A4, 0x04AA, 0x0AA4, 0x04AC, 0x06A4,
+ 0x04B1, 0x11A4, 0x04B2, 0x09A4, 0x04B4, 0x05A4, 0x04C3, 0x1864, 0x04C5, 0x1464,
+ 0x04C6, 0x0C64, 0x04C9, 0x1264, 0x04CA, 0x0A64, 0x04CC, 0x0664, 0x04D1, 0x1164,
+ 0x04D2, 0x0964, 0x04D4, 0x0564, 0x04E1, 0x10E4, 0x04E2, 0x08E4, 0x0507, 0x1C14,
+ 0x050B, 0x1A14, 0x050D, 0x1614, 0x050E, 0x0E14, 0x0513, 0x1914, 0x0515, 0x1514,
+ 0x0516, 0x0D14, 0x0519, 0x1314, 0x051A, 0x0B14, 0x051C, 0x0714, 0x0523, 0x1894,
+ 0x0525, 0x1494, 0x0526, 0x0C94, 0x0529, 0x1294, 0x052A, 0x0A94, 0x052C, 0x0694,
+ 0x0531, 0x1194, 0x0532, 0x0994, 0x0534, 0x0594, 0x0543, 0x1854, 0x0545, 0x1454,
+ 0x0546, 0x0C54, 0x0549, 0x1254, 0x054A, 0x0A54, 0x054C, 0x0654, 0x0551, 0x1154,
+ 0x0552, 0x0954, 0x0561, 0x10D4, 0x0562, 0x08D4, 0x0583, 0x1834, 0x0585, 0x1434,
+ 0x0586, 0x0C34, 0x0589, 0x1234, 0x058A, 0x0A34, 0x058C, 0x0634, 0x0591, 0x1134,
+ 0x0592, 0x0934, 0x05A1, 0x10B4, 0x05A2, 0x08B4, 0x05C1, 0x1074, 0x05C2, 0x0874,
+ 0x0607, 0x1C0C, 0x060B, 0x1A0C, 0x060D, 0x160C, 0x060E, 0x0E0C, 0x0613, 0x190C,
+ 0x0615, 0x150C, 0x0616, 0x0D0C, 0x0619, 0x130C, 0x061A, 0x0B0C, 0x061C, 0x070C,
+ 0x0623, 0x188C, 0x0625, 0x148C, 0x0626, 0x0C8C, 0x0629, 0x128C, 0x062A, 0x0A8C,
+ 0x062C, 0x068C, 0x0631, 0x118C, 0x0632, 0x098C, 0x0643, 0x184C, 0x0645, 0x144C,
+ 0x0646, 0x0C4C, 0x0649, 0x124C, 0x064A, 0x0A4C, 0x0651, 0x114C, 0x0652, 0x094C,
+ 0x0661, 0x10CC, 0x0662, 0x08CC, 0x0683, 0x182C, 0x0685, 0x142C, 0x0686, 0x0C2C,
+ 0x0689, 0x122C, 0x068A, 0x0A2C, 0x0691, 0x112C, 0x0692, 0x092C, 0x06A1, 0x10AC,
+ 0x06A2, 0x08AC, 0x06C1, 0x106C, 0x06C2, 0x086C, 0x0703, 0x181C, 0x0705, 0x141C,
+ 0x0706, 0x0C1C, 0x0709, 0x121C, 0x070A, 0x0A1C, 0x0711, 0x111C, 0x0712, 0x091C,
+ 0x0721, 0x109C, 0x0722, 0x089C, 0x0741, 0x105C, 0x0742, 0x085C, 0x0781, 0x103C,
+ 0x0782, 0x083C, 0x080F, 0x1E02, 0x0817, 0x1D02, 0x081B, 0x1B02, 0x081D, 0x1702,
+ 0x081E, 0x0F02, 0x0827, 0x1C82, 0x082B, 0x1A82, 0x082D, 0x1682, 0x082E, 0x0E82,
+ 0x0833, 0x1982, 0x0835, 0x1582, 0x0836, 0x0D82, 0x0839, 0x1382, 0x083A, 0x0B82,
+ 0x0847, 0x1C42, 0x084B, 0x1A42, 0x084D, 0x1642, 0x084E, 0x0E42, 0x0853, 0x1942,
+ 0x0855, 0x1542, 0x0856, 0x0D42, 0x0859, 0x1342, 0x085A, 0x0B42, 0x0863, 0x18C2,
+ 0x0865, 0x14C2, 0x0866, 0x0CC2, 0x0869, 0x12C2, 0x086A, 0x0AC2, 0x0871, 0x11C2,
+ 0x0872, 0x09C2, 0x0887, 0x1C22, 0x088B, 0x1A22, 0x088D, 0x1622, 0x088E, 0x0E22,
+ 0x0893, 0x1922, 0x0895, 0x1522, 0x0896, 0x0D22, 0x0899, 0x1322, 0x089A, 0x0B22,
+ 0x08A3, 0x18A2, 0x08A5, 0x14A2, 0x08A6, 0x0CA2, 0x08A9, 0x12A2, 0x08AA, 0x0AA2,
+ 0x08B1, 0x11A2, 0x08B2, 0x09A2, 0x08C3, 0x1862, 0x08C5, 0x1462, 0x08C6, 0x0C62,
+ 0x08C9, 0x1262, 0x08CA, 0x0A62, 0x08D1, 0x1162, 0x08D2, 0x0962, 0x08E1, 0x10E2,
+ 0x0907, 0x1C12, 0x090B, 0x1A12, 0x090D, 0x1612, 0x090E, 0x0E12, 0x0913, 0x1912,
+ 0x0915, 0x1512, 0x0916, 0x0D12, 0x0919, 0x1312, 0x091A, 0x0B12, 0x0923, 0x1892,
+ 0x0925, 0x1492, 0x0926, 0x0C92, 0x0929, 0x1292, 0x092A, 0x0A92, 0x0931, 0x1192,
+ 0x0932, 0x0992, 0x0943, 0x1852, 0x0945, 0x1452, 0x0946, 0x0C52, 0x0949, 0x1252,
+ 0x094A, 0x0A52, 0x0951, 0x1152, 0x0961, 0x10D2, 0x0983, 0x1832, 0x0985, 0x1432,
+ 0x0986, 0x0C32, 0x0989, 0x1232, 0x098A, 0x0A32, 0x0991, 0x1132, 0x09A1, 0x10B2,
+ 0x09C1, 0x1072, 0x0A07, 0x1C0A, 0x0A0B, 0x1A0A, 0x0A0D, 0x160A, 0x0A0E, 0x0E0A,
+ 0x0A13, 0x190A, 0x0A15, 0x150A, 0x0A16, 0x0D0A, 0x0A19, 0x130A, 0x0A1A, 0x0B0A,
+ 0x0A23, 0x188A, 0x0A25, 0x148A, 0x0A26, 0x0C8A, 0x0A29, 0x128A, 0x0A2A, 0x0A8A,
+ 0x0A31, 0x118A, 0x0A43, 0x184A, 0x0A45, 0x144A, 0x0A46, 0x0C4A, 0x0A49, 0x124A,
+ 0x0A51, 0x114A, 0x0A61, 0x10CA, 0x0A83, 0x182A, 0x0A85, 0x142A, 0x0A86, 0x0C2A,
+ 0x0A89, 0x122A, 0x0A91, 0x112A, 0x0AA1, 0x10AA, 0x0AC1, 0x106A, 0x0B03, 0x181A,
+ 0x0B05, 0x141A, 0x0B06, 0x0C1A, 0x0B09, 0x121A, 0x0B11, 0x111A, 0x0B21, 0x109A,
+ 0x0B41, 0x105A, 0x0B81, 0x103A, 0x0C07, 0x1C06, 0x0C0B, 0x1A06, 0x0C0D, 0x1606,
+ 0x0C0E, 0x0E06, 0x0C13, 0x1906, 0x0C15, 0x1506, 0x0C16, 0x0D06, 0x0C19, 0x1306,
+ 0x0C23, 0x1886, 0x0C25, 0x1486, 0x0C26, 0x0C86, 0x0C29, 0x1286, 0x0C31, 0x1186,
+ 0x0C43, 0x1846, 0x0C45, 0x1446, 0x0C49, 0x1246, 0x0C51, 0x1146, 0x0C61, 0x10C6,
+ 0x0C83, 0x1826, 0x0C85, 0x1426, 0x0C89, 0x1226, 0x0C91, 0x1126, 0x0CA1, 0x10A6,
+ 0x0CC1, 0x1066, 0x0D03, 0x1816, 0x0D05, 0x1416, 0x0D09, 0x1216, 0x0D11, 0x1116,
+ 0x0D21, 0x1096, 0x0D41, 0x1056, 0x0D81, 0x1036, 0x0E03, 0x180E, 0x0E05, 0x140E,
+ 0x0E09, 0x120E, 0x0E11, 0x110E, 0x0E21, 0x108E, 0x0E41, 0x104E, 0x0E81, 0x102E,
+ 0x0F01, 0x101E, 0x100F, 0x1E01, 0x1017, 0x1D01, 0x101B, 0x1B01, 0x101D, 0x1701,
+ 0x1027, 0x1C81, 0x102B, 0x1A81, 0x102D, 0x1681, 0x1033, 0x1981, 0x1035, 0x1581,
+ 0x1039, 0x1381, 0x1047, 0x1C41, 0x104B, 0x1A41, 0x104D, 0x1641, 0x1053, 0x1941,
+ 0x1055, 0x1541, 0x1059, 0x1341, 0x1063, 0x18C1, 0x1065, 0x14C1, 0x1069, 0x12C1,
+ 0x1071, 0x11C1, 0x1087, 0x1C21, 0x108B, 0x1A21, 0x108D, 0x1621, 0x1093, 0x1921,
+ 0x1095, 0x1521, 0x1099, 0x1321, 0x10A3, 0x18A1, 0x10A5, 0x14A1, 0x10A9, 0x12A1,
+ 0x10B1, 0x11A1, 0x10C3, 0x1861, 0x10C5, 0x1461, 0x10C9, 0x1261, 0x10D1, 0x1161,
+ 0x1107, 0x1C11, 0x110B, 0x1A11, 0x110D, 0x1611, 0x1113, 0x1911, 0x1115, 0x1511,
+ 0x1119, 0x1311, 0x1123, 0x1891, 0x1125, 0x1491, 0x1129, 0x1291, 0x1131, 0x1191,
+ 0x1143, 0x1851, 0x1145, 0x1451, 0x1149, 0x1251, 0x1183, 0x1831, 0x1185, 0x1431,
+ 0x1189, 0x1231, 0x1207, 0x1C09, 0x120B, 0x1A09, 0x120D, 0x1609, 0x1213, 0x1909,
+ 0x1215, 0x1509, 0x1219, 0x1309, 0x1223, 0x1889, 0x1225, 0x1489, 0x1229, 0x1289,
+ 0x1243, 0x1849, 0x1245, 0x1449, 0x1283, 0x1829, 0x1285, 0x1429, 0x1303, 0x1819,
+ 0x1305, 0x1419, 0x1407, 0x1C05, 0x140B, 0x1A05, 0x140D, 0x1605, 0x1413, 0x1905,
+ 0x1415, 0x1505, 0x1423, 0x1885, 0x1425, 0x1485, 0x1443, 0x1845, 0x1483, 0x1825,
+ 0x1503, 0x1815, 0x1603, 0x180D, 0x1807, 0x1C03, 0x180B, 0x1A03, 0x1813, 0x1903,
+ 0x1823, 0x1883, 0x1843, 0x1445, 0x1249, 0x1151, 0x10E1, 0x0C46, 0x0A4A, 0x0952,
+ 0x08E2, 0x064C, 0x0554, 0x04E4, 0x0358, 0x02E8, 0x01F0
+ };
+ private int[] AppxD_II = { /* Appendix D Table II - 2 of 13 characters */
+ 0x0003, 0x1800, 0x0005, 0x1400, 0x0006, 0x0C00, 0x0009, 0x1200, 0x000A, 0x0A00,
+ 0x000C, 0x0600, 0x0011, 0x1100, 0x0012, 0x0900, 0x0014, 0x0500, 0x0018, 0x0300,
+ 0x0021, 0x1080, 0x0022, 0x0880, 0x0024, 0x0480, 0x0028, 0x0280, 0x0030, 0x0180,
+ 0x0041, 0x1040, 0x0042, 0x0840, 0x0044, 0x0440, 0x0048, 0x0240, 0x0050, 0x0140,
+ 0x0060, 0x00C0, 0x0081, 0x1020, 0x0082, 0x0820, 0x0084, 0x0420, 0x0088, 0x0220,
+ 0x0090, 0x0120, 0x0101, 0x1010, 0x0102, 0x0810, 0x0104, 0x0410, 0x0108, 0x0210,
+ 0x0201, 0x1008, 0x0202, 0x0808, 0x0204, 0x0408, 0x0401, 0x1004, 0x0402, 0x0804,
+ 0x0801, 0x1002, 0x1001, 0x0802, 0x0404, 0x0208, 0x0110, 0x00A0
+ };
+ private int[] AppxD_IV = { /* Appendix D Table IV - Bar-to-Character Mapping (reverse lookup) */
+ 67, 6, 78, 16, 86, 95, 34, 40, 45, 113, 117, 121, 62, 87, 18, 104, 41, 76, 57, 119, 115, 72, 97,
+ 2, 127, 26, 105, 35, 122, 52, 114, 7, 24, 82, 68, 63, 94, 44, 77, 112, 70, 100, 39, 30, 107,
+ 15, 125, 85, 10, 65, 54, 88, 20, 106, 46, 66, 8, 116, 29, 61, 99, 80, 90, 37, 123, 51, 25, 84,
+ 129, 56, 4, 109, 96, 28, 36, 47, 11, 71, 33, 102, 21, 9, 17, 49, 124, 79, 64, 91, 42, 69, 53,
+ 60, 14, 1, 27, 103, 126, 75, 89, 50, 120, 19, 32, 110, 92, 111, 130, 59, 31, 12, 81, 43, 55,
+ 5, 74, 22, 101, 128, 58, 118, 48, 108, 38, 98, 93, 23, 83, 13, 73, 3
+ };
+
+ public UspsOneCode() {
+ this.defaultHeight = 8;
+ setHumanReadableLocation(HumanReadableLocation.NONE);
+ }
+
+ @Override
+ public boolean encode() {
+ StringBuilder zip = new StringBuilder();
+ String zip_adder;
+ StringBuilder tracker = new StringBuilder();
+ int i, j;
+ int length = content.length();
+ BigInteger accum;
+ BigInteger x_reg;
+ BigInteger mask;
+ int usps_crc;
+ int[] codeword = new int[10];
+ int[] characters = new int[10];
+ boolean[] bar_map = new boolean[130];
+ char c;
+
+ if (!content.matches("[0-9\u002D]+")) {
+ errorMsg.append("Invalid characters in input data");
+ return false;
+ }
+
+ if (length > 32) {
+ errorMsg.append("Input too long");
+ return false;
+ }
+
+ /* separate the tracking code from the routing code */
+ j = 0;
+ for (i = 0; i < length; i++) {
+ if (content.charAt(i) == '-') {
+ j = 1;
+ } else {
+ if (j == 0) {
+ /* reading tracker */
+ tracker.append(content.charAt(i));
+ } else {
+ /* reading zip code */
+ zip.append(content.charAt(i));
+ }
+ }
+ }
+
+ if (tracker.length() != 20) {
+ errorMsg.append("Invalid length tracking code");
+ return false;
+ }
+
+ if (zip.length() > 11) {
+ errorMsg.append("Invalid ZIP code");
+ return false;
+ }
+
+ /* *** Step 1 - Conversion of Data Fields into Binary Data *** */
+ /* Routing code first */
+ if (zip.length() > 0) {
+ x_reg = new BigInteger(zip.toString());
+ } else {
+ x_reg = new BigInteger("0");
+ }
+
+ /* add weight to routing code */
+ if (zip.length() > 9) {
+ zip_adder = "1000100001";
+ } else {
+ if (zip.length() > 5) {
+ zip_adder = "100001";
+ } else {
+ if (zip.length() > 0) {
+ zip_adder = "1";
+ } else {
+ zip_adder = "0";
+ }
+ }
+ }
+
+ accum = new BigInteger(zip_adder);
+ accum = accum.add(x_reg);
+ accum = accum.multiply(BigInteger.valueOf(10));
+ accum = accum.add(BigInteger.valueOf(Character.getNumericValue(tracker.charAt(0))));
+ accum = accum.multiply(BigInteger.valueOf(5));
+ accum = accum.add(BigInteger.valueOf(Character.getNumericValue(tracker.charAt(1))));
+ for (i = 2; i < tracker.length(); i++) {
+ accum = accum.multiply(BigInteger.valueOf(10));
+ accum = accum.add(BigInteger.valueOf(Character.getNumericValue(tracker.charAt(i))));
+ }
+
+ /* *** Step 2 - Generation of 11-bit CRC on Binary Data *** */
+
+ for (i = 0; i < 13; i++) {
+ mask = accum.shiftRight(96 - (8 * i));
+ mask = mask.and(new BigInteger("255"));
+ byte_array[i] = mask.intValue();
+ }
+
+ usps_crc = USPS_MSB_Math_CRC11GenerateFrameCheckSequence();
+
+ /* *** Step 3 - Conversion from Binary Data to Codewords *** */
+ /* start with codeword J which is base 636 */
+
+ x_reg = accum.mod(BigInteger.valueOf(636));
+ codeword[9] = x_reg.intValue();
+ accum = accum.subtract(x_reg);
+ accum = accum.divide(BigInteger.valueOf(636));
+
+ for (i = 8; i >= 0; i--) {
+ x_reg = accum.mod(BigInteger.valueOf(1365));
+ codeword[i] = x_reg.intValue();
+ accum = accum.subtract(x_reg);
+ accum = accum.divide(BigInteger.valueOf(1365));
+ }
+
+ for (i = 0; i < 9; i++) {
+ if (codeword[i] == 1365) {
+ codeword[i] = 0;
+ }
+ }
+
+ /* *** Step 4 - Inserting Additional Information into Codewords *** */
+ codeword[9] = codeword[9] * 2;
+
+ if (usps_crc >= 1024) {
+ codeword[0] += 659;
+ }
+
+ encodeInfo.append("Codewords: ");
+ for (i = 0; i < 10; i++) {
+ encodeInfo.append(Integer.toString(codeword[i])).append(" ");
+ }
+ encodeInfo.append("\n");
+
+ /* *** Step 5 - Conversion from Codewords to Characters *** */
+
+ for (i = 0; i < 10; i++) {
+ if (codeword[i] < 1287) {
+ characters[i] = AppxD_I[codeword[i]];
+ } else {
+ characters[i] = AppxD_II[codeword[i] - 1287];
+ }
+ }
+
+ for (i = 0; i < 10; i++) {
+ if ((usps_crc & (1 << i)) != 0) {
+ characters[i] = 0x1FFF - characters[i];
+ }
+ }
+
+ /* *** Step 6 - Conversion from Characters to the Intelligent Mail Barcode *** */
+
+ for (i = 0; i < 10; i++) {
+ for (j = 0; j < 13; j++) {
+ bar_map[AppxD_IV[(13 * i) + j] - 1] = (characters[i] & (1 << j)) != 0;
+ }
+ }
+
+ readable = new StringBuilder(content);
+ pattern = new String[1];
+ rowCount = 1;
+ rowHeight = new int[1];
+ rowHeight[0] = -1;
+
+ pattern[0] = "";
+ for (i = 0; i < 65; i++) {
+ c = 'T';
+ if (bar_map[i]) {
+ c = 'D';
+ }
+ if (bar_map[i + 65]) {
+ c = 'A';
+ }
+ if (bar_map[i] && bar_map[i + 65]) {
+ c = 'F';
+ }
+ pattern[0] += c;
+ }
+
+ encodeInfo.append("Encoding: ").append(pattern[0]).append("\n");
+
+ plotSymbol();
+ return true;
+ }
+
+ private int USPS_MSB_Math_CRC11GenerateFrameCheckSequence() {
+ int GeneratorPolynomial = 0x0F35;
+ int FrameCheckSequence = 0x07FF;
+ int Data;
+ int ByteIndex, Bit;
+ int ByteArrayPtr = 0;
+
+ /* Do most significant byte skipping the 2 most significant bits */
+ Data = byte_array[ByteArrayPtr] << 5;
+ ByteArrayPtr++;
+ for (Bit = 2; Bit < 8; Bit++) {
+ if (((FrameCheckSequence ^ Data) & 0x400) != 0)
+ FrameCheckSequence = (FrameCheckSequence << 1) ^ GeneratorPolynomial;
+ else
+ FrameCheckSequence = (FrameCheckSequence << 1);
+ FrameCheckSequence &= 0x7FF;
+ Data <<= 1;
+ }
+ /* Do rest of the bytes */
+ for (ByteIndex = 1; ByteIndex < 13; ByteIndex++) {
+ Data = byte_array[ByteArrayPtr] << 3;
+ ByteArrayPtr++;
+ for (Bit = 0; Bit < 8; Bit++) {
+ if (((FrameCheckSequence ^ Data) & 0x0400) != 0) {
+ FrameCheckSequence = (FrameCheckSequence << 1) ^ GeneratorPolynomial;
+ } else {
+ FrameCheckSequence = (FrameCheckSequence << 1);
+ }
+ FrameCheckSequence &= 0x7FF;
+ Data <<= 1;
+ }
+ }
+ return FrameCheckSequence;
+ }
+
+ @Override
+ protected void plotSymbol() {
+ int xBlock, shortHeight, longHeight;
+ double x, y, w, h;
+ getRectangles().clear();
+ getTexts().clear();
+ int baseY;
+ if (getHumanReadableLocation() == TOP) {
+ baseY = getTheoreticalHumanReadableHeight();
+ } else {
+ baseY = 0;
+ }
+
+ x = 0;
+ w = moduleWidth;
+ y = 0;
+ h = 0;
+ shortHeight = (int) (0.25 * defaultHeight);
+ longHeight = (int) (0.625 * defaultHeight);
+ for (xBlock = 0; xBlock < pattern[0].length(); xBlock++) {
+
+ switch (pattern[0].charAt(xBlock)) {
+ case 'A':
+ y = baseY;
+ h = longHeight;
+ break;
+ case 'D':
+ y = baseY + defaultHeight - longHeight;
+ h = longHeight;
+ break;
+ case 'F':
+ y = baseY;
+ h = defaultHeight;
+ break;
+ case 'T':
+ y = baseY + defaultHeight - longHeight;
+ h = shortHeight;
+ break;
+ }
+ Rectangle2D.Double rect = new Rectangle2D.Double(x, y, w, h);
+ getRectangles().add(rect);
+ x += (2.43 * w);
+ }
+ symbolWidth = (int) Math.ceil(((pattern[0].length() - 1) * 2.43 * w) + w); // final bar doesn't need extra whitespace
+ symbolHeight = defaultHeight;
+ if (getHumanReadableLocation() != NONE && readable.length() > 0) {
+ double baseline;
+ if (getHumanReadableLocation() == TOP) {
+ baseline = fontSize;
+ } else {
+ baseline = getHeight() + fontSize;
+ }
+ double centerX = getWidth() / 2.0;
+ getTexts().add(new TextBox(centerX, baseline, readable.toString()));
+ }
+ }
+}
diff --git a/barcode/src/main/java/org/xbib/graphics/barcode/UspsPackage.java b/barcode/src/main/java/org/xbib/graphics/barcode/UspsPackage.java
new file mode 100755
index 0000000..0289810
--- /dev/null
+++ b/barcode/src/main/java/org/xbib/graphics/barcode/UspsPackage.java
@@ -0,0 +1,114 @@
+package org.xbib.graphics.barcode;
+
+import org.xbib.graphics.barcode.util.TextBox;
+import java.awt.geom.Rectangle2D;
+
+/**
+ * USPS Intelligent Mail Package Barcode (IMpb)+ * /src/test/resources/uk/org/okapibarcode/backend/[symbol-name]/[test-name].properties (bar code initialization attributes) + * /src/test/resources/uk/org/okapibarcode/backend/[symbol-name]/[test-name].codewords (expected intermediate coding of the bar code) + * /src/test/resources/uk/org/okapibarcode/backend/[symbol-name]/[test-name].png (expected final rendering of the bar code) + *+ * + *
+ * Tests that verify error conditions will contain the following sets of files: + * + *
+ * /src/test/resources/uk/org/okapibarcode/backend/[symbol-name]/[test-name].properties (bar code initialization attributes) + * /src/test/resources/uk/org/okapibarcode/backend/[symbol-name]/[test-name].error (expected error message) + *+ * + * If a properties file is found with no matching expectation files, we assume that it was recently added to the test suite and + * that we need to generate suitable expectation files for it. + * + * A single properties file can contain multiple test configurations (separated by an empty line), as long as the expected output + * is the same for all of those tests. + */ +@ExtendWith(ParameterizedExtension.class) +public class SymbolTest { + + /** The font used to render human-readable text when drawing the symbologies; allows for consistent results across operating systems. */ + private static Font DEJA_VU_SANS; + + /** The type of symbology being tested. */ + private final Class< ? extends Symbol> symbolType; + + /** The test configuration properties. */ + private final Map< String, String > properties; + + /** The file containing the expected intermediate coding of the bar code, if this test verifies successful behavior. */ + private final File codewordsFile; + + /** The file containing the expected final rendering of the bar code, if this test verifies successful behavior. */ + private final File pngFile; + + /** The file containing the expected error message, if this test verifies a failure. */ + private final File errorFile; + + /** + * Finds all test resources and returns the information that JUnit needs to dynamically create the corresponding test cases. + * + * @return the test data needed to dynamically create the test cases + * @throws IOException if there is an error reading a file + */ + @Parameterized.Parameters + public static List< Object[] > data() throws IOException { + String path = "/org/xbib/graphics/barcode/fonts/OkapiDejaVuSans.ttf"; + try { + InputStream is = SymbolTest.class.getResourceAsStream(path); + DEJA_VU_SANS = Font.createFont(Font.TRUETYPE_FONT, is); + GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); + boolean registered = ge.registerFont(DEJA_VU_SANS); + assertTrue(registered); + } catch (IOException | FontFormatException e) { + throw new IOException(e.getMessage(), e); + } + String backend = "org.xbib.graphics.barcode"; + Reflections reflections = new Reflections(backend); + Set< Class< ? extends Symbol >> symbols = reflections.getSubTypesOf(Symbol.class); + List< Object[] > data = new ArrayList<>(); + for (Class< ? extends Symbol > symbol : symbols) { + String symbolName = symbol.getSimpleName().toLowerCase(); + String dir = "src/test/resources/" + backend.replace('.', '/') + "/" + symbolName; + for (File file : getPropertiesFiles(dir)) { + String fileBaseName = file.getName().replaceAll(".properties", ""); + File codewordsFile = new File(file.getParentFile(), fileBaseName + ".codewords"); + File pngFile = new File(file.getParentFile(), fileBaseName + ".png"); + File errorFile = new File(file.getParentFile(), fileBaseName + ".error"); + for (Map< String, String > properties : readProperties(file)) { + data.add(new Object[] { symbol, properties, codewordsFile, pngFile, errorFile }); + } + } + } + return data; + } + /** + * Creates a new test. + * + * @param symbolType the type of symbol being tested + * @param properties the test configuration properties + * @param codewordsFile the file containing the expected intermediate coding of the bar code, if this test verifies successful behavior + * @param pngFile the file containing the expected final rendering of the bar code, if this test verifies successful behavior + * @param errorFile the file containing the expected error message, if this test verifies a failure + */ + public SymbolTest(Class< ? extends Symbol > symbolType, + Map< String, String > properties, + File codewordsFile, + File pngFile, + File errorFile) { + this.symbolType = symbolType; + this.properties = properties; + this.codewordsFile = codewordsFile; + this.pngFile = pngFile; + this.errorFile = errorFile; + } + + /** + * Runs the test. If there are no expectation files yet, we generate them instead of checking against them. + * + * @throws Exception if any error occurs during the test + */ + @TestTemplate + public void test() throws Exception { + Symbol symbol = symbolType.getDeclaredConstructor().newInstance(); + symbol.setFontName(DEJA_VU_SANS.getFontName()); + try { + setProperties(symbol, properties); + } catch (InvocationTargetException e) { + symbol.errorMsg.append(e.getCause().getMessage()); + } + if (codewordsFile.exists()) { + verifySuccess(symbol); + } else if (errorFile.exists()) { + verifyError(symbol); + } + if (!pngFile.exists()) { + generateExpectationFiles(symbol); + } + } + + /** + * Verifies that the specified symbol was encoded and rendered in a way that matches expectations. + * + * @param symbol the symbol to check + * @throws IOException if there is any I/O error + * @throws ReaderException if ZXing has an issue decoding the barcode image + */ + private void verifySuccess(Symbol symbol) throws IOException, ReaderException { + if (symbol.errorMsg.length() > 0) { + fail("got error message: " + symbol.errorMsg); + } + List< String > expectedList = Files.readAllLines(codewordsFile.toPath(), StandardCharsets.UTF_8); + try { + // try to verify codewords + int[] actualCodewords = symbol.getCodewords(); + assertEquals(expectedList.size(), actualCodewords.length); + for (int i = 0; i < actualCodewords.length; i++) { + int expected = getInt(expectedList.get(i)); + int actual = actualCodewords[i]; + assertEquals(expected, actual, "at codeword index " + i); + } + } catch (UnsupportedOperationException e) { + // codewords aren't supported, try to verify patterns + String[] actualPatterns = symbol.pattern; + if (actualPatterns != null) { + assertEquals(expectedList.size(), actualPatterns.length); + for (int i = 0; i < actualPatterns.length; i++) { + String expected = expectedList.get(i); + String actual = actualPatterns[i]; + assertEquals(expected, actual, "at pattern index " + i); + } + } + } + // make sure the barcode images match + if (pngFile.exists()) { + BufferedImage expected = ImageIO.read(pngFile); + BufferedImage actual = draw(symbol, 10.0d); + if (expected != null && actual != null) { + assertEqualImage(pngFile.getName(), expected, actual); + } + // if possible, ensure an independent third party (ZXing) can read the generated barcode and agrees on what it represents + Reader zxingReader = findReader(symbol); + if (zxingReader != null && expected != null) { + LuminanceSource source = new BufferedImageLuminanceSource(expected); + BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source)); + Map