Սկանավորեք գրքերը C# շտրիխ կոդերի սկաների միջոցով

Գրքերի սկանավորումը շտրիխ կոդերի սկաներներով դառնում է գրադարանների, գրախանութների, արխիվների և կրթական հաստատությունների ավտոմատացման անբաժանելի մասը։ Այս մոտեցումը արագացնում է մեծ հավաքածուների մշակումը, նվազագույնի է հասցնում հաշվապահական սխալները, ինչպես նաև ապահովում է գրքի և ընթերցողի հետ փոխազդեցության նոր ձևեր։

Սկզբունքներ Գրքերի համատեքստում ծրագրային շտրիխ կոդերի սկաների աշխատանքի սկզբունքը

Ծրագրային սկաները մասնագիտացված ծրագրային լուծում է, որն ավտոմատ կերպով ճանաչում և վերծանում է գրքերին կիրառվող շտրիխ կոդերը՝ օգտագործելով տեսախցիկներ, սկաներներ կամ բջջային սարքեր: Դրա ներդրումը թույլ է տալիս կազմակերպել արագ և ճշգրիտ էլեկտրոնային հաշվապահություն, ֆոնդերի կառավարում և գործարքների մշակում՝ առանց ձեռքով տվյալների մուտքագրման անհրաժեշտության:

Ծրագրային սկաների աշխատանքը հիմնված է հետևյալ սկզբունքի վրա. սարքը (օրինակ՝ տեսախցիկը կամ սկաները) կարդում է շտրիխ կոդի պատկերը գրքի շապիկից կամ էջից, և ծրագիրը վերծանում է դրանում կոդավորված տեղեկատվությունը (օրինակ՝ ISBN) և փոխանցում է այդ տվյալները գրադարան կամ առևտրային համակարգ՝ հետագա մշակման համար:

Գրքերի շտրիխ կոդեր

Վերջին տասնամյակներում հրատարակված գրքերի մեծ մասն ունի շտրիխ կոդ՝ սովորաբար ISBN (International Standard Book Number) EAN-13 ձևաչափով կամ QR կոդ (նոր սերնդի հրատարակությունների դեպքում): Այն պարունակում է գրքի եզակի նույնականացուցիչ, հաճախ՝ թողարկման վերաբերյալ լրացուցիչ տեղեկատվությամբ:

Տեսախցիկների և սկաներների օգտագործում

Ծրագրային շտրիխ կոդերի սկաները ծրագիր կամ գրադարան է, որը կարող է ճանաչել շտրիխ կոդերը՝ օգտագործելով ինչպես հատուկ սարքավորումներ (սկաներներ, տերմինալներ), այնպես էլ վեբ տեսախցիկներ կամ շարժական սարքեր, ինչը գործընթացը դարձնում է հնարավորինս շարժական և մատչելի։

Ճանաչում և տվյալների մշակում

Պատկերի մշակման ալգորիթմները գտնում են գրքի շտրիխ կոդը, վերծանում են դրա մեջ պարունակվող տեղեկատվությունը և ինտեգրում այն ​​կատալոգների, տվյալների բազաների և գրադարանային համակարգերի հետ՝ ապահովելով արագ և ճշգրիտ հաշվապահություն։

Գրքերի սկանավորման փուլեր

Գրքերի սկանավորումը ծրագրային շտրիխ կոդերի սկաների միջոցով ներառում է մի քանի հաջորդական փուլեր, որոնցից յուրաքանչյուրը կարևոր է հաշվապահական հաշվառման, գրքերի տրամադրման և վերադարձման գործընթացների ճշգրտության և արդյունավետության համար։ Ճիշտ կազմակերպված աշխատանքային ցիկլը կարող է զգալիորեն կրճատել գույքագրման ժամանակը, բարելավել տվյալների որակը և օպտիմալացնել սպասարկումը գրադարաններում և գրախանութներում։

Սարքավորումների և ծրագրային ապահովման պատրաստում

Սկանավորումը սկսելուց առաջ համոզվեք, որ ձեր օգտագործած սարքը աջակցում է ընտրված ծրագրակազմին և շտրիխ կոդերի ստանդարտներին։ Այնուհետև՝

• Տեղադրեք և կարգավորեք սկաների ծրագրային ապահովումը համակարգչում,շարժական սարք կամ մասնագիտացված տերմինալ։
• Ստուգեք տեսախցիկների, սկաներների կամ այլ պատկերի գրանցման սարքերի սպասարկելիությունը։
• Ստուգեք գրադարան կամ մանրածախ առևտրի համակարգ մուտք գործելու հնարավորությունը, որի հետ ինտեգրվելու է գրքի տվյալների փոխանցման ծրագիրը։

Շտրիխ կոդի սկանավորում և ճանաչում

Այս փուլում իրականացվում է գրքից շտրիխ կոդի իրական ընթերցումը՝
Գիրքը տեղադրված է այնպես, որ շտրիխ կոդը հստակ տեսանելի լինի տեսախցիկի կամ սկաների համար։

• Ծրագիրը ավտոմատ կերպով գտնում է շտրիխ կոդը պատկերի վրա, նույնիսկ եթե կա արտաքին միջամտություն (արտացոլումներ, ծռումներ, աննշան վնասվածքներ)։
• Տեղի է ունենում վերծանում. ծրագրային սկաները սկանավորված շերտերը կամ պիքսելները վերածում է թվային արժեքի, օրինակ՝ ISBN-ի կամ ներքին գույքագրման համարի։
• Անհրաժեշտության դեպքում օգտատերը հաստատում կամ ուղղում է արդյունքը (եթե կոդի որակը կամ տեսանելիությունը նվազել է):

Ինտեգրում գրադարանի կամ առևտրային համակարգի հետ

Հաջող ճանաչումից հետո ծրագրային սկաները ավտոմատ կերպով փոխանցում է ստացված տվյալները տեղեկատվական համակարգ՝

• Եթե գիրքն արդեն գրանցված է, կատարվում է գործողությունը կատարելու համար համապատասխան գրառման արագ որոնում (թողարկում, վերադարձ, գույքագրում):
• Նոր ժամանած գրքերը սկանավորելիս համակարգը կարող է ավտոմատ կերպով ստեղծել նոր գրառում՝ օգտագործելով կամ ներքին տեղեկատուներ, կամ արտաքին տվյալների բազաներ (օրինակ՝ հանրությանը հասանելի ISBN կատալոգներ):
• Բացի այդ, գրքի տվյալներով դաշտերը (վերնագիր, հեղինակ, հրատարակություն և այլն) կարող են լրացվել ավտոմատ կերպով։

Պահեստավորում, վերլուծություն և հետագա աշխատանք տվյալների հետ

Երբ տեղեկատվությունը գտնվում է տվյալների բազայում, բացվում են հաշվապահական և վերլուծական գործընթացների ավտոմատացման հնարավորություններ.

• Բոլոր գործարքները պահպանվում են, ինչը թույլ է տալիս հետևել յուրաքանչյուր գրքի պատմությանը. երբ է այն ստացվել, արդյոք այն տրվել է ընթերցողին, արդյոք այն մասնակցել է աուդիտի և այլն։
• Հավաքված տվյալների հիման վրա ստեղծվում են հաշվետվություններ գույքագրման, մնացորդների հեռացման, առանձին օրինակների ժողովրդականության վերլուծության վերաբերյալ։
• Տվյալների սկանավորումը կարող է դառնալ ավտոմատ սցենարների խթանիչ՝ դուրսգրումներ, ֆոնդի համալրում, աշխատակիցներին կամ ընթերցողներին ծանուցումներ ուղարկելը։

Ժամանակակից ծրագրային սկաների տեխնոլոգիական առանձնահատկությունները և առավելությունները

Ժամանակակից ծրագրային շտրիխ կոդի սկաները առանձնանում է հետևյալ տեխնոլոգիական լուծումներով՝

• Բազմաֆորմատ շտրիխ կոդի աջակցություն: Ծրագրային սկաներները կարող են ճանաչել կոդերի լայն շրջանակ, այդ թվում՝ EAN-13 (ամենատարածվածը ISBN-ի համար), QR, DataMatrix, Codabar, Code 39 և այլ ձևաչափեր:
• Պատկերի վերլուծության ինտելեկտուալ ալգորիթմներ: Ստացված պատկերները մշակելիս օգտագործվում են ուղղման և զտման մեթոդներ՝ ավտոմատ ֆոկուսավորում, թեքության ուղղում, շողքի մարում, կոնտրաստի ուժեղացում: Սա ապահովում է կայուն ճանաչում նույնիսկ կոր, քերծված, քսված կամ մասամբ վնասված կազմերի վրա:
• Բարձր արագություն:Պատկերի մշակումը և կոդի ճանաչումը կատարվում են գրեթե իրական ժամանակում, ինչը թույլ է տալիս զանգվածաբար սկանավորել գրքերը՝ առանց ուշացումների և արտադրողականության կորստի։
• Տարբեր սարքերի վրա աշխատանքի աջակցություն։ Ծրագրային սկաներները կենտրոնացած են համակարգիչների, պլանշետների, սմարթֆոնների, սկաներների, POS տերմինալների հետ ինտեգրման վրա, ինչը կարևոր է արտագնա միջոցառումների կամ մեծ գրադարաններում շարժական աշխատանքի համար։
• Կոդի ավտոմատ հայտնաբերում բարդ պայմաններում։ Ուսուցանվող ալգորիթմների և նեյրոնային ցանցերի շնորհիվ ժամանակակից լուծումները կարողանում են գտնել կոդեր պատկերի վրա նույնիսկ տեքստի, պիտակների կամ կեղտի հետ հատվելիս։
• Ճկուն ինտեգրում API-ի և SDK-ի միջոցով։ Ծրագրային սկաներների մեծ մասը կարող է ինտեգրվել ցանկացած գրադարանային, մանրածախ կամ արխիվային համակարգերի հետ՝ բաց ինտերֆեյսների շնորհիվ, ինչը նվազեցնում է ներդրման աշխատանքային ծախսերը։

Ժամանակակից շտրիխ կոդերի սկաների ծրագիրը կարևոր գործիք է ցանկացած գրադարանի կամ գրախանութի համար, որը ձգտում է ավտոմատացման, հաշվապահության թափանցիկության և սպասարկման արագության բարձրացման։ Նման ծրագրային ապահովման շնորհիվ թղթային հավաքածուների մշակումը տեղափոխվում է ժամանակակից թվային մակարդակ՝ նվազագույն ծախսերով և առավելագույն եկամտաբերությամբ։

Ծրագրային լուծման ընտրություն

Գրքերի հետ աշխատելու համար ծրագրային շտրիխ կոդի սկաներ ընտրելիս խորհուրդ է տրվում հաշվի առնել.

• Աջակցվող ստանդարտներ և կոդի ձևաչափեր
• Ճանաչման արագություն և ճշգրտություն
• Գրադարանային համակարգի հետ ինտեգրման հնարավորություններ
• Հուսալիություն և ճկունություն (աշխատանք տարբեր տեսակի տեսախցիկների և սկաներների հետ)
• Օպտիմալացում բջջային և ամպային օգտագործման սցենարների համար

Համընդհանուր լուծումները պետք է հեշտությամբ ինտեգրվեն ՏՏ ենթակառուցվածքում և աջակցեն աշխատանքը տարբեր սարքերի վրա՝ սեղանադիր համակարգիչներից մինչև բջջային հեռախոսներ: Խորհուրդ է տրվում ընտրել պարզ ինտերֆեյսով, թարմացման հնարավորությամբ և տեխնիկական աջակցությամբ ապրանքներ:

Զարգացման հեռանկարներ

Գրքերի սկանավորման տեխնոլոգիաները, որոնք օգտագործում են ծրագրային շտրիխ կոդի սկաներներ, շարունակում են արագ զարգանալ: Մոտ ապագայում 2D շտրիխ կոդերը (օրինակ՝ DataMatrix-ը և QR-ը) նախատեսվում է ավելի լայնորեն ներդնել, քանի որ դրանք կարող են պարունակել ավելի շատ տեղեկատվություն՝ հղումներ գրքերի էլեկտրոնային տարբերակներին, ծանոթագրություններ, անվտանգ նույնականացուցիչներ։

Սկաներների ինտեգրումը ամպային ծառայությունների և թվային գրադարանների հետ աճում է, ինչը թույլ կտա ավտոմատացված մուտք գործել առցանց ռեսուրսներ և ընդլայնված ծառայություններ օգտատերերի համար։ Ապագայում նախատեսվում է նաև ինտելեկտուալ գործառույթների ներդրում՝ գրքի վիճակի ավտոմատ վերլուծություն, առաջարկությունների ստեղծում, ինչպես նաև ամբողջական վերլուծությունների մշակում և գրադարանային ֆոնդերի շարժի մոնիթորինգ։

Եզրակացություն

Շտրիխ կոդերի սկանավորման ծրագրային լուծման ընտրությունը պահանջում է բազմաթիվ գործոնների ուշադիր քննարկում, ներառյալ աջակցվող ձևաչափերը, արագությունը, ինտեգրման հնարավորությունները և օգտագործման հեշտությունը։ Տեխնոլոգիաների զարգացման հեռանկարները բացում են նոր հորիզոններ ավտոմատացման, գրադարանային համակարգերի արդյունավետության բարձրացման և օգտատերերի համար սպասարկման բարելավման համար։

VintaSoft,VintaSoft Barcode .NET SDK-ի մշակողը կարող է զգալիորեն պարզեցնել գրադարանային շտրիխ կոդերի համակարգի ստեղծումը: Այս հզոր գործիքը աջակցում է ձևաչափված շտրիխ կոդերի լայն տեսականի, ապահովում է բարձր սկանավորման արագություն և ճշգրտություն և հեշտությամբ ինտեգրվում է առկա գրադարանային համակարգերի հետ: VintaSoft Barcode .NET SDK-ի միջոցով գրադարանները կկարողանան արագ և արդյունավետորեն ավտոմատացնել հաշվապահության և գրքերի սպասարկման հետ կապված բոլոր գործընթացները՝ բարելավելով ծառայության որակը և ապահովելով ռեսուրսների զգալի խնայողություն:


Ահա C# կոդ, որը ցույց է տալիս, թե ինչպես ճանաչել ISBN շտրիխ կոդը տեսախցիկից ստացված պատկերում.

/// <summary>
/// Reads barcode from a <see cref="System.Drawing.Bitmap"/>.
/// </summary>
/// <param name="bitmap">A bitmap with barcodes.</param>
public static void ReadIsbnBarcodesFromBitmap(System.Drawing.Bitmap bitmap)
{
    // create barcode reader
    using (Vintasoft.Barcode.BarcodeReader reader = new Vintasoft.Barcode.BarcodeReader())
    {
        // specify that reader must search for ISBN barcodes
        reader.Settings.ScanBarcodeTypes = Vintasoft.Barcode.BarcodeType.ISBN;

        // read barcodes from image
        Vintasoft.Barcode.IBarcodeInfo[] infos = Vintasoft.Barcode.GdiExtensions.ReadBarcodes(reader, bitmap);

        // if barcodes are not detected
        if (infos.Length == 0)
        {
            System.Console.WriteLine("No barcodes found.");
        }
        // if barcodes are detected
        else
        {
            // get information about extracted barcodes

            System.Console.WriteLine(string.Format("{0} barcodes found:", infos.Length));
            System.Console.WriteLine();
            for (int i = 0; i < infos.Length; i++)
            {
                Vintasoft.Barcode.IBarcodeInfo info = infos[i];
                System.Console.WriteLine(string.Format("[{0}:{1}]", i + 1, info.BarcodeType));
                System.Console.WriteLine(string.Format("Value:      {0}", info.Value));
                System.Console.WriteLine(string.Format("Region:     {0}", info.Region));
                System.Console.WriteLine();
            }
        }
    }
}

Ահա C# կոդ, որը ցույց է տալիս, թե ինչպես պատկերներ ստանալ DirectShow տեսախցիկից (VintaSoft Imaging .NET SDK) և ճանաչել ISBN շտրիխ կոդերը ստացված պատկերներում (VintaSoft Barcode .NET SDK) WinForms հավելվածում.

public partial class IsbnBarcodeScannerForm : Form
{
    /// <summary>
    /// The camera barcode scanner.
    /// </summary>
    ImagingCameraBarcodeScanner _cameraBarcodeScanner;

    /// <summary>
    /// Initializes a new instance of the <see cref="IsbnBarcodeScannerForm"/> class.
    /// </summary>
    public IsbnBarcodeScannerForm()
    {
        InitializeComponent();

        _cameraBarcodeScanner = new ImagingCameraBarcodeScanner();
        _cameraBarcodeScanner.BarcodeScanner.FrameScanFinished += BarcodeScanner_FrameScanFinished;
        _cameraBarcodeScanner.ScanningException += CameraBarcodeScanner_ScanningException;

        _cameraBarcodeScanner.BarcodeScanner.ScannerSettings.ScanBarcodeTypes = Vintasoft.Barcode.BarcodeType.QR;
    }

    /// <summary>
    /// Starts the capturing of images from seleced device and recognition of barcodes in captured images.
    /// </summary>
    private void startButton_Click(object sender, EventArgs e)
    {
        textBox1.Text = "Scan Barcodes Types: " + _cameraBarcodeScanner.BarcodeScanner.ScannerSettings.ScanBarcodeTypes.ToString();

        _cameraBarcodeScanner.CaptureDevice = _cameraBarcodeScanner.CaptureDevices[0];
        _cameraBarcodeScanner.StartScanning();
    }

    /// <summary>
    /// Stops the capturing of images from seleced device and recognition of barcodes in captured images.
    /// </summary>
    private void stopButton_Click(object sender, EventArgs e)
    {
        textBox1.Text = "";

        _cameraBarcodeScanner.StopScanning();
    }

    /// <summary>
    /// Shows an error.
    /// </summary>
    private void CameraBarcodeScanner_ScanningException(object sender, Vintasoft.Imaging.ExceptionEventArgs e)
    {
        MessageBox.Show(e.Exception.ToString());
    }

    /// <summary>
    /// Handles the FrameScanFinished event of the BarcodeScanner.
    /// </summary>
    private void BarcodeScanner_FrameScanFinished(object sender, Vintasoft.Barcode.FrameScanFinishedEventArgs e)
    {
        if (e.FoundBarcodes.Length > 0)
            Invoke(new ShowRecognitionResultsDelegate(ShowRecognitionResults), new object[] { e.FoundBarcodes });
    }

    /// <summary>
    /// Shows barcode recognition results.
    /// </summary>
    private void ShowRecognitionResults(Vintasoft.Barcode.IBarcodeInfo[] barcodes)
    {
        StringBuilder result = new StringBuilder();

        foreach (Vintasoft.Barcode.IBarcodeInfo barcode in barcodes)
            result.AppendLine(string.Format("{0}: {1}", barcode.BarcodeType, barcode.Value));

        // show barcode recognition in text box
        textBox1.Text = result.ToString();
    }

    delegate void ShowRecognitionResultsDelegate(Vintasoft.Barcode.IBarcodeInfo[] barcodeInfo);
}


/// <summary>
/// Allows to capture images from DirectShow camera (VintaSoft Imaging .NET SDK) and recognize barcodes in captured images (VintaSoft Barcode .NET SDK).
/// </summary>
public class ImagingCameraBarcodeScanner : IDisposable
{

    #region Fields

    /// <summary>
    /// Monitor for capture devices.
    /// </summary>
    Vintasoft.Imaging.Media.ImageCaptureDevicesMonitor _captureDevicesMonitor;

    /// <summary>
    /// Image capture source for barcode recognition.
    /// </summary>
    Vintasoft.Imaging.Media.ImageCaptureSource _imageCaptureSource;

    #endregion



    #region Constructors

    /// <summary>
    /// Initializes a new instance of the <see cref="ImagingCameraBarcodeScanner"/> class.
    /// </summary>
    public ImagingCameraBarcodeScanner()
    {
        _barcodeScanner = new Vintasoft.Barcode.CameraBarcodeScanner();
        _barcodeScanner.FrameScanException += BarcodeScanner_FrameScanException;
        _barcodeScanner.ScannerSettings.ScanBarcodeTypes = Vintasoft.Barcode.BarcodeType.ISBN;

        _captureDevicesMonitor = new Vintasoft.Imaging.Media.ImageCaptureDevicesMonitor();
        _captureDevicesMonitor.CaptureDevicesChanged += CaptureDevicesMonitor_CaptureDevicesChanged;

        if (!Vintasoft.Imaging.ImagingEnvironment.IsInDesignMode)
            _captureDevicesMonitor.Start();

        _imageCaptureSource = new Vintasoft.Imaging.Media.ImageCaptureSource();
        _imageCaptureSource.CaptureCompleted += ImageCaptureSource_CaptureCompleted;

    }

    #endregion



    #region Properties

    Vintasoft.Imaging.Media.ImageCaptureDevice _captureDevice;
    /// <summary>
    /// Gets or sets current capture device.
    /// </summary>
    public Vintasoft.Imaging.Media.ImageCaptureDevice CaptureDevice
    {
        get
        {
            return _captureDevice;
        }
        set
        {
            if (_captureDevice != value)
            {
                _captureDevice = value;

                UpdateCapureFormats();
            }
        }
    }

    ReadOnlyCollection<Vintasoft.Imaging.Media.ImageCaptureFormat> _captureFormats = null;
    /// <summary>
    /// Gets the available capture formats of current capture device.
    /// </summary>
    /// <seealso cref="CaptureDevice"/>
    public ReadOnlyCollection<Vintasoft.Imaging.Media.ImageCaptureFormat> CaptureFormats
    {
        get
        {
            return _captureFormats;
        }
    }

    /// <summary>
    /// Gets available capture devices.
    /// </summary>
    public ReadOnlyCollection<Vintasoft.Imaging.Media.ImageCaptureDevice> CaptureDevices
    {
        get
        {
            return Vintasoft.Imaging.Media.ImageCaptureDeviceConfiguration.GetCaptureDevices();
        }
    }

    Vintasoft.Barcode.CameraBarcodeScanner _barcodeScanner;
    /// <summary>
    /// Gets the barcode scanner.
    /// </summary>
    public Vintasoft.Barcode.CameraBarcodeScanner BarcodeScanner
    {
        get
        {
            return _barcodeScanner;
        }
    }

    /// <summary>
    /// Gets a value indicating whether barcode scanning is started.
    /// </summary>
    public bool IsStarted
    {
        get
        {
            return _imageCaptureSource.State == Vintasoft.Imaging.Media.ImageCaptureState.Started;
        }
    }

    #endregion



    #region Methods

    #region PUBLIC

    /// <summary>
    /// Starts the capturing of images from seleced device and recognition of barcodes in captured images.
    /// </summary>
    public void StartScanning()
    {
        try
        {
            if (CaptureDevice == null)
                throw new ArgumentNullException("CaptureDevice");

            if (CaptureFormats == null || CaptureFormats.Count == 0)
                throw new ArgumentNullException("CaptureFormats");

            if (_imageCaptureSource.State != Vintasoft.Imaging.Media.ImageCaptureState.Started)
            {
                if (CaptureDevice.DesiredFormat == null)
                    CaptureDevice.DesiredFormat = CaptureFormats[0];

                _barcodeScanner.StartScanning();

                _imageCaptureSource.CaptureDevice = _captureDevice;
                _imageCaptureSource.Start();
                _imageCaptureSource.CaptureAsync();

                OnScanningStart(EventArgs.Empty);
            }
        }
        catch (Exception ex)
        {
            OnScanningException(new Vintasoft.Imaging.ExceptionEventArgs(ex));
        }
    }

    /// <summary>
    /// Stops the capturing of images from seleced device and recognition of barcodes in captured images.
    /// </summary>
    public void StopScanning()
    {
        try
        {
            if (_imageCaptureSource.State != Vintasoft.Imaging.Media.ImageCaptureState.Stopped)
            {
                _barcodeScanner.StopScanning();
                _imageCaptureSource.Stop();

                OnScanningStop(EventArgs.Empty);
            }
        }
        catch (Exception ex)
        {
            OnScanningException(new Vintasoft.Imaging.ExceptionEventArgs(ex));
        }
    }

    /// <summary>
    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
    /// </summary>
    public void Dispose()
    {
        _captureDevicesMonitor.CaptureDevicesChanged -= CaptureDevicesMonitor_CaptureDevicesChanged;
        _barcodeScanner.BarcodeReader.Dispose();
    }

    #endregion


    #region PROTECTED

    /// <summary>
    /// Raises the <see cref="CaptureDevicesChanged" /> event.
    /// </summary>
    /// <param name="args">The <see cref="ImageCaptureDevicesChangedEventArgs"/> instance containing the event data.</param>
    protected virtual void OnCaptureDevicesChanged(Vintasoft.Imaging.Media.ImageCaptureDevicesChangedEventArgs args)
    {
        if (CaptureDevicesChanged != null)
            CaptureDevicesChanged(this, args);
    }

    /// <summary>
    /// Raises the <see cref="ScanningException" /> event.
    /// </summary>
    /// <param name="args">The <see cref="ExceptionEventArgs"/> instance containing the event data.</param>
    protected virtual void OnScanningException(Vintasoft.Imaging.ExceptionEventArgs args)
    {
        if (ScanningException != null)
            ScanningException(this, args);
    }

    /// <summary>
    /// Raises the <see cref="ScanningStart" /> event.
    /// </summary>
    /// <param name="args">The <see cref="EventArgs"/> instance containing the event data.</param>
    protected virtual void OnScanningStart(EventArgs args)
    {
        if (ScanningStart != null)
            ScanningStart(this, args);
    }

    /// <summary>
    /// Raises the <see cref="ScanningStop" /> event.
    /// </summary>
    /// <param name="args">The <see cref="EventArgs"/> instance containing the event data.</param>
    protected virtual void OnScanningStop(EventArgs args)
    {
        if (ScanningStop != null)
            ScanningStop(this, args);
    }

    #endregion


    #region PRIVATE

    /// <summary>
    /// Handles the FrameScanException event of the BarcodeScanner control.
    /// </summary>
    /// <param name="sender">The source of the event.</param>
    /// <param name="e">The <see cref="Vintasoft.Barcode.FrameScanExceptionEventArgs"/> instance containing the event data.</param>
    private void BarcodeScanner_FrameScanException(object sender, Vintasoft.Barcode.FrameScanExceptionEventArgs e)
    {
        OnScanningException(new Vintasoft.Imaging.ExceptionEventArgs(e.Exception));
    }

    /// <summary>
    /// Handles the CaptureCompleted event of the ImageCaptureSource.
    /// </summary>
    /// <param name="sender">The source of the event.</param>
    /// <param name="e">The <see cref="ImageCaptureCompletedEventArgs"/> instance containing the event data.</param>
    private void ImageCaptureSource_CaptureCompleted(object sender, Vintasoft.Imaging.Media.ImageCaptureCompletedEventArgs e)
    {
        try
        {
            // get captured image
            Vintasoft.Imaging.VintasoftImage image = e.GetCapturedImage();

            // recognize barcodes from captured image
            using (Vintasoft.Imaging.VintasoftBitmap bitmap = image.GetAsVintasoftBitmap())
                _barcodeScanner.ScanFrame(bitmap);

            // if image capturing is started
            if (_imageCaptureSource.State == Vintasoft.Imaging.Media.ImageCaptureState.Started)
            {
                // capture next image
                _imageCaptureSource.CaptureAsync();
            }
        }
        catch (Exception ex)
        {
            OnScanningException(new Vintasoft.Imaging.ExceptionEventArgs(ex));
        }
    }

    /// <summary>
    /// Handles the CaptureDevicesChanged event of the CaptureDevicesMonitor.
    /// </summary>
    /// <param name="sender">The source of the event.</param>
    /// <param name="e">The <see cref="ImageCaptureDevicesChangedEventArgs"/> instance containing the event data.</param>
    private void CaptureDevicesMonitor_CaptureDevicesChanged(object sender, Vintasoft.Imaging.Media.ImageCaptureDevicesChangedEventArgs e)
    {
        if (Array.IndexOf(e.RemovedDevices, CaptureDevice) >= 0)
        {
            StopScanning();
        }

        OnCaptureDevicesChanged(e);
    }

    /// <summary>
    /// Updates the capture formats.
    /// </summary>
    private void UpdateCapureFormats()
    {
        Vintasoft.Imaging.Media.ImageCaptureDevice device = CaptureDevice;
        if (device == null || device.SupportedFormats == null)
        {
            _captureFormats = null;
        }
        else
        {
            List<Vintasoft.Imaging.Media.ImageCaptureFormat> captureFormats = new List<Vintasoft.Imaging.Media.ImageCaptureFormat>();

            List<uint> imageCaptureFormatSizes = new List<uint>();
            for (int i = 0; i < device.SupportedFormats.Count; i++)
            {
                // if format has bit depth less or equal than 12 bit
                if (device.SupportedFormats[i].BitsPerPixel <= 12)
                {
                    // ignore formats with bit depth less or equal than 12 bit because they may cause issues on Windows 8
                    continue;
                }

                uint imageCaptureFormatSize = (uint)(device.SupportedFormats[i].Width | (device.SupportedFormats[i].Height << 16));
                if (!imageCaptureFormatSizes.Contains(imageCaptureFormatSize))
                {
                    imageCaptureFormatSizes.Add(imageCaptureFormatSize);

                    captureFormats.Add(device.SupportedFormats[i]);
                }
            }
            _captureFormats = captureFormats.AsReadOnly();
        }
    }

    #endregion

    #endregion



    #region Events

    /// <summary>
    /// Occurs when barcode scanning is started.
    /// </summary>
    public event EventHandler ScanningStart;

    /// <summary>
    /// Occurs when barcode scanning is stopped.
    /// </summary>
    public event EventHandler ScanningStop;

    /// <summary>
    /// Occurs when barcode scanning error occurs.
    /// </summary>
    public event EventHandler<Vintasoft.Imaging.ExceptionEventArgs> ScanningException;

    /// <summary>
    /// Occurs when <see cref="CaptureDevices"/> property is changed.
    /// </summary>
    public event EventHandler<Vintasoft.Imaging.Media.ImageCaptureDevicesChangedEventArgs> CaptureDevicesChanged;

    #endregion

}