Escaneie imagens usando um aplicativo .NET de console para Windows e Linux

TWAIN é um protocolo e interface (API) padrão que define a interação entre um programa e um scanner de imagens. O padrão TWAIN está sendo desenvolvido pelo Grupo de Trabalho TWAIN. A versão 1 do padrão TWAIN define a interação com scanners de imagem para Windows. A versão 2 do padrão TWAIN define a interação com scanners de imagem para Windows, macOS e Linux.
O padrão TWAIN é o padrão mais popular para scanners de imagem no Windows. Quase todos os scanners de imagem possuem um driver TWAIN para uso no Windows.
O padrão TWAIN não é tão popular no Linux e nossa pesquisa (no início de 2024) mostrou que apenas a Kodak fornece drivers TWAIN para usar seus scanners de imagem no Linux.

A API SANE é uma interface de programação de aplicativos (API) que fornece acesso padronizado a dispositivos de digitalização de imagens raster (scanners de mesa, scanners portáteis, etc.). A API SANE é de domínio público e está aberta à discussão e ao desenvolvimento. A API SANE é a API de scanner de imagem mais popular para Linux.
Muitos fabricantes de scanners criaram drivers SANE para seus scanners de imagem. Existem também drivers SANE criados pela comunidade SANE. Como resultado, quase todos os scanners de imagem modernos possuem um driver SANE que permite usar o dispositivo no Linux.

O VintaSoft Twain .NET SDK é a biblioteca profissional de digitalização de imagens que permite controlar scanners TWAIN ou SANE e adquirir imagens em .NET.Aplicativo .NET para Windows e Linux. As imagens adquiridas podem ser pré-processadas e salvas em um arquivo ou enviadas para um servidor HTTP(S) ou FTP.

O VintaSoft Twain .NET SDK fornece a API VintaSoft TWAIN .NET para trabalhar com dispositivos TWAIN no Windows e no Linux. Além disso, o VintaSoft Twain .NET SDK fornece a API VintaSoft SANE .NET para trabalhar com dispositivos SANE no Linux. Para obter informações detalhadas sobre as APIs VintaSoft TWAIN .NET e VintaSoft SANE .NET, consulte a documentação para desenvolvedores .NET aqui: https://www.vintasoft.com/docs/vstwain-dotnet/

Aqui está o código C# que mostra como adquirir imagens de um scanner de imagens TWAIN no Windows e no Linux:

/// <summary>
/// Synchronously acquire images images from TWAIN scanner.
/// </summary>
public void SynchronouslyAcquireImagesFromTwainScanner()
{
    try
    {
        using (Vintasoft.Twain.DeviceManager deviceManager = new Vintasoft.Twain.DeviceManager())
        {
            // open the device manager
            deviceManager.Open();

            // get reference to the default device
            Vintasoft.Twain.Device device = deviceManager.DefaultDevice;

            // open the device
            device.Open();

            // set acquisition parameters
            device.TransferMode = Vintasoft.Twain.TransferMode.Memory;
            device.ShowUI = false;
            device.DisableAfterAcquire = true;
            device.PixelType = Vintasoft.Twain.PixelType.BW;

            // create directory for PDF document
            string directoryForImages = System.IO.Path.GetDirectoryName(System.IO.Directory.GetCurrentDirectory());
            directoryForImages = System.IO.Path.Combine(directoryForImages, "Images");
            if (!System.IO.Directory.Exists(directoryForImages))
                System.IO.Directory.CreateDirectory(directoryForImages);

            string pdfFilename = System.IO.Path.Combine(directoryForImages, "multipage.pdf");

            // acquire image(s) from the device
            Vintasoft.Twain.AcquireModalState acquireModalState = Vintasoft.Twain.AcquireModalState.None;
            int imageIndex = 0;
            do
            {
                acquireModalState = device.AcquireModal();
                switch (acquireModalState)
                {
                    case Vintasoft.Twain.AcquireModalState.ImageAcquired:
                        // save image to file
                        device.AcquiredImage.Save(pdfFilename);
                        // dispose acquired image
                        device.AcquiredImage.Dispose();
                        // output current state
                        System.Console.WriteLine(string.Format("Image{0} is saved.", imageIndex++));
                        break;

                    case Vintasoft.Twain.AcquireModalState.ScanCompleted:
                        // output current state
                        System.Console.WriteLine("Scan completed.");
                        break;

                    case Vintasoft.Twain.AcquireModalState.ScanCanceled:
                        // output current state
                        System.Console.WriteLine("Scan canceled.");
                        break;

                    case Vintasoft.Twain.AcquireModalState.ScanFailed:
                        // output current state
                        System.Console.WriteLine(string.Format("Scan failed: {0}", device.ErrorString));
                        break;
                }
            }
            while (acquireModalState != Vintasoft.Twain.AcquireModalState.None);

            // close the device
            device.Close();

            // close the device manager
            deviceManager.Close();
        }
    }
    catch (Vintasoft.Twain.TwainException ex)
    {
        System.Console.WriteLine("Error: " + ex.Message);
    }

    System.Console.ReadLine();
}

Aqui está o código C# que mostra como adquirir imagens de um scanner de imagens SANE no Linux:

/// <summary>
/// Synchronously acquire images images from SANE scanner.
/// </summary>
public void SynchronouslyAcquireImagesFromSaneScanner()
{
    // create SANE device manager
    using (Vintasoft.Sane.SaneLocalDeviceManager deviceManager = new Vintasoft.Sane.SaneLocalDeviceManager())
    {
        // open SANE device manager
        deviceManager.Open();

        // get count of SANE devices
        int deviceCount = deviceManager.Devices.Count;
        if (deviceCount == 0)
        {
            System.Console.WriteLine("Devices are not found.");
            return;
        }

        // select the first SANE device
        Vintasoft.Sane.SaneLocalDevice device = deviceManager.Devices[0];

        // open SANE device
        device.Open();

        int imageIndex = 0;
        Vintasoft.Sane.SaneAcquiredImage acquiredImage;
        do
        {
            try
            {
                // acquire image from SANE device
                acquiredImage = device.AcquireImageSync();
                // if image is received
                if (acquiredImage != null)
                {
                    imageIndex++;
                    string filename = string.Format("scannedImage-{0}.png", imageIndex);
                    if (System.IO.File.Exists(filename))
                        System.IO.File.Delete(filename);

                    acquiredImage.Save(filename);

                    System.Console.WriteLine(string.Format("Acquired image is saved to a file '{0}'.", filename));
                }
                // if image is not received
                else
                {
                    System.Console.WriteLine("Scan is completed.");
                    break;
                }
            }
            catch (System.Exception ex)
            {
                System.Console.WriteLine(string.Format("Scan is failed: {0}", ex.Message));
                break;
            }
        }
        // while device has more images to scan
        while (device.HasMoreImagesToScan);

        // close SANE device
        device.Close();

        // close SANE device manager
        deviceManager.Close();
    }

    System.Console.ReadLine();
}