rhodes 2.4.1 → 3.0.0.beta.1

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/oned/rss/expanded/decoders/GeneralAppIdDecoder.java

@@ -0,0 +1,414 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * 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.
+ */
+
+/*
+ * These authors would like to acknowledge the Spanish Ministry of Industry,
+ * Tourism and Trade, for the support in the project TSI020301-2008-2
+ * "PIRAmIDE: Personalizable Interactions with Resources on AmI-enabled
+ * Mobile Dynamic Environments", led by Treelogic
+ * ( http://www.treelogic.com/ ):
+ *
+ *   http://www.piramidepse.com/
+ */
+
+package com.google.zxing.oned.rss.expanded.decoders;
+
+import com.google.zxing.NotFoundException;
+import com.google.zxing.common.BitArray;
+
+/**
+ * @author Pablo Orduña, University of Deusto (pablo.orduna@deusto.es)
+ * @author Eduardo Castillejo, University of Deusto (eduardo.castillejo@deusto.es)
+ */
+final class GeneralAppIdDecoder {
+
+  private final BitArray information;
+  private final CurrentParsingState current = new CurrentParsingState();
+  private final StringBuffer buffer = new StringBuffer();
+
+  GeneralAppIdDecoder(BitArray information){
+    this.information = information;
+  }
+
+  String decodeAllCodes(StringBuffer buff, int initialPosition) throws NotFoundException {
+    int currentPosition = initialPosition;
+    String remaining = null;
+    do{
+      DecodedInformation info = this.decodeGeneralPurposeField(currentPosition, remaining);
+      String parsedFields = FieldParser.parseFieldsInGeneralPurpose(info.getNewString());
+      buff.append(parsedFields);
+      if(info.isRemaining()) {
+        remaining = String.valueOf(info.getRemainingValue());
+      } else {
+        remaining = null;
+      }
+
+      if(currentPosition == info.getNewPosition()) {// No step forward!
+        break;
+      }
+      currentPosition = info.getNewPosition();
+    }while(true);
+
+    return buff.toString();
+  }
+
+  private boolean isStillNumeric(int pos) {
+    // It's numeric if it still has 7 positions
+    // and one of the first 4 bits is "1".
+    if(pos + 7 > this.information.size){
+      return pos + 4 <= this.information.size;
+    }
+
+    for(int i = pos; i < pos + 3; ++i) {
+      if (this.information.get(i)) {
+        return true;
+      }
+    }
+
+    return this.information.get(pos + 3);
+  }
+
+  private DecodedNumeric decodeNumeric(int pos) {
+    if(pos + 7 > this.information.size){
+      int numeric = extractNumericValueFromBitArray(pos, 4);
+      if(numeric == 0) {
+        return new DecodedNumeric(this.information.size, DecodedNumeric.FNC1, DecodedNumeric.FNC1);
+      }
+      return new DecodedNumeric(this.information.size, numeric - 1, DecodedNumeric.FNC1);
+    }
+    int numeric = extractNumericValueFromBitArray(pos, 7);
+
+    int digit1  = (numeric - 8) / 11;
+    int digit2  = (numeric - 8) % 11;
+
+    return new DecodedNumeric(pos + 7, digit1, digit2);
+  }
+
+  int extractNumericValueFromBitArray(int pos, int bits){
+    return extractNumericValueFromBitArray(this.information, pos, bits);
+  }
+
+  static int extractNumericValueFromBitArray(BitArray information, int pos, int bits) {
+    if(bits > 32) {
+      throw new IllegalArgumentException("extractNumberValueFromBitArray can't handle more than 32 bits");
+    }
+
+    int value = 0;
+    for(int i = 0; i < bits; ++i) {
+      if (information.get(pos + i)) {
+        value |= (1 << (bits - i - 1));
+      }
+    }
+
+    return value;
+  }
+
+  DecodedInformation decodeGeneralPurposeField(int pos, String remaining) {
+    this.buffer.setLength(0);
+
+    if(remaining != null) {
+      this.buffer.append(remaining);
+    }
+
+    this.current.position = pos;
+
+    DecodedInformation lastDecoded = parseBlocks();
+    if(lastDecoded != null && lastDecoded.isRemaining()) {
+      return new DecodedInformation(this.current.position, this.buffer.toString(), lastDecoded.getRemainingValue());
+    }
+    return new DecodedInformation(this.current.position, this.buffer.toString());
+  }
+
+  private DecodedInformation parseBlocks() {
+    boolean isFinished;
+    BlockParsedResult result;
+    do{
+      int initialPosition = current.position;
+
+      if (current.isAlpha()){
+        result = parseAlphaBlock();
+        isFinished = result.isFinished();
+      }else if (current.isIsoIec646()){
+        result = parseIsoIec646Block();
+        isFinished = result.isFinished();
+      }else{ // it must be numeric
+        result = parseNumericBlock();
+        isFinished = result.isFinished();
+      }
+
+      boolean positionChanged = initialPosition != current.position;
+      if(!positionChanged && !isFinished) {
+        break;
+      }
+    } while (!isFinished);
+
+    return result.getDecodedInformation();
+  }
+
+  private BlockParsedResult parseNumericBlock() {
+    while(isStillNumeric(current.position)){
+      DecodedNumeric numeric = decodeNumeric(current.position);
+      current.position = numeric.getNewPosition();
+
+      if(numeric.isFirstDigitFNC1()){
+        DecodedInformation information;
+        if (numeric.isSecondDigitFNC1()) {
+          information = new DecodedInformation(current.position, buffer.toString());
+        } else {
+          information = new DecodedInformation(current.position, buffer.toString(), numeric.getSecondDigit());
+        }
+        return new BlockParsedResult(information, true);
+      }
+      buffer.append(numeric.getFirstDigit());
+
+      if(numeric.isSecondDigitFNC1()){
+        DecodedInformation information = new DecodedInformation(current.position, buffer.toString());
+        return new BlockParsedResult(information, true);
+      }
+      buffer.append(numeric.getSecondDigit());
+    }
+
+    if(isNumericToAlphaNumericLatch(current.position)){
+      current.setAlpha();
+      current.position += 4;
+    }
+    return new BlockParsedResult(false);
+  }
+
+  private BlockParsedResult parseIsoIec646Block() {
+    while (isStillIsoIec646(current.position)) {
+      DecodedChar iso = decodeIsoIec646(current.position);
+      current.position = iso.getNewPosition();
+
+      if (iso.isFNC1()) {
+        DecodedInformation information = new DecodedInformation(current.position, buffer.toString());
+        return new BlockParsedResult(information, true);
+      }
+      buffer.append(iso.getValue());
+    }
+
+    if (isAlphaOr646ToNumericLatch(current.position)) {
+      current.position  += 3;
+      current.setNumeric();
+    } else if (isAlphaTo646ToAlphaLatch(current.position)) {
+      if (current.position + 5 < this.information.size) {
+        current.position += 5;
+      } else {
+        current.position = this.information.size;
+      }
+
+      current.setAlpha();
+    }
+    return new BlockParsedResult(false);
+  }
+
+  private BlockParsedResult parseAlphaBlock() {
+    while (isStillAlpha(current.position)) {
+      DecodedChar alpha = decodeAlphanumeric(current.position);
+      current.position = alpha.getNewPosition();
+
+      if(alpha.isFNC1()) {
+        DecodedInformation information = new DecodedInformation(current.position, buffer.toString());
+        return new BlockParsedResult(information, true); //end of the char block
+      }
+
+      buffer.append(alpha.getValue());
+    }
+
+    if (isAlphaOr646ToNumericLatch(current.position)) {
+      current.position += 3;
+      current.setNumeric();
+    } else if (isAlphaTo646ToAlphaLatch(current.position)) {
+      if (current.position + 5 < this.information.size) {
+        current.position += 5;
+      } else {
+        current.position = this.information.size;
+      }
+
+      current.setIsoIec646();
+    }
+    return new BlockParsedResult(false);
+  }
+
+  private boolean isStillIsoIec646(int pos) {
+    if(pos + 5 > this.information.size) {
+      return false;
+    }
+
+    int fiveBitValue = extractNumericValueFromBitArray(pos, 5);
+    if(fiveBitValue >= 5 && fiveBitValue < 16) {
+      return true;
+    }
+
+    if(pos + 7 > this.information.size) {
+      return false;
+    }
+
+    int sevenBitValue = extractNumericValueFromBitArray(pos, 7);
+    if(sevenBitValue >= 64 && sevenBitValue < 116) {
+      return true;
+    }
+
+    if(pos + 8 > this.information.size) {
+      return false;
+    }
+
+    int eightBitValue = extractNumericValueFromBitArray(pos, 8);
+    return eightBitValue >= 232 && eightBitValue < 253;
+
+  }
+
+  private DecodedChar decodeIsoIec646(int pos) {
+    int fiveBitValue = extractNumericValueFromBitArray(pos, 5);
+    if(fiveBitValue == 15) {
+      return new DecodedChar(pos + 5, DecodedChar.FNC1);
+    }
+
+    if(fiveBitValue >= 5 && fiveBitValue < 15) {
+      return new DecodedChar(pos + 5, (char) ('0' + fiveBitValue - 5));
+    }
+
+    int sevenBitValue = extractNumericValueFromBitArray(pos, 7);
+
+    if(sevenBitValue >= 64 && sevenBitValue < 90) {
+      return new DecodedChar(pos + 7, (char) (sevenBitValue + 1));
+    }
+
+    if(sevenBitValue >= 90 && sevenBitValue < 116) {
+      return new DecodedChar(pos + 7, (char) (sevenBitValue + 7));
+    }
+
+    int eightBitValue = extractNumericValueFromBitArray(pos, 8);
+    switch (eightBitValue){
+      case 232: return new DecodedChar(pos + 8, '!');
+      case 233: return new DecodedChar(pos + 8, '"');
+      case 234: return new DecodedChar(pos + 8, '%');
+      case 235: return new DecodedChar(pos + 8, '&');
+      case 236: return new DecodedChar(pos + 8, '\'');
+      case 237: return new DecodedChar(pos + 8, '(');
+      case 238: return new DecodedChar(pos + 8, ')');
+      case 239: return new DecodedChar(pos + 8, '*');
+      case 240: return new DecodedChar(pos + 8, '+');
+      case 241: return new DecodedChar(pos + 8, ',');
+      case 242: return new DecodedChar(pos + 8, '-');
+      case 243: return new DecodedChar(pos + 8, '.');
+      case 244: return new DecodedChar(pos + 8, '/');
+      case 245: return new DecodedChar(pos + 8, ':');
+      case 246: return new DecodedChar(pos + 8, ';');
+      case 247: return new DecodedChar(pos + 8, '<');
+      case 248: return new DecodedChar(pos + 8, '=');
+      case 249: return new DecodedChar(pos + 8, '>');
+      case 250: return new DecodedChar(pos + 8, '?');
+      case 251: return new DecodedChar(pos + 8, '_');
+      case 252: return new DecodedChar(pos + 8, ' ');
+    }
+
+    throw new RuntimeException("Decoding invalid ISO/IEC 646 value: " + eightBitValue);
+  }
+
+  private boolean isStillAlpha(int pos) {
+    if(pos + 5 > this.information.size) {
+      return false;
+    }
+
+    // We now check if it's a valid 5-bit value (0..9 and FNC1)
+    int fiveBitValue = extractNumericValueFromBitArray(pos, 5);
+    if(fiveBitValue >= 5 && fiveBitValue < 16) {
+      return true;
+    }
+
+    if(pos + 6 > this.information.size) {
+      return false;
+    }
+
+    int sixBitValue =  extractNumericValueFromBitArray(pos, 6);
+    return sixBitValue >= 16 && sixBitValue < 63; // 63 not included
+  }
+
+  private DecodedChar decodeAlphanumeric(int pos) {
+    int fiveBitValue = extractNumericValueFromBitArray(pos, 5);
+    if(fiveBitValue == 15) {
+      return new DecodedChar(pos + 5, DecodedChar.FNC1);
+    }
+
+    if(fiveBitValue >= 5 && fiveBitValue < 15) {
+      return new DecodedChar(pos + 5, (char) ('0' + fiveBitValue - 5));
+    }
+
+    int sixBitValue =  extractNumericValueFromBitArray(pos, 6);
+
+    if(sixBitValue >= 32 && sixBitValue < 58) {
+      return new DecodedChar(pos + 6, (char) (sixBitValue + 33));
+    }
+
+    switch(sixBitValue){
+      case 58: return new DecodedChar(pos + 6, '*');
+      case 59: return new DecodedChar(pos + 6, ',');
+      case 60: return new DecodedChar(pos + 6, '-');
+      case 61: return new DecodedChar(pos + 6, '.');
+      case 62: return new DecodedChar(pos + 6, '/');
+    }
+
+    throw new RuntimeException("Decoding invalid alphanumeric value: " + sixBitValue);
+  }
+
+  private boolean isAlphaTo646ToAlphaLatch(int pos) {
+    if(pos + 1 > this.information.size) {
+      return false;
+    }
+
+    for(int i = 0; i < 5 && i + pos < this.information.size; ++i){
+      if(i == 2){
+        if(!this.information.get(pos + 2)) {
+          return false;
+        }
+      } else if(this.information.get(pos + i)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  private boolean isAlphaOr646ToNumericLatch(int pos) {
+    // Next is alphanumeric if there are 3 positions and they are all zeros
+    if (pos + 3 > this.information.size) {
+      return false;
+    }
+
+    for (int i = pos; i < pos + 3; ++i) {
+      if (this.information.get(i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private boolean isNumericToAlphaNumericLatch(int pos) {
+    // Next is alphanumeric if there are 4 positions and they are all zeros, or
+    // if there is a subset of this just before the end of the symbol
+    if (pos + 1 > this.information.size) {
+      return false;
+    }
+
+    for (int i = 0; i < 4 && i + pos < this.information.size; ++i) {
+      if (this.information.get(pos + i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/pdf417/PDF417Reader.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * 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.
+ */
+
+package com.google.zxing.pdf417;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.BinaryBitmap;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.FormatException;
+import com.google.zxing.NotFoundException;
+import com.google.zxing.Reader;
+import com.google.zxing.Result;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.common.DecoderResult;
+import com.google.zxing.common.DetectorResult;
+import com.google.zxing.pdf417.decoder.Decoder;
+import com.google.zxing.pdf417.detector.Detector;
+import com.google.zxing.qrcode.QRCodeReader;
+
+import java.util.Hashtable;
+
+/**
+ * This implementation can detect and decode PDF417 codes in an image.
+ *
+ * @author SITA Lab (kevin.osullivan@sita.aero)
+ */
+public final class PDF417Reader implements Reader {
+
+  private static final ResultPoint[] NO_POINTS = new ResultPoint[0];
+
+  private final Decoder decoder = new Decoder();
+
+  /**
+   * Locates and decodes a PDF417 code in an image.
+   *
+   * @return a String representing the content encoded by the PDF417 code
+   * @throws NotFoundException if a PDF417 code cannot be found,
+   * @throws FormatException if a PDF417 cannot be decoded
+   */
+  public Result decode(BinaryBitmap image) throws NotFoundException, FormatException {
+    return decode(image, null);
+  }
+
+  public Result decode(BinaryBitmap image, Hashtable hints)
+      throws NotFoundException, FormatException {
+    DecoderResult decoderResult;
+    ResultPoint[] points;
+    if (hints != null && hints.containsKey(DecodeHintType.PURE_BARCODE)) {
+      BitMatrix bits = QRCodeReader.extractPureBits(image.getBlackMatrix());
+      decoderResult = decoder.decode(bits);
+      points = NO_POINTS;
+    } else {
+      DetectorResult detectorResult = new Detector(image).detect();
+      decoderResult = decoder.decode(detectorResult.getBits());
+      points = detectorResult.getPoints();
+    }
+    return new Result(decoderResult.getText(), decoderResult.getRawBytes(), points,
+        BarcodeFormat.PDF417);
+  }
+
+  public void reset() {
+    // do nothing
+  }
+
+}