pdf417highlevelencoder.java

生成二维条形码的java程序

/*
 * Copyright 2006 Jeremias Maerki.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* $Id: PDF417HighLevelEncoder.java,v 1.4 2007/03/23 21:16:16 jmaerki Exp $ */

package org.krysalis.barcode4j.impl.pdf417;

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.util.Arrays;

/**
 * PDF417 high-level encoder following the algorithm described in ISO/IEC 15438:2001(E) in
 * annex P.
 * 
 * @version $Id: PDF417HighLevelEncoder.java,v 1.4 2007/03/23 21:16:16 jmaerki Exp $
 */
public class PDF417HighLevelEncoder implements PDF417Constants {

    private static final byte[] MIXED = new byte[128];
    private static final byte[] PUNCTUATION = new byte[128];
    
    static {
        //Construct inverse lookups
        Arrays.fill(MIXED, (byte)-1);
        for (byte i = 0; i < TEXT_MIXED_RAW.length; i++) {
            byte b = TEXT_MIXED_RAW[i];
            if (b > 0) {
                MIXED[b] = i;
            }
        }
        Arrays.fill(PUNCTUATION, (byte)-1);
        for (byte i = 0; i < TEXT_PUNCTUATION_RAW.length; i++) {
            byte b = TEXT_PUNCTUATION_RAW[i];
            if (b > 0) {
                PUNCTUATION[b] = i;
            }
        }
    }
    
    /**
     * Converts the message to a byte array using the default encoding (cp437) as defined by the
     * specification
     * @param msg the message
     * @return the byte array of the message
     */
    public static byte[] getBytesForMessage(String msg) {
        final String charset = "cp437"; //See 4.4.3 and annex B of ISO/IEC 15438:2001(E)
        try {
            return msg.getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            throw new UnsupportedOperationException(
                    "Incompatible JVM! The '" + charset + "' charset is not available!");
        }
    }
    
    /**
     * Performs high-level encoding of a PDF417 message using the algorithm described in annex P
     * of ISO/IEC 15438:2001(E).
     * @param msg the message
     * @return the encoded message (the char values range from 0 to 928)
     */
    public static String encodeHighLevel(String msg) {
        byte[] bytes = null; //Fill later and only if needed 
        
        //the codewords 0..928 are encoded as Unicode characters
        StringBuffer sb = new StringBuffer(msg.length());
        
        int len = msg.length();
        int p = 0;
        int encodingMode = TEXT_COMPACTION; //Default mode, see 4.4.2.1
        while (p < len) {
            int n = determineConsecutiveDigitCount(msg, p);
            if (n >= 13) {
                sb.append((char)LATCH_TO_NUMERIC);
                encodingMode = NUMERIC_COMPACTION;
                encodeNumeric(msg, p, n, sb);
                p += n;
            } else {
                int t = determineConsecutiveTextCount(msg, p);
                if (t >= 5 || n == len) {
                    if (encodingMode != TEXT_COMPACTION) {
                        sb.append((char)LATCH_TO_TEXT);
                    }
                    encodingMode = TEXT_COMPACTION;
                    encodeText(msg, p, t, sb);
                    p += t;
                } else {
                    if (bytes == null) {
                        bytes = getBytesForMessage(msg);
                    }
                    int b = determineConsecutiveBinaryCount(msg, bytes, p);
                    if (b == 0) {
                        b = 1;
                    }
                    if (b == 1 && encodingMode == TEXT_COMPACTION) {
                        encodeBinary(msg, bytes, p, b, encodingMode, sb);
                    } else {
                        //Mode latch performed by encodeBinary()
                        encodeBinary(msg, bytes, p, b, encodingMode, sb);
                        encodingMode = BYTE_COMPACTION;
                    }
                    p += b;
                }
            }
        }
        
        return sb.toString();
    }

    /**
     * Encode parts of the message using Text Compaction as described in ISO/IEC 15438:2001(E), 
     * chapter 4.4.2.
     * @param msg the message
     * @param startpos the start position within the message
     * @param count the number of characters to encode
     * @param sb receives the encoded codewords
     */
    public static void encodeText(String msg, int startpos, int count, StringBuffer sb) {
        StringBuffer tmp = new StringBuffer(count);
        int submode = SUBMODE_ALPHA;
        int idx = 0;
        while (true) {
            char ch = msg.charAt(startpos + idx);
            switch (submode) {
            case SUBMODE_ALPHA:
                if (isAlphaUpper(ch)) {
                    if (ch != ' ') {
                        tmp.append((char)(ch - 65));
                    } else {
                        tmp.append((char)26); //space
                    }
                } else {
                    if (isAlphaLower(ch)) {
                        submode = SUBMODE_LOWER;
                        tmp.append((char)27); //ll
                        continue;
                    } else if (isMixed(ch)) {
                        submode = SUBMODE_MIXED;
                        tmp.append((char)28); //ml
                        continue;
                    } else {
                        tmp.append((char)29); //ps
                        tmp.append((char)PUNCTUATION[ch]);
                        break;
                    }
                }
                break;
            case SUBMODE_LOWER:
                if (isAlphaLower(ch)) {
                    if (ch != ' ') {
                        tmp.append((char)(ch - 97));
                    } else {
                        tmp.append((char)26); //space
                    }
                } else {
                    if (isAlphaUpper(ch)) {
                        tmp.append((char)27); //as
                        tmp.append((char)(ch - 65));
                        //space cannot happen here, it is also in "Lower"
                        break;
                    } else if (isMixed(ch)) {
                        submode = SUBMODE_MIXED;
                        tmp.append((char)28); //ml
                        continue;
                    } else {
                        tmp.append((char)29); //ps
                        tmp.append((char)PUNCTUATION[ch]);
                        break;
                    }
                }
                break;
            case SUBMODE_MIXED:
                if (isMixed(ch)) {
                    tmp.append((char)MIXED[ch]);
                } else {
                    if (isAlphaUpper(ch)) {
                        submode = SUBMODE_ALPHA;
                        tmp.append((char)28); //al
                        continue;
                    } else if (isAlphaLower(ch)) {
                        submode = SUBMODE_LOWER;
                        tmp.append((char)27); //ll
                        continue;
                    } else {
                        char next = msg.charAt(startpos + idx + 1);
                        if (isPunctuation(next)) {
                            submode = SUBMODE_PUNCTUATION;
                            tmp.append((char)25); //pl
                            continue;
                        } else {
                            tmp.append((char)29); //ps
                            tmp.append((char)PUNCTUATION[ch]);
                            break;
                        }
                    }
                }
                break;
            default: //SUBMODE_PUNCTUATION
                if (isPunctuation(ch)) {
                    tmp.append((char)PUNCTUATION[ch]);
                } else {
                    submode = SUBMODE_ALPHA;
                    tmp.append((char)28); //al
                    continue;
                }
            }
            idx++;
            if (idx >= count) {
                break;
            }
        }
        char h = 0;
        int len = tmp.length();
        for (int i = 0; i < len; i++) {
            boolean odd = (i % 2) != 0;
            if (odd) {
                h = (char)((h * 30) + tmp.charAt(i));
                sb.append(h);
            } else {
                h = tmp.charAt(i);