C# BitArray.getNextSet方法代码示例

      /// <summary>
      /// Skip all whitespace until we get to the first black line.
      /// </summary>
      /// <param name="row">row of black/white values to search</param>
      /// <returns>index of the first black line or -1 if no black lines are found in the row.</returns>
      private static int skipWhiteSpace(BitArray row)
      {
         int width = row.Size;
         int endStart = row.getNextSet(0);
         if (endStart == width)
         {
            return -1;
         }

         return endStart;
      }

      /// <summary>
      ///   <p>Attempts to decode a one-dimensional barcode format given a single row of
      /// an image.</p>
      /// </summary>
      /// <param name="rowNumber">row number from top of the row</param>
      /// <param name="row">the black/white pixel data of the row</param>
      /// <param name="hints">decode hints</param>
      /// <returns><see cref="Result"/>containing encoded string and start/end of barcode</returns>
      override public Result decodeRow(int rowNumber, BitArray row, IDictionary<DecodeHintType, object> hints)
      {
         for (var index = 0; index < counters.Length; index++)
            counters[index] = 0;
         decodeRowResult.Length = 0;

         int[] start = findStartPattern(row, counters);
         if (start == null)
            return null;

         // Read off white space    
         int nextStart = row.getNextSet(start[1]);

         char decodedChar;
         int lastStart = nextStart;
         int pattern;
         do
         {
            if (!recordPattern(row, nextStart, counters, 8))
            {
               // not enough bars for a number but perhaps enough for the end pattern
               var endPattern = findEndPattern(row, nextStart, counters);
               if (endPattern == null)
                  return null;
               lastStart = nextStart;
               nextStart = endPattern[1];
               break;
            }
            pattern = toPattern(counters, 8);
            if (!patternToChar(pattern, out decodedChar))
            {
               // pattern doesn't result in an encoded number
               // but it could be the end pattern followed by some black areas
               var endPattern = findEndPattern(row, nextStart, counters);
               if (endPattern == null)
                  return null;
               lastStart = nextStart;
               nextStart = endPattern[1];
               break;
            }
            decodeRowResult.Append(decodedChar);
            lastStart = nextStart;
            foreach (int counter in counters)
            {
               nextStart += counter;
            }
            // Read off white space
            nextStart = row.getNextSet(nextStart);
         } while (decodedChar != '*');
         
         // at least 3 digits to prevent false positives within other kind
         // of codes like PDF417
         if (decodeRowResult.Length < 3)
         {
            return null;
         }

         var rawBytes = Encoding.UTF8.GetBytes(decodeRowResult.ToString());
         var resultString = decodeRowResult.ToString();

         if (usingCheckDigit)
         {
            var resultStringWithoutChecksum = resultString.Substring(0, resultString.Length - 1);
            int checkSum = CalculateChecksumLuhn(resultStringWithoutChecksum);
            if ((char)(checkSum + 48) != resultString[resultStringWithoutChecksum.Length])
            {
               return null;
            }
         }

         float left = (float)(start[1] + start[0]) / 2.0f;
         float right = (float)(nextStart + lastStart) / 2.0f;

         var resultPointCallback = hints == null || !hints.ContainsKey(DecodeHintType.NEED_RESULT_POINT_CALLBACK)
                                      ? null
                                      : (ResultPointCallback)hints[DecodeHintType.NEED_RESULT_POINT_CALLBACK];
         if (resultPointCallback != null)
         {
            resultPointCallback(new ResultPoint(left, rowNumber));
            resultPointCallback(new ResultPoint(right, rowNumber));
         }

         return new Result(
            resultString,
            rawBytes,
            new[]
               {
                  new ResultPoint(left, rowNumber),
                  new ResultPoint(right, rowNumber)
               },
            BarcodeFormat.MSI);
      }

 /// <summary>
 /// </summary>
 /// <param name="row">row of black/white values to search</param>
 /// <param name="rowOffset">position to start search</param>
 /// <param name="whiteFirst">if true, indicates that the pattern specifies white/black/white/...</param>
 /// pixel counts, otherwise, it is interpreted as black/white/black/...
 /// <param name="pattern">pattern of counts of number of black and white pixels that are being</param>
 /// searched for as a pattern
 /// <param name="counters">array of counters, as long as pattern, to re-use</param>
 /// <returns>start/end horizontal offset of guard pattern, as an array of two ints</returns>
 internal static int[] findGuardPattern(BitArray row,
                               int rowOffset,
                               bool whiteFirst,
                               int[] pattern,
                               int[] counters)
 {
    int patternLength = pattern.Length;
    int width = row.Size;
    bool isWhite = whiteFirst;
    rowOffset = whiteFirst ? row.getNextUnset(rowOffset) : row.getNextSet(rowOffset);
    int counterPosition = 0;
    int patternStart = rowOffset;
    for (int x = rowOffset; x < width; x++)
    {
       if (row[x] ^ isWhite)
       {
          counters[counterPosition]++;
       }
       else
       {
          if (counterPosition == patternLength - 1)
          {
             if (patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE)
             {
                return new int[] { patternStart, x };
             }
             patternStart += counters[0] + counters[1];
             Array.Copy(counters, 2, counters, 0, patternLength - 2);
             counters[patternLength - 2] = 0;
             counters[patternLength - 1] = 0;
             counterPosition--;
          }
          else
          {
             counterPosition++;
          }
          counters[counterPosition] = 1;
          isWhite = !isWhite;
       }
    }
    return null;
 }

      /// <summary>
      ///   <p>Attempts to decode a one-dimensional barcode format given a single row of
      /// an image.</p>
      /// </summary>
      /// <param name="rowNumber">row number from top of the row</param>
      /// <param name="row">the black/white pixel data of the row</param>
      /// <param name="hints">decode hints</param>
      /// <returns><see cref="Result"/>containing encoded string and start/end of barcode</returns>
      override public Result decodeRow(int rowNumber, BitArray row, IDictionary<DecodeHintType, object> hints)
      {
         for (var index = 0; index < counters.Length; index++)
            counters[index] = 0;
         decodeRowResult.Length = 0;
         
         int[] start = findAsteriskPattern(row);
         if (start == null)
            return null;

         // Read off white space    
         int nextStart = row.getNextSet(start[1]);
         int end = row.Size;

         char decodedChar;
         int lastStart;
         do
         {
            if (!recordPattern(row, nextStart, counters))
               return null;

            int pattern = toPattern(counters);
            if (pattern < 0)
            {
               return null;
            }
            if (!patternToChar(pattern, out decodedChar))
               return null;
            decodeRowResult.Append(decodedChar);
            lastStart = nextStart;
            foreach (int counter in counters)
            {
               nextStart += counter;
            }
            // Read off white space
            nextStart = row.getNextSet(nextStart);
         } while (decodedChar != '*');
         decodeRowResult.Remove(decodeRowResult.Length - 1, 1); // remove asterisk

         // Should be at least one more black module
         if (nextStart == end || !row[nextStart])
         {
            return null;
         }

         if (decodeRowResult.Length < 2)
         {
            // false positive -- need at least 2 checksum digits
            return null;
         }

         if (!checkChecksums(decodeRowResult))
            return null;
         // Remove checksum digits
         decodeRowResult.Length = decodeRowResult.Length - 2;

         String resultString = decodeExtended(decodeRowResult);
         if (resultString == null)
            return null;

         float left = (start[1] + start[0])/2.0f;
         float right = (nextStart + lastStart)/2.0f;

         var resultPointCallback = hints == null || !hints.ContainsKey(DecodeHintType.NEED_RESULT_POINT_CALLBACK)
                                      ? null
                                      : (ResultPointCallback) hints[DecodeHintType.NEED_RESULT_POINT_CALLBACK];
         if (resultPointCallback != null)
         {
            resultPointCallback(new ResultPoint(left, rowNumber));
            resultPointCallback(new ResultPoint(right, rowNumber));
         }

         return new Result(
            resultString,
            null,
            new[]
               {
                  new ResultPoint(left, rowNumber),
                  new ResultPoint(right, rowNumber)
               },
            BarcodeFormat.CODE_93);
      }

      private int[] findStartPattern(BitArray row, int[] counters)
      {
         const int patternLength = 2;

         int width = row.Size;
         int rowOffset = row.getNextSet(0);

         int counterPosition = 0;
         int patternStart = rowOffset;
         bool isWhite = false;

         counters[0] = 0;
         counters[1] = 0;
         for (int i = rowOffset; i < width; i++)
         {
            if (row[i] ^ isWhite)
            {
               counters[counterPosition]++;
            }
            else
            {
               if (counterPosition == patternLength - 1)
               {
                  // narrow and wide areas should be as near as possible to factor 2
                  // lets say we will check 1.5 <= factor <= 5
                  var factorNarrowToWide = ((float)counters[0]) / ((float)counters[1]);
                  if (factorNarrowToWide >= 1.5 && factorNarrowToWide <= 5)
                  {
                     calculateAverageCounterWidth(counters, patternLength);
                     if (toPattern(counters, patternLength) == START_ENCODING)
                     {
                        // Look for whitespace before start pattern, >= 50% of width of start pattern
                        if (row.isRange(Math.Max(0, patternStart - ((i - patternStart) >> 1)), patternStart, false))
                        {
                           return new int[] {patternStart, i};
                        }
                     }
                  }
                  patternStart += counters[0] + counters[1];
                  Array.Copy(counters, 2, counters, 0, patternLength - 2);
                  counters[patternLength - 2] = 0;
                  counters[patternLength - 1] = 0;
                  counterPosition--;
               }
               else
               {
                  counterPosition++;
               }
               counters[counterPosition] = 1;
               isWhite = !isWhite;
            }
         }
         return null;
      }

      /// <summary>
      ///   <p>Attempts to decode a one-dimensional barcode format given a single row of
      /// an image.</p>
      /// </summary>
      /// <param name="rowNumber">row number from top of the row</param>
      /// <param name="row">the black/white pixel data of the row</param>
      /// <param name="hints">decode hints</param>
      /// <returns><see cref="Result"/>containing encoded string and start/end of barcode</returns>
      override public Result decodeRow(int rowNumber, BitArray row, IDictionary<DecodeHintType, object> hints)
      {
         for (var index = 0; index < counters.Length; index++)
            counters[index] = 0;
         decodeRowResult.Length = 0;

         int[] start = findAsteriskPattern(row, counters);
         if (start == null)
            return null;

         // Read off white space    
         int nextStart = row.getNextSet(start[1]);
         int end = row.Size;

         char decodedChar;
         int lastStart;
         do
         {
            if (!recordPattern(row, nextStart, counters))
               return null;

            int pattern = toNarrowWidePattern(counters);
            if (pattern < 0)
            {
               return null;
            }
            if (!patternToChar(pattern, out decodedChar))
               return null;
            decodeRowResult.Append(decodedChar);
            lastStart = nextStart;
            foreach (int counter in counters)
            {
               nextStart += counter;
            }
            // Read off white space
            nextStart = row.getNextSet(nextStart);
         } while (decodedChar != '*');
         decodeRowResult.Length = decodeRowResult.Length - 1; // remove asterisk

         // Look for whitespace after pattern:
         int lastPatternSize = 0;
         foreach (int counter in counters)
         {
            lastPatternSize += counter;
         }
         int whiteSpaceAfterEnd = nextStart - lastStart - lastPatternSize;
         // If 50% of last pattern size, following last pattern, is not whitespace, fail
         // (but if it's whitespace to the very end of the image, that's OK)
         if (nextStart != end && (whiteSpaceAfterEnd >> 1) < lastPatternSize)
         {
            return null;
         }

         // overriding constructor value is possible
         bool useCode39CheckDigit = usingCheckDigit;
         if (hints != null && hints.ContainsKey(DecodeHintType.ASSUME_CODE_39_CHECK_DIGIT))
         {
            useCode39CheckDigit = (bool) hints[DecodeHintType.ASSUME_CODE_39_CHECK_DIGIT];
         }

         if (useCode39CheckDigit)
         {
            int max = decodeRowResult.Length - 1;
            int total = 0;
            for (int i = 0; i < max; i++)
            {
               total += ALPHABET_STRING.IndexOf(decodeRowResult[i]);
            }
            if (decodeRowResult[max] != ALPHABET[total % 43])
            {
               return null;
            }
            decodeRowResult.Length = max;
         }

         if (decodeRowResult.Length == 0)
         {
            // false positive
            return null;
         }

         // overriding constructor value is possible
         bool useCode39ExtendedMode = extendedMode;
         if (hints != null && hints.ContainsKey(DecodeHintType.USE_CODE_39_EXTENDED_MODE))
         {
            useCode39ExtendedMode = (bool)hints[DecodeHintType.USE_CODE_39_EXTENDED_MODE];
         }

         String resultString;
         if (useCode39ExtendedMode)
         {
            resultString = decodeExtended(decodeRowResult.ToString());
//.........这里部分代码省略.........

      private int[] findAsteriskPattern(BitArray row)
      {
         int width = row.Size;
         int rowOffset = row.getNextSet(0);

         for (var index = 0; index < counters.Length; index++)
            counters[index] = 0;
         int counterPosition = 0;
         int patternStart = rowOffset;
         bool isWhite = false;
         int patternLength = counters.Length;

         for (int i = rowOffset; i < width; i++)
         {
            if (row[i] ^ isWhite)
            {
               counters[counterPosition]++;
            }
            else
            {
               if (counterPosition == patternLength - 1)
               {
                  if (toPattern(counters) == ASTERISK_ENCODING)
                  {
                     return new int[] { patternStart, i };
                  }
                  patternStart += counters[0] + counters[1];
                  Array.Copy(counters, 2, counters, 0, patternLength - 2);
                  counters[patternLength - 2] = 0;
                  counters[patternLength - 1] = 0;
                  counterPosition--;
               }
               else
               {
                  counterPosition++;
               }
               counters[counterPosition] = 1;
               isWhite = !isWhite;
            }
         }
         return null;
      }

      private static int[] findStartPattern(BitArray row)
      {
         int width = row.Size;
         int rowOffset = row.getNextSet(0);

         int counterPosition = 0;
         int[] counters = new int[6];
         int patternStart = rowOffset;
         bool isWhite = false;
         int patternLength = counters.Length;

         for (int i = rowOffset; i < width; i++)
         {
            if (row[i] ^ isWhite)
            {
               counters[counterPosition]++;
            }
            else
            {
               if (counterPosition == patternLength - 1)
               {
                  int bestVariance = MAX_AVG_VARIANCE;
                  int bestMatch = -1;
                  for (int startCode = CODE_START_A; startCode <= CODE_START_C; startCode++)
                  {
                     int variance = patternMatchVariance(counters, CODE_PATTERNS[startCode],
                         MAX_INDIVIDUAL_VARIANCE);
                     if (variance < bestVariance)
                     {
                        bestVariance = variance;
                        bestMatch = startCode;
                     }
                  }
                  if (bestMatch >= 0)
                  {
                     // Look for whitespace before start pattern, >= 50% of width of start pattern
                     if (row.isRange(Math.Max(0, patternStart - (i - patternStart) / 2), patternStart,
                         false))
                     {
                        return new int[] { patternStart, i, bestMatch };
                     }
                  }
                  patternStart += counters[0] + counters[1];
                  Array.Copy(counters, 2, counters, 0, patternLength - 2);
                  counters[patternLength - 2] = 0;
                  counters[patternLength - 1] = 0;
                  counterPosition--;
               }
               else
               {
                  counterPosition++;
               }
               counters[counterPosition] = 1;
               isWhite = !isWhite;
            }
         }
         return null;
      }

      private static int[] findAsteriskPattern(BitArray row, int[] counters)
      {
         int width = row.Size;
         int rowOffset = row.getNextSet(0);

         int counterPosition = 0;
         int patternStart = rowOffset;
         bool isWhite = false;
         int patternLength = counters.Length;

         for (int i = rowOffset; i < width; i++)
         {
            if (row[i] ^ isWhite)
            {
               counters[counterPosition]++;
            }
            else
            {
               if (counterPosition == patternLength - 1)
               {
                  if (toNarrowWidePattern(counters) == ASTERISK_ENCODING)
                  {
                     // Look for whitespace before start pattern, >= 50% of width of start pattern
                     if (row.isRange(Math.Max(0, patternStart - ((i - patternStart) >> 1)), patternStart, false))
                     {
                        return new int[] { patternStart, i };
                     }
                  }
                  patternStart += counters[0] + counters[1];
                  Array.Copy(counters, 2, counters, 0, patternLength - 2);
                  counters[patternLength - 2] = 0;
                  counters[patternLength - 1] = 0;
                  counterPosition--;
               }
               else
               {
                  counterPosition++;
               }
               counters[counterPosition] = 1;
               isWhite = !isWhite;
            }
         }
         return null;
      }

 private static int getNextSecondBar(BitArray row, int initialPos)
 {
    int currentPos;
    if (row[initialPos])
    {
       currentPos = row.getNextUnset(initialPos);
       currentPos = row.getNextSet(currentPos);
    }
    else
    {
       currentPos = row.getNextSet(initialPos);
       currentPos = row.getNextUnset(currentPos);
    }
    return currentPos;
 }

        private int isIMB(BitArray row, ref int pixelStartOffset, ref int pixelStopOffset, ref int pixelBarLength)
        {
            int width = row.Size;
            int rowOffset = row.getNextSet(0);
            pixelStartOffset = rowOffset;
            int previousPixelOffset = pixelStartOffset;
            const bool isWhite = false;

            int countBars = 0;
            bool insideBar = false;
            int currBarLength = 0;
            int prevBarLength = 0;

            bool insideWS = false;
            int numWSBetween = 0;
            int currWSLength = 0;
            int prevWSLength = 0;

            for (int i = rowOffset; i < width; i++)
            {
                if (row[i] ^ isWhite) // if current pixel is black
                {
                    insideWS = false;

                    if (!insideBar)
                    {
                        if (countBars <= 1)
                        {
                            prevWSLength = currWSLength;
                        }
                        else
                        {
                            if (prevWSLength != currWSLength)
                            {
                                numWSBetween = 1;
                                prevWSLength = currWSLength;
                                countBars = 1;
                                pixelStartOffset = previousPixelOffset;
                            }
                        }
                        countBars++;

                        insideBar = true;
                        previousPixelOffset = i;
                    }

                    currWSLength = 0;

                    currBarLength++;
                }
                else // if current pixel is white
                {
                    insideBar = false;

                    if (!insideWS)
                    {
                        numWSBetween++;
                        insideWS = true;

                        if (countBars <= 1)
                            prevBarLength = currBarLength;
                        else
                        {
                            if (prevBarLength != currBarLength)
                            {
                                countBars = 1;
                                numWSBetween = 1;
                                prevWSLength = 0;
                                pixelStartOffset = previousPixelOffset;
                                prevBarLength = currBarLength;
                            }
                            else
                            {
                                if (countBars == 65) // made it this far, so break
                                {
                                    pixelStopOffset = i;
                                    //pixelBarLength = prevBarLength;
                                    break;
                                }
                            }
                        }
                        currBarLength = 0;
                    }


                    currWSLength++;
                }


            }

            pixelBarLength = prevBarLength;
            return (countBars);
        }

      int decodeMiddle(BitArray row, int[] startRange, StringBuilder resultString)
      {
         int[] counters = decodeMiddleCounters;
         counters[0] = 0;
         counters[1] = 0;
         counters[2] = 0;
         counters[3] = 0;
         int end = row.Size;
         int rowOffset = startRange[1];

         int checkParity = 0;

         for (int x = 0; x < 2 && rowOffset < end; x++)
         {
            int bestMatch;
            if (!UPCEANReader.decodeDigit(row, counters, rowOffset, UPCEANReader.L_AND_G_PATTERNS, out bestMatch))
               return -1;
            resultString.Append((char)('0' + bestMatch % 10));
            foreach (int counter in counters)
            {
               rowOffset += counter;
            }
            if (bestMatch >= 10)
            {
               checkParity |= 1 << (1 - x);
            }
            if (x != 1)
            {
               // Read off separator if not last
               rowOffset = row.getNextSet(rowOffset);
               rowOffset = row.getNextUnset(rowOffset);
            }
         }

         if (resultString.Length != 2)
         {
            return -1;
         }

         if (int.Parse(resultString.ToString()) % 4 != checkParity)
         {
            return -1;
         }

         return rowOffset;
      }

      /// <summary>
      ///   <p>Attempts to decode a one-dimensional barcode format given a single row of
      /// an image.</p>
      /// </summary>
      /// <param name="rowNumber">row number from top of the row</param>
      /// <param name="row">the black/white pixel data of the row</param>
      /// <param name="hints">decode hints</param>
      /// <returns><see cref="Result"/>containing encoded string and start/end of barcode</returns>
      override public Result decodeRow(int rowNumber, BitArray row, IDictionary<DecodeHintType, object> hints)
      {
         int[] counters = new int[9];
         int[] start = findAsteriskPattern(row, counters);
         if (start == null)
            return null;

         // Read off white space    
         int nextStart = row.getNextSet(start[1]);
         int end = row.Size;

         StringBuilder result = new StringBuilder(20);
         char decodedChar;
         int lastStart;
         do
         {
            if (!recordPattern(row, nextStart, counters))
               return null;

            int pattern = toNarrowWidePattern(counters);
            if (pattern < 0)
            {
               return null;
            }
            if (!patternToChar(pattern, out decodedChar))
               return null;
            result.Append(decodedChar);
            lastStart = nextStart;
            foreach (int counter in counters)
            {
               nextStart += counter;
            }
            // Read off white space
            nextStart = row.getNextSet(nextStart);
         } while (decodedChar != '*');
         result.Length = result.Length - 1; // remove asterisk

         // Look for whitespace after pattern:
         int lastPatternSize = 0;
         foreach (int counter in counters)
         {
            lastPatternSize += counter;
         }
         int whiteSpaceAfterEnd = nextStart - lastStart - lastPatternSize;
         // If 50% of last pattern size, following last pattern, is not whitespace, fail
         // (but if it's whitespace to the very end of the image, that's OK)
         if (nextStart != end && (whiteSpaceAfterEnd >> 1) < lastPatternSize)
         {
            return null;
         }

         if (usingCheckDigit)
         {
            int max = result.Length - 1;
            int total = 0;
            for (int i = 0; i < max; i++)
            {
               total += ALPHABET_STRING.IndexOf(result[i]);
            }
            if (result[max] != ALPHABET[total%43])
            {
               return null;
            }
            result.Length = max;
         }

         if (result.Length == 0)
         {
            // false positive
            return null;
         }

         String resultString;
         if (extendedMode)
         {
            resultString = decodeExtended(result.ToString());
            if (resultString == null)
               return null;
         }
         else
         {
            resultString = result.ToString();
         }

         float left = (float) (start[1] + start[0])/2.0f;
         float right = (float) (nextStart + lastStart)/2.0f;

         var resultPointCallback = hints == null || !hints.ContainsKey(DecodeHintType.NEED_RESULT_POINT_CALLBACK)
                                      ? null
                                      : (ResultPointCallback) hints[DecodeHintType.NEED_RESULT_POINT_CALLBACK];
         if (resultPointCallback != null)
         {
//.........这里部分代码省略.........

      int decodeMiddle(BitArray row, int[] startRange, StringBuilder resultString)
      {
         int[] counters = decodeMiddleCounters;
         counters[0] = 0;
         counters[1] = 0;
         counters[2] = 0;
         counters[3] = 0;
         int end = row.Size;
         int rowOffset = startRange[1];

         int lgPatternFound = 0;

         for (int x = 0; x < 5 && rowOffset < end; x++)
         {
            int bestMatch;
            if (!UPCEANReader.decodeDigit(row, counters, rowOffset, UPCEANReader.L_AND_G_PATTERNS, out bestMatch))
               return -1;
            resultString.Append((char)('0' + bestMatch % 10));
            foreach (int counter in counters)
            {
               rowOffset += counter;
            }
            if (bestMatch >= 10)
            {
               lgPatternFound |= 1 << (4 - x);
            }
            if (x != 4)
            {
               // Read off separator if not last
               rowOffset = row.getNextSet(rowOffset);
               rowOffset = row.getNextUnset(rowOffset);
            }
         }

         if (resultString.Length != 5)
         {
            return -1;
         }

         int checkDigit;
         if (!determineCheckDigit(lgPatternFound, out checkDigit))
            return -1;

         if (extensionChecksum(resultString.ToString()) != checkDigit)
         {
            return -1;
         }

         return rowOffset;
      }