DefaultGridSampler ported

src/common/DefaultGridSampler.java

@@ -1,88 +0,0 @@
-/*
- * Copyright 2007 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.common;
-
-import com.google.zxing.NotFoundException;
-
-/**
- * @author Sean Owen
- */
-public final class DefaultGridSampler extends GridSampler {
-
-  @Override
-  public BitMatrix sampleGrid(BitMatrix image,
-                              int dimensionX,
-                              int dimensionY,
-                              float p1ToX, float p1ToY,
-                              float p2ToX, float p2ToY,
-                              float p3ToX, float p3ToY,
-                              float p4ToX, float p4ToY,
-                              float p1FromX, float p1FromY,
-                              float p2FromX, float p2FromY,
-                              float p3FromX, float p3FromY,
-                              float p4FromX, float p4FromY) throws NotFoundException {
-
-    PerspectiveTransform transform = PerspectiveTransform.quadrilateralToQuadrilateral(
-        p1ToX, p1ToY, p2ToX, p2ToY, p3ToX, p3ToY, p4ToX, p4ToY,
-        p1FromX, p1FromY, p2FromX, p2FromY, p3FromX, p3FromY, p4FromX, p4FromY);
-
-    return sampleGrid(image, dimensionX, dimensionY, transform);
-  }
-
-  @Override
-  public BitMatrix sampleGrid(BitMatrix image,
-                              int dimensionX,
-                              int dimensionY,
-                              PerspectiveTransform transform) throws NotFoundException {
-    if (dimensionX <= 0 || dimensionY <= 0) {
-      throw NotFoundException.getNotFoundInstance();
-    }
-    BitMatrix bits = new BitMatrix(dimensionX, dimensionY);
-    float[] points = new float[2 * dimensionX];
-    for (int y = 0; y < dimensionY; y++) {
-      int max = points.length;
-      float iValue = y + 0.5f;
-      for (int x = 0; x < max; x += 2) {
-        points[x] = (float) (x / 2) + 0.5f;
-        points[x + 1] = iValue;
-      }
-      transform.transformPoints(points);
-      // Quick check to see if points transformed to something inside the image;
-      // sufficient to check the endpoints
-      checkAndNudgePoints(image, points);
-      try {
-        for (int x = 0; x < max; x += 2) {
-          if (image.get((int) points[x], (int) points[x + 1])) {
-            // Black(-ish) pixel
-            bits.set(x / 2, y);
-          }
-        }
-      } catch (ArrayIndexOutOfBoundsException aioobe) {
-        // This feels wrong, but, sometimes if the finder patterns are misidentified, the resulting
-        // transform gets "twisted" such that it maps a straight line of points to a set of points
-        // whose endpoints are in bounds, but others are not. There is probably some mathematical
-        // way to detect this about the transformation that I don't know yet.
-        // This results in an ugly runtime exception despite our clever checks above -- can't have
-        // that. We could check each point's coordinates but that feels duplicative. We settle for
-        // catching and wrapping ArrayIndexOutOfBoundsException.
-        throw NotFoundException.getNotFoundInstance();
-      }
-    }
-    return bits;
-  }
-
-}

src/common/mod.rs

@@ -2068,7 +2068,6 @@ impl BitSourceBuilder {
     }
 }
 
-
 /*
  * Copyright 2007 ZXing authors
  *
@@ -2104,25 +2103,25 @@ impl BitSourceBuilder {
  */
 
 pub trait GridSampler {
-//   /**
+    //   /**
-//    * Sets the implementation of GridSampler used by the library. One global
+    //    * Sets the implementation of GridSampler used by the library. One global
-//    * instance is stored, which may sound problematic. But, the implementation provided
+    //    * instance is stored, which may sound problematic. But, the implementation provided
-//    * ought to be appropriate for the entire platform, and all uses of this library
+    //    * ought to be appropriate for the entire platform, and all uses of this library
-//    * in the whole lifetime of the JVM. For instance, an Android activity can swap in
+    //    * in the whole lifetime of the JVM. For instance, an Android activity can swap in
-//    * an implementation that takes advantage of native platform libraries.
+    //    * an implementation that takes advantage of native platform libraries.
-//    *
+    //    *
-//    * @param newGridSampler The platform-specific object to install.
+    //    * @param newGridSampler The platform-specific object to install.
-//    */
+    //    */
-//   public static void setGridSampler(GridSampler newGridSampler) {
+    //   public static void setGridSampler(GridSampler newGridSampler) {
-//     gridSampler = newGridSampler;
+    //     gridSampler = newGridSampler;
-//   }
+    //   }
 
-//   /**
+    //   /**
-//    * @return the current implementation of GridSampler
+    //    * @return the current implementation of GridSampler
-//    */
+    //    */
-//   public static GridSampler getInstance() {
+    //   public static GridSampler getInstance() {
-//     return gridSampler;
+    //     return gridSampler;
-//   }
+    //   }
 
     /**
      * Samples an image for a rectangular matrix of bits of the given dimension. The sampling
@@ -2153,22 +2152,36 @@ pub trait GridSampler {
      * @throws NotFoundException if image can't be sampled, for example, if the transformation defined
      *   by the given points is invalid or results in sampling outside the image boundaries
      */
-  fn  sample_grid_detailed(&self,  image:&BitMatrix,
+    fn sample_grid_detailed(
-                                        dimensionX:u32,
+        &self,
-                                        dimensionY:u32,
+        image: &BitMatrix,
-                                        p1ToX:f32,  p1ToY:f32,
+        dimensionX: u32,
-                                        p2ToX:f32,  p2ToY:f32,
+        dimensionY: u32,
-                                        p3ToX:f32,  p3ToY:f32,
+        p1ToX: f32,
-                                        p4ToX:f32,  p4ToY:f32,
+        p1ToY: f32,
-                                        p1FromX:f32,  p1FromY:f32,
+        p2ToX: f32,
-                                        p2FromX:f32,  p2FromY:f32,
+        p2ToY: f32,
-                                        p3FromX:f32,  p3FromY:f32,
+        p3ToX: f32,
-                                        p4FromX:f32,  p4FromY:f32) -> Result<BitMatrix,Exceptions>;
+        p3ToY: f32,
+        p4ToX: f32,
+        p4ToY: f32,
+        p1FromX: f32,
+        p1FromY: f32,
+        p2FromX: f32,
+        p2FromY: f32,
+        p3FromX: f32,
+        p3FromY: f32,
+        p4FromX: f32,
+        p4FromY: f32,
+    ) -> Result<BitMatrix, Exceptions>;
 
-  fn  sample_grid(&self,  image:&BitMatrix,
+    fn sample_grid(
-                                        dimensionX:u32,
+        &self,
-                                        dimensionY:u32,
+        image: &BitMatrix,
-                                        transform:&PerspectiveTransform) -> Result<BitMatrix ,Exceptions>;
+        dimensionX: u32,
+        dimensionY: u32,
+        transform: &PerspectiveTransform,
+    ) -> Result<BitMatrix, Exceptions>;
 
     /**
      * <p>Checks a set of points that have been transformed to sample points on an image against
@@ -2185,8 +2198,7 @@ pub trait GridSampler {
      * @param points actual points in x1,y1,...,xn,yn form
      * @throws NotFoundException if an endpoint is lies outside the image boundaries
      */
-  fn checkAndNudgePoints(&self,  image:&BitMatrix,
+    fn checkAndNudgePoints(&self, image: &BitMatrix, points: &mut [f32]) -> Result<(), Exceptions> {
-                                             points:&mut [f32]) -> Result<(),Exceptions> {
         let width = image.getWidth();
         let height = image.getHeight();
         // Check and nudge points from start until we see some that are OK:
@@ -2198,7 +2210,9 @@ pub trait GridSampler {
             let x = points[offset] as i32;
             let y = points[offset + 1] as i32;
             if x < -1 || x > width.try_into().unwrap() || y < -1 || y > height.try_into().unwrap() {
-        return Err(Exceptions::NotFoundException("getNotFoundInstance".to_owned()));
+                return Err(Exceptions::NotFoundException(
+                    "getNotFoundInstance".to_owned(),
+                ));
             }
             nudged = false;
             if x == -1 {
@@ -2215,17 +2229,19 @@ pub trait GridSampler {
                 points[offset + 1] = height as f32 - 1f32;
                 nudged = true;
             }
-      offset+=2;
+            offset += 2;
         }
         // Check and nudge points from end:
         nudged = true;
-    let mut offset = points.len()-2;
+        let mut offset = points.len() - 2;
         while offset >= 0 && nudged {
             // for (int offset = points.length - 2; offset >= 0 && nudged; offset -= 2) {
             let x = points[offset] as i32;
             let y = points[offset + 1] as i32;
             if x < -1 || x > width.try_into().unwrap() || y < -1 || y > height.try_into().unwrap() {
-        return Err(Exceptions::NotFoundException("getNotFoundInstance".to_owned()));
+                return Err(Exceptions::NotFoundException(
+                    "getNotFoundInstance".to_owned(),
+                ));
             }
             nudged = false;
             if x == -1 {
@@ -2242,9 +2258,118 @@ pub trait GridSampler {
                 points[offset + 1] = height as f32 - 1f32;
                 nudged = true;
             }
-      offset+=2;
+            offset += 2;
         }
         Ok(())
     }
-
+}
+
+/*
+ * Copyright 2007 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.common;
+
+// import com.google.zxing.NotFoundException;
+
+/**
+ * @author Sean Owen
+ */
+pub struct DefaultGridSampler {}
+
+impl GridSampler for DefaultGridSampler {
+    fn sample_grid_detailed(
+        &self,
+        image: &BitMatrix,
+        dimensionX: u32,
+        dimensionY: u32,
+        p1ToX: f32,
+        p1ToY: f32,
+        p2ToX: f32,
+        p2ToY: f32,
+        p3ToX: f32,
+        p3ToY: f32,
+        p4ToX: f32,
+        p4ToY: f32,
+        p1FromX: f32,
+        p1FromY: f32,
+        p2FromX: f32,
+        p2FromY: f32,
+        p3FromX: f32,
+        p3FromY: f32,
+        p4FromX: f32,
+        p4FromY: f32,
+    ) -> Result<BitMatrix, Exceptions> {
+        let transform = PerspectiveTransform::quadrilateralToQuadrilateral(
+            p1ToX, p1ToY, p2ToX, p2ToY, p3ToX, p3ToY, p4ToX, p4ToY, p1FromX, p1FromY, p2FromX,
+            p2FromY, p3FromX, p3FromY, p4FromX, p4FromY,
+        );
+
+        self.sample_grid(image, dimensionX, dimensionY, &transform)
+    }
+
+    fn sample_grid(
+        &self,
+        image: &BitMatrix,
+        dimensionX: u32,
+        dimensionY: u32,
+        transform: &PerspectiveTransform,
+    ) -> Result<BitMatrix, Exceptions> {
+        if dimensionX <= 0 || dimensionY <= 0 {
+            return Err(Exceptions::NotFoundException(
+                "getNotFoundInstance".to_owned(),
+            ));
+        }
+        let mut bits = BitMatrix::new(dimensionX, dimensionY)?;
+        let mut points = vec![0_f32; 2 * dimensionX as usize];
+        for y in 0..dimensionY {
+            //   for (int y = 0; y < dimensionY; y++) {
+            let max = points.len();
+            let iValue = y as f32 + 0.5f32;
+            let mut x = 0;
+            while x < max {
+                // for (int x = 0; x < max; x += 2) {
+                points[x] = (x as f32 / 2.0) + 0.5f32;
+                points[x + 1] = iValue;
+                x += 2;
+            }
+            transform.transform_points_single(&mut points);
+            // Quick check to see if points transformed to something inside the image;
+            // sufficient to check the endpoints
+            self.checkAndNudgePoints(image, &mut points);
+            // try {
+            let mut x = 0;
+            while x < max {
+                //   for (int x = 0; x < max; x += 2) {
+                if image.get(points[x] as u32, points[x + 1] as u32) {
+                    // Black(-ish) pixel
+                    bits.set(x as u32 / 2, y);
+                    x += 2;
+                }
+            }
+            // } catch (ArrayIndexOutOfBoundsException aioobe) {
+            //   // This feels wrong, but, sometimes if the finder patterns are misidentified, the resulting
+            //   // transform gets "twisted" such that it maps a straight line of points to a set of points
+            //   // whose endpoints are in bounds, but others are not. There is probably some mathematical
+            //   // way to detect this about the transformation that I don't know yet.
+            //   // This results in an ugly runtime exception despite our clever checks above -- can't have
+            //   // that. We could check each point's coordinates but that feels duplicative. We settle for
+            //   // catching and wrapping ArrayIndexOutOfBoundsException.
+            //   throw NotFoundException.getNotFoundInstance();
+            // }
+        }
+        return Ok(bits);
+    }
 }