Полезный Open Source и как мы научили Zxing разговаривать на другом языке

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using BitArray = ETR.REBT.BarcodeReader.common.BitArray;

namespace ETR.REBT.BarcodeReader.oned
{    
    public sealed class MyCodeReader : OneDReader
    {
        // These values are critical for determining how permissive the decoding
        // will be. All stripe sizes must be within the window these define, as
        // compared to the average stripe size.
        private static readonly int MAX_ACCEPTABLE = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 2.0f);
        private static readonly int PADDING = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 1.5f);

        private static readonly int STARTEND_LENGTH = 3;
        private static readonly int SYMBOL_LENGTH = 9;
        private static readonly int DATA_LENGTH = 15; // 15 symbols + 2 start/stop symbols
        private static readonly int All_LENGHT = (16 + DATA_LENGTH * SYMBOL_LENGTH + 2 * STARTEND_LENGTH);

        private const String ALPHABET_STRING = "0123456789AE";
        internal static readonly char[] ALPHABET = ALPHABET_STRING.ToCharArray();

        /**
         * These represent the encodings of characters, as patterns of wide and narrow bars. The 7 least-significant bits of
         * each int correspond to the pattern of wide and narrow, with 1s representing "wide" and 0s representing narrow.
         */

        internal static int[] CHARACTER_ENCODINGS = {
                                                    0x014, 0x101, 0x041, 0x140, 0x011, 0x110, 0x050, 0x005, 0x104, 0x044, // 0-9
                                                    0x000, 0x004, // AE
                                                 };

        // minimal number of characters that should be present (inclusing start and stop characters)
        // under normal circumstances this should be set to 3, but can be set higher
        // as a last-ditch attempt to reduce false positives.
        private const int MIN_CHARACTER_LENGTH = 3;

        // Start and end patterns        
        private static readonly char[] START_ENCODING = { 'A' };

        private static readonly char[] END_ENCODING = { 'E' };

        private static readonly char[] DATA_ENCODING = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };

        // some codabar generator allow the codabar string to be closed by every
        // character. This will cause lots of false positives!

        // some industries use a checksum standard but this is not part of the original codabar standard
        // for more information see : http://www.mecsw.com/specs/codabar.html

        // Keep some instance variables to avoid reallocations
        private readonly StringBuilder decodeRowResult;
        private int[] counters;
        private int counterLength;

        public MyCodeReader()
        {
            decodeRowResult = new StringBuilder(40);
            counters = new int[500];
            counterLength = 0;
        }

        override public List<Result> decodeRow(int rowNumber, BitArray row, Hashtable hints)
        {                        
            List<Result> returnList = null;
            
            if (!setCounters(row))
                return null;

            int globalOffset = 0;

            while (globalOffset < counterLength)
            {
                int startSymbolPos = -1;
                int startOffset = findStartPattern(out startSymbolPos, globalOffset);
                if (startOffset < 0)
                    return returnList; // we can't find start char in the whole row -> so, exit

                decodeRowResult.Length = 0;

                decodeRowResult.Append((char)startSymbolPos);                

                int nextStart = startOffset;
                nextStart += (STARTEND_LENGTH + 1/*space between symbols*/);

                bool findNextStart = false;

                do
                {
                    int charOffset = toNarrowWidePattern(nextStart, SYMBOL_LENGTH);
                    if (charOffset == -1 || !arrayContains(DATA_ENCODING, ALPHABET[charOffset]))
                    {
                        findNextStart = true;
                        break;
                    }

                    decodeRowResult.Append((char)charOffset);                    

                    nextStart += (SYMBOL_LENGTH + 1);

                    //  Stop as soon as length of data symbols equals to corresponding number
                    if (decodeRowResult.Length == DATA_LENGTH + 1/*start symbol*/)
                    {
                        int endOffset = toNarrowWidePattern(nextStart, STARTEND_LENGTH);
                        if (endOffset == -1 || !arrayContains(END_ENCODING, ALPHABET[endOffset]))
                        {
                            findNextStart = true;
                            break;
                        }

                        globalOffset = nextStart + STARTEND_LENGTH;

                        decodeRowResult.Append((char)endOffset);
                        break;
                    }

                } while (nextStart < counterLength); // no fixed end pattern so keep on reading while data is available                        

                if (findNextStart)
                {
                    globalOffset = ++startOffset;                    
                    continue;
                }

                if (!validatePattern())
                {
                    globalOffset = ++startOffset;
                    continue;
                }

                // remove stop/start characters character            
                decodeRowResult.Remove(decodeRowResult.Length - 1, 1);
                decodeRowResult.Remove(0, 1);

                int runningCount = 0;
                for (int i = 0; i < startOffset; i++)
                {
                    runningCount += counters[i];
                }
                float left = (float)runningCount;
                for (int i = startOffset; i < nextStart - 1; i++)
                {
                    runningCount += counters[i];
                }
                float right = (float)runningCount;
                Result result = new Result(
                    decodeRowResult.ToString(),
                    null,
                    new ResultPoint[]
            {
                new ResultPoint(left, (float) rowNumber),
                new ResultPoint(right, (float) rowNumber)
            },
                    BarcodeFormat.CODABAR);

                if (returnList == null)
                    returnList = new List<Result>();

                returnList.Add(result);
            }
            
            return returnList;
        }

        private bool validatePattern()
        {
            if (decodeRowResult.Length != DATA_LENGTH + 2)
            {
                return false;
            }

            // Translate character table offsets to actual characters.
            for (int i = 0; i < decodeRowResult.Length; i++)
            {
                decodeRowResult[i] = ALPHABET[decodeRowResult[i]];
            }

            // Ensure a valid start character
            char startchar = decodeRowResult[0];
            if (!arrayContains(START_ENCODING, startchar))
            {
                return false;
            }
            // Ensure a valid end character
            char endchar = decodeRowResult[decodeRowResult.Length - 1];
            if (!arrayContains(END_ENCODING, endchar))
            {
                return false;
            }

            // Ensure a valid data symbols
            for (int i = 1; i < decodeRowResult.Length - 1; i++)
            {
                if (!arrayContains(DATA_ENCODING, decodeRowResult[i]))
                {
                    return false;
                }
            }

            return true;
        }

        /// <summary>
        /// Records the size of all runs of white and black pixels, starting with white.
        /// This is just like recordPattern, except it records all the counters, and
        /// uses our builtin "counters" member for storage.
        /// </summary>
        /// <param name="row">row to count from</param>
        private bool setCounters(BitArray row)
        {                        
            counterLength = 0;
            // Start from the first white bit.
            int i = row.getNextUnset(0);
            int end = row.Size;
            if (i >= end)
            {
                return false;
            }
            bool isWhite = true;
            int count = 0;
            for (; i < end; i++)
            {
                if (row[i] ^ isWhite)
                {
                    // that is, exactly one is true
                    count++;
                }
                else
                {
                    counterAppend(count);
                    count = 1;
                    isWhite = !isWhite;
                }
            }
            counterAppend(count);            
            return true;
        }

        private void counterAppend(int e)
        {
            counters[counterLength] = e;
            counterLength++;
            if (counterLength >= counters.Length)
            {
                int[] temp = new int[counterLength * 2];
                Array.Copy(counters, 0, temp, 0, counterLength);
                counters = temp;
            }
        }

        private int findStartPattern(out int charOffset, int globalOffset)
        {
            charOffset = -1;

            //
            // Assume that first (i = 0) set of pixels is white,
            // so we start find symbols from second set (i = 1).
            // And next we step over white set ('i += 2').
            //
            for (int i = 1 + globalOffset; i < counterLength; i += 2)
            {
                if (counters[i - 1] < counters[i] * 5) // before start char must be a long space
                    continue;                
                
                charOffset = toNarrowWidePattern(i, 3);
                if (charOffset != -1 && arrayContains(START_ENCODING, ALPHABET[charOffset]))
                {                                                            
                    return i;
                }
            }
            return -1;
        }

        internal static bool arrayContains(char[] array, char key)
        {
            if (array != null)
            {
                foreach (char c in array)
                {
                    if (c == key)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        // Assumes that counters[position] is a bar.
        private int toNarrowWidePattern(int position, int offset)
        {
            int end = position + offset;
            if (end >= counterLength)                            
                return -1;
            
            // First element is for bars, second is for spaces.                        
            int[] maxes = { 0, 0 };
            int[] mins = { Int32.MaxValue, Int32.MaxValue };
            int[] thresholds = { 0, 0 };

            for (int i = 0; i < 2; i++)
            {
                for (int j = position + i; j < end; j += 2)
                {
                    if (counters[j] < mins[i])
                    {
                        mins[i] = counters[j];
                    }
                    if (counters[j] > maxes[i])
                    {
                        maxes[i] = counters[j];
                    }
                }

                double tr = ((double)mins[i] + (double)maxes[i]) / 2;
                thresholds[i] = (int)Math.Ceiling(tr);                
            }    
        
            // There are no big spaces in the barcode -> only small spaces
            thresholds[1] = Int32.MaxValue;

            // For start and end symbols defined empirically threshold equals to 5
            if (offset == STARTEND_LENGTH)
                thresholds[0] = 5;            

            int bitmask = 1 << offset;
            int pattern = 0;
            for (int i = 0; i < offset; i++)
            {
                int barOrSpace = i & 1;
                bitmask >>= 1;
                if (counters[position + i] >= thresholds[barOrSpace])
                {
                    pattern |= bitmask;
                }
            }

            for (int i = 0; i < CHARACTER_ENCODINGS.Length; i++)
            {
                if (CHARACTER_ENCODINGS[i] == pattern)
                {
                    return i;
                }
            }
            return -1;
        }
    }
}

var reader = new PdfReader(filePath)

for (var pageNumber = 1; pageNumber <= reader.NumberOfPages; pageNumber++)
            {
                var page = reader.GetPageN(pageNumber);
                List<ImageRenderInfo> images;
                try
                {
                    images = FindImageInPDFDictionary(page);
                }
                catch (Exception)
                {
                    // Переходим к следующей странице PDF документа    
                    continue;
                }
                finally
                {
                    reader.ReleasePage(pageNumber);
                }
                
                foreach (var img in images)
                {
                    var image = RenderImage(img);
                    var result = ImageDecoder.Decode(image, allRotations);
                    if (result != null && result.Count > 0)
                    {
                        // Страница распозналась, можно использовать результат сканирования
                    }
                }
            }

private static List<ImageRenderInfo> FindImageInPDFDictionary(PdfDictionary pg)
        {
            var result = new List<ImageRenderInfo>();

            var res = (PdfDictionary)PdfReader.GetPdfObject(pg.Get(PdfName.RESOURCES));
            var xobj = (PdfDictionary)PdfReader.GetPdfObject(res.Get(PdfName.XOBJECT));
            if (xobj == null) return null;

            foreach (var name in xobj.Keys)
            {
                var obj = xobj.Get(name);
                if (!obj.IsIndirect()) continue;
                var tg = (PdfDictionary)PdfReader.GetPdfObject(obj);

                var type = (PdfName)PdfReader.GetPdfObject(tg.Get(PdfName.SUBTYPE));

                if (PdfName.IMAGE.Equals(type))
                {
                    var width = float.Parse(tg.Get(PdfName.WIDTH).ToString());
                    var height = float.Parse(tg.Get(PdfName.HEIGHT).ToString());
                    if (width > ImageDecoder.MinimalSideResolution || height >= ImageDecoder.MinimalSideResolution)
                    {
                        var imgRi = ImageRenderInfo.CreateForXObject(new Matrix(width, height), (PRIndirectReference)obj, tg);
                        result.Add(imgRi);
                    }
                }
                if (PdfName.FORM.Equals(type))
                {
                    result.AddRange(FindImageInPDFDictionary(tg));
                }
                if (PdfName.GROUP.Equals(type))
                {
                    result.AddRange(FindImageInPDFDictionary(tg));
                }
            }
            return result;
        }

private static Bitmap RenderImage(ImageRenderInfo renderInfo)
        {
            try
            {
                var image = renderInfo.GetImage();
                using (var dotnetImg = image.GetDrawingImage())
                {
                    if (dotnetImg != null)
                    {
                        using (var ms = new MemoryStream())
                        {                           
                            dotnetImg.Save(ms, ImageFormat.Png);
                            return new Bitmap(dotnetImg);                 
          }
                    }
                }
            }
            catch (Exception)
            {

            }
            return null;
        }