checkin for entire port source tree

port_src/output/zxing/maxicode/maxi_code_reader.rs

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2011 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::maxicode;
+
+/**
+ * This implementation can detect and decode a MaxiCode in an image.
+ */
+
+ const NO_POINTS: [Option<ResultPoint>; 0] = [None; 0];
+
+ const MATRIX_WIDTH: i32 = 30;
+
+ const MATRIX_HEIGHT: i32 = 33;
+#[derive(Reader)]
+pub struct MaxiCodeReader {
+
+     let decoder: Decoder = Decoder::new();
+}
+
+impl MaxiCodeReader {
+
+    /**
+   * Locates and decodes a MaxiCode in an image.
+   *
+   * @return a String representing the content encoded by the MaxiCode
+   * @throws NotFoundException if a MaxiCode cannot be found
+   * @throws FormatException if a MaxiCode cannot be decoded
+   * @throws ChecksumException if error correction fails
+   */
+    pub fn  decode(&self,  image: &BinaryBitmap) -> /*  throws NotFoundException, ChecksumException, FormatException */Result<Result, Rc<Exception>>   {
+        return Ok(self.decode(image, null));
+    }
+
+    pub fn  decode(&self,  image: &BinaryBitmap,  hints: &Map<DecodeHintType, ?>) -> /*  throws NotFoundException, ChecksumException, FormatException */Result<Result, Rc<Exception>>   {
+        // Note that MaxiCode reader effectively always assumes PURE_BARCODE mode
+        // and can't detect it in an image
+         let bits: BitMatrix = ::extract_pure_bits(&image.get_black_matrix());
+         let decoder_result: DecoderResult = self.decoder.decode(bits, &hints);
+         let result: Result = Result::new(&decoder_result.get_text(), &decoder_result.get_raw_bytes(), NO_POINTS, BarcodeFormat::MAXICODE);
+         let ec_level: String = decoder_result.get_e_c_level();
+        if ec_level != null {
+            result.put_metadata(ResultMetadataType::ERROR_CORRECTION_LEVEL, &ec_level);
+        }
+        return Ok(result);
+    }
+
+    pub fn  reset(&self)   {
+    // do nothing
+    }
+
+    /**
+   * This method detects a code in a "pure" image -- that is, pure monochrome image
+   * which contains only an unrotated, unskewed, image of a code, with some white border
+   * around it. This is a specialized method that works exceptionally fast in this special
+   * case.
+   */
+    fn  extract_pure_bits( image: &BitMatrix) -> /*  throws NotFoundException */Result<BitMatrix, Rc<Exception>>   {
+         let enclosing_rectangle: Vec<i32> = image.get_enclosing_rectangle();
+        if enclosing_rectangle == null {
+            throw NotFoundException::get_not_found_instance();
+        }
+         let left: i32 = enclosing_rectangle[0];
+         let top: i32 = enclosing_rectangle[1];
+         let width: i32 = enclosing_rectangle[2];
+         let height: i32 = enclosing_rectangle[3];
+        // Now just read off the bits
+         let bits: BitMatrix = BitMatrix::new(MATRIX_WIDTH, MATRIX_HEIGHT);
+         {
+             let mut y: i32 = 0;
+            while y < MATRIX_HEIGHT {
+                {
+                     let iy: i32 = Math::min(top + (y * height + height / 2) / MATRIX_HEIGHT, height - 1);
+                     {
+                         let mut x: i32 = 0;
+                        while x < MATRIX_WIDTH {
+                            {
+                                // srowen: I don't quite understand why the formula below is necessary, but it
+                                // can walk off the image if left + width = the right boundary. So cap it.
+                                 let ix: i32 = left + Math::min((x * width + width / 2 + (y & 0x01) * width / 2) / MATRIX_WIDTH, width - 1);
+                                if image.get(ix, iy) {
+                                    bits.set(x, y);
+                                }
+                            }
+                            x += 1;
+                         }
+                     }
+
+                }
+                y += 1;
+             }
+         }
+
+        return Ok(bits);
+    }
+}
+