pdf417lib.java

pdf417二维条码处理。包括显示和识别。

                }
                else if ((v & MIXED) != 0) {
                    dest[ptr++] = ML;
                    dest[ptr++] = v & 0xff;
                    mode = MIXED;
                }
                else if ((getTextTypeAndValue(length, k + 1) & getTextTypeAndValue(length, k + 2) & PUNCTUATION) != 0) {
                    dest[ptr++] = ML;
                    dest[ptr++] = PL;
                    dest[ptr++] = v & 0xff;
                    mode = PUNCTUATION;
                }
                else {
                    dest[ptr++] = PS;
                    dest[ptr++] = v & 0xff;
                }
                break;
            case LOWER:
                if ((v & ALPHA) != 0) {
                    if ((getTextTypeAndValue(length, k + 1) & getTextTypeAndValue(length, k + 2) & ALPHA) != 0) {
                        dest[ptr++] = ML;
                        dest[ptr++] = AL;
                        mode = ALPHA;
                    }
                    else {
                        dest[ptr++] = AS;
                    }
                    dest[ptr++] = v & 0xff;
                }
                else if ((v & MIXED) != 0) {
                    dest[ptr++] = ML;
                    dest[ptr++] = v & 0xff;
                    mode = MIXED;
                }
                else if ((getTextTypeAndValue(length, k + 1) & getTextTypeAndValue(length, k + 2) & PUNCTUATION) != 0) {
                    dest[ptr++] = ML;
                    dest[ptr++] = PL;
                    dest[ptr++] = v & 0xff;
                    mode = PUNCTUATION;
                }
                else {
                    dest[ptr++] = PS;
                    dest[ptr++] = v & 0xff;
                }
                break;
            case MIXED:
                if ((v & LOWER) != 0) {
                    dest[ptr++] = LL;
                    dest[ptr++] = v & 0xff;
                    mode = LOWER;
                }
                else if ((v & ALPHA) != 0) {
                    dest[ptr++] = AL;
                    dest[ptr++] = v & 0xff;
                    mode = ALPHA;
                }
                else if ((getTextTypeAndValue(length, k + 1) & getTextTypeAndValue(length, k + 2) & PUNCTUATION) != 0) {
                    dest[ptr++] = PL;
                    dest[ptr++] = v & 0xff;
                    mode = PUNCTUATION;
                }
                else {
                    dest[ptr++] = PS;
                    dest[ptr++] = v & 0xff;
                }
                break;
            case PUNCTUATION:
                dest[ptr++] = PAL;
                mode = ALPHA;
                --k;
                break;
            }
        }
        if ((ptr & 1) != 0)
            dest[ptr++] = PS;
        size = (ptr + fullBytes) / 2;
        if (size + cwPtr > MAX_DATA_CODEWORDS) {
            throw new IndexOutOfBoundsException("The text is too big.");
        }
        length = ptr;
        ptr = 0;
        while (ptr < length) {
            v = dest[ptr++];
            if (v >= 30) {
                codewords[cwPtr++] = v;
                codewords[cwPtr++] = dest[ptr++];
            }
            else
                codewords[cwPtr++] = v * 30 + dest[ptr++];
        }
    }

    protected void basicNumberCompaction(int start, int length) {
        int ret = cwPtr;
        int retLast = length / 3;
        int ni, k;
        cwPtr += retLast + 1;
        for (k = 0; k <= retLast; ++k)
            codewords[ret + k] = 0;
        codewords[ret + retLast] = 1;
        length += start;
        for (ni = start; ni < length; ++ni) {
            // multiply by 10
            for (k = retLast; k >= 0; --k)
                codewords[ret + k] *= 10;
            // add the digit
            codewords[ret + retLast] += text[ni] - '0';
            // propagate carry
            for (k = retLast; k > 0; --k) {
                codewords[ret + k - 1] += codewords[ret + k] / 900;
                codewords[ret + k] %= 900;
            }
        }
    }

    protected void numberCompaction(int start, int length) {
        int full = (length / 44) * 15;
        int size = length % 44;
        int k;
        if (size == 0)
            size = full;
        else
            size = full + size / 3 + 1;
        if (size + cwPtr > MAX_DATA_CODEWORDS) {
            throw new IndexOutOfBoundsException("The text is too big.");
        }
        length += start;
        for (k = start; k < length; k += 44) {
            size = length - k < 44 ? length - k : 44;
            basicNumberCompaction(k, size);
        }
    }

    protected void byteCompaction6(int start) {
        int length = 6;
        int ret = cwPtr;
        int retLast = 4;
        int ni, k;
        cwPtr += retLast + 1;
        for (k = 0; k <= retLast ; ++k)
            codewords[ret + k] = 0;
        length += start;
        for (ni = start; ni < length; ++ni) {
            // multiply by 256
            for (k = retLast; k >= 0; --k)
                codewords[ret + k] *= 256;
            // add the digit
            codewords[ret + retLast] += (int)text[ni] & 0xff;
            // propagate carry
            for (k = retLast; k > 0; --k) {
                codewords[ret + k - 1] += codewords[ret + k] / 900;
                codewords[ret + k] %= 900;
            }
        }
    }

    void byteCompaction(int start, int length) {
        int k, j;
        int size = (length / 6) * 5 + (length % 6);
        if (size + cwPtr > MAX_DATA_CODEWORDS) {
            throw new IndexOutOfBoundsException("The text is too big.");
        }
        length += start;
        for (k = start; k < length; k += 6) {
            size = length - k < 44 ? length - k : 6;
            if (size < 6) {
                for (j = 0; j < size; ++j)
                    codewords[cwPtr++] = (int)text[k + j] & 0xff;
            }
            else {
                byteCompaction6(k);
            }
        }
    }

    void breakString() {
        int textLength = text.length;
        int lastP = 0;
        int startN = 0;
        int nd = 0;
        char c = 0;
        int k, ptrS, j;
        boolean lastTxt, txt;
        Segment v;
        Segment vp;
        Segment vn;
        for (k = 0; k < textLength; ++k) {
            c = (char)(text[k] & 0xff);
            if (c >= '0' && c <= '9') {
                if (nd == 0)
                    startN = k;
                ++nd;
                continue;
            }
            if (nd >= 13) {
                if (lastP != startN) {
                    c = (char)(text[lastP] & 0xff);
                    ptrS = lastP;
                    lastTxt = (c >= ' ' && c < 127) || c == '\r' || c == '\n' || c == '\t';
                    for (j = lastP; j < startN; ++j) {
                        c = (char)(text[j] & 0xff);
                        txt = (c >= ' ' && c < 127) || c == '\r' || c == '\n' || c == '\t';
                        if (txt != lastTxt) {
                            segmentList.add(lastTxt ? 'T' : 'B', lastP, j);
                            lastP = j;
                            lastTxt = txt;
                        }
                    }
                    segmentList.add(lastTxt ? 'T' : 'B', lastP, startN);
                }
                segmentList.add('N', startN, k);
                lastP = k;
            }
            nd = 0;
        }
        if (nd < 13)
            startN = textLength;
        if (lastP != startN) {
            c = (char)(text[lastP] & 0xff);
            ptrS = lastP;
            lastTxt = (c >= ' ' && c < 127) || c == '\r' || c == '\n' || c == '\t';
            for (j = lastP; j < startN; ++j) {
                c = (char)(text[j] & 0xff);
                txt = (c >= ' ' && c < 127) || c == '\r' || c == '\n' || c == '\t';
                if (txt != lastTxt) {
                    segmentList.add(lastTxt ? 'T' : 'B', lastP, j);
                    lastP = j;
                    lastTxt = txt;
                }
            }
            segmentList.add(lastTxt ? 'T' : 'B', lastP, startN);
        }
        if (nd >= 13)
            segmentList.add('N', startN, textLength);
        //optimize
        //merge short binary
        for (k = 0; k < segmentList.size(); ++k) {
            v = segmentList.get(k);
            vp = segmentList.get(k - 1);
            vn = segmentList.get(k + 1);;
            if (checkSegmentType(v, 'B') && getSegmentLength(v) == 1) {
                if (checkSegmentType(vp, 'T') && checkSegmentType(vn, 'T') 
                    && getSegmentLength(vp) + getSegmentLength(vn) >= 3) {
                    vp.end = vn.end;
                    segmentList.remove(k);
                    segmentList.remove(k);
                    k = -1;
                    continue;
                }
            }
        }
        //merge text sections
        for (k = 0; k < segmentList.size(); ++k) {
            v = segmentList.get(k);
            vp = segmentList.get(k - 1);
            vn = segmentList.get(k + 1);;
            if (checkSegmentType(v, 'T') && getSegmentLength(v) >= 5) {
                boolean redo = false;
                if ((checkSegmentType(vp, 'B') && getSegmentLength(vp) == 1) || checkSegmentType(vp, 'T')) {
                    redo = true;
                    v.start = vp.start;
                    segmentList.remove(k - 1);
                    --k;
                }
                if ((checkSegmentType(vn, 'B') && getSegmentLength(vn) == 1) || checkSegmentType(vn, 'T')) {
                    redo = true;
                    v.end = vn.end;
                    segmentList.remove(k + 1);
                }
                if (redo) {
                    k = -1;