pdf417条码_pdf417条码编码原理_pdf417条码

I need to generate a PDF417 barcode from some text. I have an API (that I didn't create) that generates a PDF417 barcode given the data, number of rows and number of columns (among other parameters irrelevant to the question).

My PDF417 barcode uses text encoding. This means 1 codeword can hold up to 2 characters. Now, the number of columns HAS to be fixed because I'm printing this barcode in a very constrained space.

The following is what I have inferred from this document (Refer page 38 - Sizing a barcode):

Let number of codewords per row, CWPerRow = 7.

Number of codewords required for some given text, ReqCW = strlen(text) / 2.

Number of rows required = ReqCW / CWPerRow

When I test the above algorithm, nothing displays. When I use the same API when the data is very small and the number of rows = 25, the barcode prints just fine (verified by various barcode scanners).

So, how do I calculate the number of rows required for some given text when the number of columns is known?

You could look at the source-code of some PDF417 implementation, such as .

The text encoding isn't just two characters per code-word. If you use any other character than uppercase letters and space, the encoder will add extra characters to switch character-sets etc. You really have to to see how many code-words it will become.

public class Test
{
    public static void main(String[] args)
    {
        String msg = "Hello, world!";
        int columns = 7;
        int sourceCodeWords = calculateSourceCodeWords(msg);
        int errorCorrectionCodeWords = getErrorCorrectionCodewordCount(0);
        int rows = calculateNumberOfRows(sourceCodeWords, errorCorrectionCodeWords, columns);
        System.out.printf("\"%s\" requires %d code-words, and %d error correction code-words. This becomes %d rows.%n",
                msg, sourceCodeWords, errorCorrectionCodeWords, rows);
    }


    public static int calculateNumberOfRows(int sourceCodeWords, int errorCorrectionCodeWords, int columns) {
        int rows = ((sourceCodeWords + 1 + errorCorrectionCodeWords) / columns) + 1;
        if (columns * rows >= (sourceCodeWords + 1 + errorCorrectionCodeWords + columns)) {
            rows--;
        }
        return rows;
    }

    public static int getErrorCorrectionCodewordCount(int errorCorrectionLevel) {
        if (errorCorrectionLevel < 0 || errorCorrectionLevel > 8) {
            throw new IllegalArgumentException("Error correction level must be between 0 and 8!");
        }
        return 1 << (errorCorrectionLevel + 1);
    }

    private static boolean isAlphaUpper(char ch) {
        return ch == ' ' || (ch >= 'A' && ch <= 'Z');
    }

    private static boolean isAlphaLower(char ch) {
        return ch == ' ' || (ch >= 'a' && ch <= 'z');
    }

    private static boolean isMixed(char ch) {
        return "\t\r #$%&*+,-./0123456789:=^".indexOf(ch) > -1;
    }

    private static boolean isPunctuation(char ch) {
        return "\t\n\r!\"$'()*,-./:;<>?@[\\]_`{|}~".indexOf(ch) > -1;
    }

    private static final int SUBMODE_ALPHA = 0;
    private static final int SUBMODE_LOWER = 1;
    private static final int SUBMODE_MIXED = 2;
    private static final int SUBMODE_PUNCTUATION = 3;

    public static int calculateSourceCodeWords(String msg)
    {
        int len = 0;
        int submode = SUBMODE_ALPHA;
        int msgLength = msg.length();
        for (int idx = 0; idx < msgLength;)
        {
            char ch = msg.charAt(idx);
            switch (submode)
            {
                case SUBMODE_ALPHA:
                    if (isAlphaUpper(ch))
                    {
                        len++;
                    }
                    else
                    {
                        if (isAlphaLower(ch))
                        {
                            submode = SUBMODE_LOWER;
                            len++;
                            continue;
                        }
                        else if (isMixed(ch))
                        {
                            submode = SUBMODE_MIXED;
                            len++;
                            continue;
                        }
                        else
                        {
                            len += 2;
                            break;
                        }
                    }
                    break;
                case SUBMODE_LOWER:
                    if (isAlphaLower(ch))
                    {
                        len++;
                    }
                    else
                    {
                        if (isAlphaUpper(ch))
                        {
                            len += 2;
                            break;
                        }
                        else if (isMixed(ch))
                        {
                            submode = SUBMODE_MIXED;
                            len++;
                            continue;
                        }
                        else
                        {
                            len += 2;
                            break;
                        }
                    }
                    break;
                case SUBMODE_MIXED:
                    if (isMixed(ch))
                    {
                        len++;
                    }
                    else
                    {
                        if (isAlphaUpper(ch))
                        {
                            submode = SUBMODE_ALPHA;
                            len++;
                            continue;
                        }
                        else if (isAlphaLower(ch))
                        {
                            submode = SUBMODE_LOWER;
                            len++;
                            continue;
                        }
                        else
                        {
                            if (idx + 1 < msgLength)
                            {
                                char next = msg.charAt(idx + 1);
                                if (isPunctuation(next))
                                {
                                    submode = SUBMODE_PUNCTUATION;
                                    len++;
                                    continue;
                                }
                            }
                            len += 2;
                        }
                    }
                    break;
                default:
                    if (isPunctuation(ch))
                    {
                        len++;
                    }
                    else
                    {
                        submode = SUBMODE_ALPHA;
                        len++;
                        continue;
                    }
                    break;
            }
            idx++; // Don't increment if 'continue' was used.
        }
        return (len + 1) / 2;
    }
}

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/tongxinshuyu/article-37114-1.html