添加项目文件。

zxing.core/xx/oned/rss/AbstractRSSReader.cs

@@ -0,0 +1,216 @@
+/*
+ * 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.
+ */
+
+using System;
+
+namespace ZXing.OneD.RSS
+{
+   /// <summary>
+   /// 
+   /// </summary>
+   public abstract class AbstractRSSReader : OneDReader
+   {
+      private static readonly int MAX_AVG_VARIANCE = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.2f);
+      private static readonly int MAX_INDIVIDUAL_VARIANCE = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.45f);
+
+      private const float MIN_FINDER_PATTERN_RATIO = 9.5f / 12.0f;
+      private const float MAX_FINDER_PATTERN_RATIO = 12.5f / 14.0f;
+
+      private readonly int[] decodeFinderCounters;
+      private readonly int[] dataCharacterCounters;
+      private readonly float[] oddRoundingErrors;
+      private readonly float[] evenRoundingErrors;
+      private readonly int[] oddCounts;
+      private readonly int[] evenCounts;
+
+      /// <summary>
+      /// Initializes a new instance of the <see cref="AbstractRSSReader"/> class.
+      /// </summary>
+      protected AbstractRSSReader()
+      {
+         decodeFinderCounters = new int[4];
+         dataCharacterCounters = new int[8];
+         oddRoundingErrors = new float[4];
+         evenRoundingErrors = new float[4];
+         oddCounts = new int[dataCharacterCounters.Length / 2];
+         evenCounts = new int[dataCharacterCounters.Length / 2];
+      }
+
+      /// <summary>
+      /// Gets the decode finder counters.
+      /// </summary>
+      /// <returns></returns>
+      protected int[] getDecodeFinderCounters()
+      {
+         return decodeFinderCounters;
+      }
+
+      /// <summary>
+      /// Gets the data character counters.
+      /// </summary>
+      /// <returns></returns>
+      protected int[] getDataCharacterCounters()
+      {
+         return dataCharacterCounters;
+      }
+
+      /// <summary>
+      /// Gets the odd rounding errors.
+      /// </summary>
+      /// <returns></returns>
+      protected float[] getOddRoundingErrors()
+      {
+         return oddRoundingErrors;
+      }
+
+      /// <summary>
+      /// Gets the even rounding errors.
+      /// </summary>
+      /// <returns></returns>
+      protected float[] getEvenRoundingErrors()
+      {
+         return evenRoundingErrors;
+      }
+
+      /// <summary>
+      /// Gets the odd counts.
+      /// </summary>
+      /// <returns></returns>
+      protected int[] getOddCounts()
+      {
+         return oddCounts;
+      }
+
+      /// <summary>
+      /// Gets the even counts.
+      /// </summary>
+      /// <returns></returns>
+      protected int[] getEvenCounts()
+      {
+         return evenCounts;
+      }
+
+      /// <summary>
+      /// Parses the finder value.
+      /// </summary>
+      /// <param name="counters">The counters.</param>
+      /// <param name="finderPatterns">The finder patterns.</param>
+      /// <param name="value">The value.</param>
+      /// <returns></returns>
+      protected static bool parseFinderValue(int[] counters,
+                                            int[][] finderPatterns,
+                                            out int value)
+      {
+         for (value = 0; value < finderPatterns.Length; value++)
+         {
+            if (patternMatchVariance(counters, finderPatterns[value], MAX_INDIVIDUAL_VARIANCE) <
+                MAX_AVG_VARIANCE)
+            {
+               return true;
+            }
+         }
+         return false;
+      }
+
+      /// <summary>
+      /// Counts the specified array.
+      /// </summary>
+      /// <param name="array">The array.</param>
+      /// <returns></returns>
+      protected static int count(int[] array)
+      {
+         int count = 0;
+         foreach (int a in array)
+         {
+            count += a;
+         }
+         return count;
+      }
+
+      /// <summary>
+      /// Increments the specified array.
+      /// </summary>
+      /// <param name="array">The array.</param>
+      /// <param name="errors">The errors.</param>
+      protected static void increment(int[] array, float[] errors)
+      {
+         int index = 0;
+         float biggestError = errors[0];
+         for (int i = 1; i < array.Length; i++)
+         {
+            if (errors[i] > biggestError)
+            {
+               biggestError = errors[i];
+               index = i;
+            }
+         }
+         array[index]++;
+      }
+
+      /// <summary>
+      /// Decrements the specified array.
+      /// </summary>
+      /// <param name="array">The array.</param>
+      /// <param name="errors">The errors.</param>
+      protected static void decrement(int[] array, float[] errors)
+      {
+         int index = 0;
+         float biggestError = errors[0];
+         for (int i = 1; i < array.Length; i++)
+         {
+            if (errors[i] < biggestError)
+            {
+               biggestError = errors[i];
+               index = i;
+            }
+         }
+         array[index]--;
+      }
+
+      /// <summary>
+      /// Determines whether [is finder pattern] [the specified counters].
+      /// </summary>
+      /// <param name="counters">The counters.</param>
+      /// <returns>
+      ///   <c>true</c> if [is finder pattern] [the specified counters]; otherwise, <c>false</c>.
+      /// </returns>
+      protected static bool isFinderPattern(int[] counters)
+      {
+         int firstTwoSum = counters[0] + counters[1];
+         int sum = firstTwoSum + counters[2] + counters[3];
+         float ratio = (float)firstTwoSum / (float)sum;
+         if (ratio >= MIN_FINDER_PATTERN_RATIO && ratio <= MAX_FINDER_PATTERN_RATIO)
+         {
+            // passes ratio test in spec, but see if the counts are unreasonable
+            int minCounter = Int32.MaxValue;
+            int maxCounter = Int32.MinValue;
+            foreach (int counter in counters)
+            {
+               if (counter > maxCounter)
+               {
+                  maxCounter = counter;
+               }
+               if (counter < minCounter)
+               {
+                  minCounter = counter;
+               }
+            }
+            return maxCounter < 10 * minCounter;
+         }
+         return false;
+      }
+   }
+}