perf: removed many 1d stack allocations

Author: hschimke

src/oned/code_128_reader.rs

@@ -363,15 +363,15 @@ impl Code128Reader {
         let mut counters = [0_u32; 6];
         let mut patternStart = rowOffset;
         let mut isWhite = false;
-        let patternLength = counters.len();
+        let patternLength = 6;
 
         for i in rowOffset..width {
             if row.get(i) != isWhite {
                 counters[counterPosition] += 1;
             } else {
                 if counterPosition == patternLength - 1 {
                     let mut bestVariance = MAX_AVG_VARIANCE;
-                    let mut bestMatch = -1_isize;
+                    let mut bestMatch = -1_i32;
                     for startCode in CODE_START_A..=CODE_START_C {
                         let variance = one_d_reader::pattern_match_variance(
                             &counters,
@@ -380,7 +380,7 @@ impl Code128Reader {
                         );
                         if variance < bestVariance {
                             bestVariance = variance;
-                            bestMatch = startCode as isize;
+                            bestMatch = startCode as i32;
                         }
                     }
                     // Look for whitespace before start pattern, >= 50% of width of start pattern

src/oned/code_39_reader.rs

@@ -211,14 +211,17 @@ impl Code39Reader {
         }
     }
 
-    fn findAsteriskPattern(row: &BitArray, counters: &mut [u32]) -> Result<Vec<u32>> {
+    fn findAsteriskPattern<const N: usize>(
+        row: &BitArray,
+        counters: &mut [u32; N],
+    ) -> Result<[u32; 2]> {
         let width = row.get_size();
         let rowOffset = row.getNextSet(0);
 
         let mut counterPosition = 0;
         let mut patternStart = rowOffset;
         let mut isWhite = false;
-        let patternLength = counters.len();
+        let patternLength = N;
 
         for i in rowOffset..width {
             // for (int i = rowOffset; i < width; i++) {
@@ -236,7 +239,7 @@ impl Code39Reader {
                             false,
                         )?
                     {
-                        return Ok(vec![patternStart as u32, i as u32]);
+                        return Ok([patternStart as u32, i as u32]);
                         // return new int[]{patternStart, i};
                     }
                     patternStart += (counters[0] + counters[1]) as usize;
@@ -258,8 +261,8 @@ impl Code39Reader {
 
     // For efficiency, returns -1 on failure. Not throwing here saved as many as 700 exceptions
     // per image when using some of our blackbox images.
-    fn toNarrowWidePattern(counters: &[u32]) -> i32 {
-        let numCounters = counters.len();
+    fn toNarrowWidePattern<const N: usize>(counters: &[u32; N]) -> i32 {
+        let numCounters = N;
         let mut maxNarrowCounter = 0;
         let mut wideCounters;
         loop {

src/oned/code_93_reader.rs

@@ -169,7 +169,7 @@ impl Code93Reader {
         let rowOffset = row.getNextSet(0);
 
         self.counters.fill(0);
-        let mut theCounters = self.counters;
+        let theCounters = &mut self.counters;
         let mut patternStart = rowOffset;
         let mut isWhite = false;
         let patternLength = theCounters.len();
@@ -180,7 +180,7 @@ impl Code93Reader {
                 theCounters[counterPosition] += 1;
             } else {
                 if counterPosition == patternLength - 1 {
-                    if Self::toPattern(&theCounters) == Self::ASTERISK_ENCODING {
+                    if Self::toPattern(theCounters) == Self::ASTERISK_ENCODING {
                         return Ok([patternStart, i]);
                     }
                     patternStart += (theCounters[0] + theCounters[1]) as usize;
@@ -199,11 +199,11 @@ impl Code93Reader {
         Err(Exceptions::NOT_FOUND)
     }
 
-    fn toPattern(counters: &[u32; 6]) -> i32 {
+    fn toPattern<const N: usize>(counters: &[u32; N]) -> i32 {
         let sum = counters.iter().sum::<u32>();
 
         let mut pattern = 0;
-        let max = counters.len();
+        let max = N;
         for (i, counter) in counters.iter().enumerate().take(max) {
             let scaled = (*counter as f32 * 9.0 / sum as f32).round() as u32;
             if !(1..=4).contains(&scaled) {

src/oned/itf_reader.rs

@@ -333,14 +333,14 @@ impl ITFReader {
      *         ints
      * @throws NotFoundException if pattern is not found
      */
-    fn findGuardPattern(
+    fn findGuardPattern<const N: usize>(
         &self,
         row: &BitArray,
         rowOffset: usize,
-        pattern: &[u32],
+        pattern: &[u32; N],
     ) -> Result<[usize; 2]> {
-        let patternLength = pattern.len();
-        let mut counters = vec![0u32; patternLength]; //new int[patternLength];
+        let patternLength = N;
+        let mut counters = [0u32; N]; //new int[patternLength];
         let width = row.get_size();
         let mut isWhite = false;
 
@@ -384,7 +384,7 @@ impl ITFReader {
      * @return The decoded digit
      * @throws NotFoundException if digit cannot be decoded
      */
-    fn decodeDigit(&self, counters: &[u32]) -> Result<u32> {
+    fn decodeDigit(&self, counters: &[u32; 5]) -> Result<u32> {
         let mut bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
         let mut bestMatch = -1_isize;
         for (i, pattern) in PATTERNS.iter().enumerate() {

src/oned/one_d_reader.rs

@@ -212,12 +212,12 @@ fn pad_bitarray(bits: &[u8], quiet_zone: usize) -> BitArray {
  * @param maxIndividualVariance The most any counter can differ before we give up
  * @return ratio of total variance between counters and pattern compared to total pattern size
  */
-pub fn pattern_match_variance(
-    counters: &[u32],
+pub fn pattern_match_variance<const N: usize>(
+    counters: &[u32; N],
     pattern: &[u32],
     mut max_individual_variance: f32,
 ) -> f32 {
-    let num_counters = counters.len();
+    let num_counters = N;
 
     let total: f32 = counters.iter().sum::<u32>() as f32;
     let pattern_length: u32 = pattern.iter().take(num_counters).sum();
@@ -266,8 +266,12 @@ pub fn pattern_match_variance(
  * @throws NotFoundException if counters cannot be filled entirely from row before running out
  *  of pixels
  */
-pub fn record_pattern(row: &BitArray, start: usize, counters: &mut [u32]) -> Result<()> {
-    let num_counters = counters.len();
+pub fn record_pattern<const N: usize>(
+    row: &BitArray,
+    start: usize,
+    counters: &mut [u32; N],
+) -> Result<()> {
+    let num_counters = N;
     counters.fill(0);
 
     let end = row.get_size();
@@ -300,10 +304,14 @@ pub fn record_pattern(row: &BitArray, start: usize, counters: &mut [u32]) -> Res
     Ok(())
 }
 
-pub fn record_pattern_in_reverse(row: &BitArray, start: usize, counters: &mut [u32]) -> Result<()> {
+pub fn record_pattern_in_reverse<const N: usize>(
+    row: &BitArray,
+    start: usize,
+    counters: &mut [u32; N],
+) -> Result<()> {
     let mut start = start;
     // This could be more efficient I guess
-    let mut num_transitions_left = counters.len() as isize;
+    let mut num_transitions_left = N as isize;
     let mut last = row.get(start);
     while start > 0 && num_transitions_left >= 0 {
         start -= 1;

src/oned/rss/abstract_rss_reader.rs

@@ -31,7 +31,10 @@ pub trait AbstractRSSReaderTrait: OneDReader {
     const MIN_FINDER_PATTERN_RATIO: f32 = 9.5 / 12.0;
     const MAX_FINDER_PATTERN_RATIO: f32 = 12.5 / 14.0;
 
-    fn parseFinderValue(counters: &[u32], finderPatterns: &[[u32; 4]]) -> Result<u32> {
+    fn parseFinderValue<const N: usize>(
+        counters: &[u32; N],
+        finderPatterns: &[[u32; N]],
+    ) -> Result<u32> {
         for (value, pattern) in finderPatterns.iter().enumerate() {
             if one_d_reader::pattern_match_variance(
                 counters,
@@ -69,7 +72,10 @@ pub trait AbstractRSSReaderTrait: OneDReader {
         array[index] -= 1;
     }
 
-    fn isFinderPattern(counters: &[u32]) -> bool {
+    fn isFinderPattern<const N: usize>(counters: &[u32; N]) -> bool {
+        if N < 4 {
+            return false;
+        }
         let firstTwoSum = counters[0] + counters[1];
         let sum = firstTwoSum + counters[2] + counters[3];
         let ratio: f32 = (firstTwoSum as f32) / (sum as f32);

src/oned/rss/expanded/rss_expanded_reader.rs

@@ -758,12 +758,8 @@ impl RSSExpandedReader {
         Err(Exceptions::NOT_FOUND)
     }
 
-    fn reverseCounters(counters: &mut [u32]) {
+    fn reverseCounters<const N: usize>(counters: &mut [u32; N]) {
         counters.reverse();
-        // let length = counters.len();
-        // for i in 0..length / 2 {
-        //     counters.swap(i, length - i - 1);
-        // }
     }
 
     fn parseFoundFinderPattern(
@@ -833,14 +829,6 @@ impl RSSExpandedReader {
             record_pattern(row, pattern.getStartEnd()[1], counters)?;
             // reverse it
             counters.reverse();
-            // let mut i = 0;
-            // let mut j = counters.len() - 1;
-            // while i < j {
-            //     counters.swap(i, j);
-
-            //     i += 1;
-            //     j -= 1;
-            // }
         } //counters[] has the pixels of the module
 
         //left and right data characters have all the same length

src/oned/rss/rss_14_reader.rs

@@ -276,14 +276,6 @@ impl RSS14Reader {
             one_d_reader::record_pattern(row, pattern.getStartEnd()[1], counters)?;
             // reverse it
             counters.reverse();
-            // let mut i = 0;
-            // let mut j = counters.len() - 1;
-            // while i < j {
-            //     counters.swap(i, j);
-
-            //     i += 1;
-            //     j -= 1;
-            // }
         }
 
         let numModules = if outsideChar { 16 } else { 15 };

src/oned/upc_ean_reader.rs

@@ -337,20 +337,14 @@ pub trait UPCEANReader: OneDReader {
         self.findGuardPattern(row, endStart, false, &START_END_PATTERN)
     }
 
-    fn findGuardPattern(
+    fn findGuardPattern<const N: usize>(
         &self,
         row: &BitArray,
         rowOffset: usize,
         whiteFirst: bool,
-        pattern: &[u32],
+        pattern: &[u32; N],
     ) -> Result<[usize; 2]> {
-        self.findGuardPatternWithCounters(
-            row,
-            rowOffset,
-            whiteFirst,
-            pattern,
-            &mut vec![0u32; pattern.len()],
-        )
+        self.findGuardPatternWithCounters(row, rowOffset, whiteFirst, pattern, &mut [0u32; N])
     }
 
     /**
@@ -364,13 +358,13 @@ pub trait UPCEANReader: OneDReader {
      * @return start/end horizontal offset of guard pattern, as an array of two ints
      * @throws NotFoundException if pattern is not found
      */
-    fn findGuardPatternWithCounters(
+    fn findGuardPatternWithCounters<const N: usize>(
         &self,
         row: &BitArray,
         rowOffset: usize,
         whiteFirst: bool,
-        pattern: &[u32],
-        counters: &mut [u32],
+        pattern: &[u32; N],
+        counters: &mut [u32; N],
     ) -> Result<[usize; 2]> {
         let width = row.get_size();
         let rowOffset = if whiteFirst {
@@ -380,7 +374,7 @@ pub trait UPCEANReader: OneDReader {
         };
         let mut counterPosition = 0;
         let mut patternStart = rowOffset;
-        let patternLength = pattern.len();
+        let patternLength = N;
         let mut isWhite = whiteFirst;
         for x in rowOffset..width {
             // for (int x = rowOffset; x < width; x++) {