扫描仪对接（C#）(Twain)

前言

对接扫描仪的几种方式：

TWAIN 此为大多数扫描仪基础协议。是C++语言写的底层dll，对.NET来说通过DLLImport来扩展使用。

此协议是很底层的协议，并没有经过.NET封装。所以要了解其机制才能更好的来开发。

WIA .NET已经封装了支持该协议的dll，但是WIA一次只能扫描一张。

相关文章：

https://blog.csdn.net/younghaiqing/article/details/78431454

https://www.likecs.com/show-503057.html

Twain方式1

TwainWin32.cs

namespace Ztwain
{
    using System;
    using System.Runtime.InteropServices;

    /// <summary>
    /// Imports from Windows32
    /// </summary>
    public static class TwainWin32
    {
        [DllImport("kernel32.dll", ExactSpelling = true)]
        public static extern IntPtr GlobalLock(IntPtr handle);

        [DllImport("kernel32.dll", ExactSpelling = true)]
        public static extern IntPtr GlobalUnlock(IntPtr handle);

        [DllImport("kernel32.dll", ExactSpelling = true)]
        public static extern IntPtr GlobalAlloc(int flags, int size);

        [DllImport("kernel32.dll", ExactSpelling = true)]
        public static extern IntPtr GlobalFree(IntPtr handle);

        [DllImport("user32")]
        public static extern bool PostMessage(IntPtr hwnd, uint msg, IntPtr wparam, IntPtr lparam);

        [DllImport("user32")]
        public static extern uint RegisterWindowMessage(string lpString);

        [DllImport("user32")]
        public static extern bool SendMessage(IntPtr hwnd, uint msg, IntPtr wparam, IntPtr lparam);

        [DllImport("user32.dll")]
        public static extern int FindWindow(string lpClassName, string lpWindowName);

        [DllImport("user32.dll", ExactSpelling = true)]
        public static extern int GetMessagePos();

        [DllImport("user32.dll", ExactSpelling = true)]
        public static extern int GetMessageTime();

        [DllImport("gdi32.dll", ExactSpelling = true)]
        public static extern int GetDeviceCaps(IntPtr hDc, int nIndex);

        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr CreateDC(
            string szdriver,
            string szdevice,
            string szoutput,
            IntPtr devmode
        );

        [DllImport("gdi32.dll", ExactSpelling = true)]
        public static extern bool DeleteDC(IntPtr hdc);

        [StructLayout(LayoutKind.Sequential, Pack = 2)]
        public class Bitmapinfoheader
        {
            public uint biSize;
            public int biWidth;
            public int biHeight;
            public ushort biPlanes;
            public ushort biBitCount;
            public uint biCompression;
            public uint biSizeImage;
            public int biXPelsPerMeter;
            public int biYPelsPerMeter;
            public uint biClrUsed;
            public uint biClrImportant;
        }
    }
}

TwainDefs.cs

namespace Ztwain
{
    using System;
    using System.Runtime.InteropServices;

    public class TwProtocol
    { // TWON_PROTOCOL...
        public const short MAJOR = 1;
        public const short MINOR = 9;
    }

    [Flags]
    internal enum TwDg : short
    {
        // DG_.....
        Control = 0x0001,
        Image = 0x0002,
        Audio = 0x0004,
    }

    internal enum TwDat : short
    {
        // DAT_....
        Null = 0x0000,
        Capability = 0x0001,
        Event = 0x0002,
        Identity = 0x0003,
        Parent = 0x0004,
        PendingXfers = 0x0005,
        SetupMemXfer = 0x0006,
        SetupFileXfer = 0x0007,
        Status = 0x0008,
        UserInterface = 0x0009,
        XferGroup = 0x000a,
        TwunkIdentity = 0x000b,
        CustomDsData = 0x000c,
        DeviceEvent = 0x000d,
        FileSystem = 0x000e,
        PassThru = 0x000f,

        ImageInfo = 0x0101,
        ImageLayout = 0x0102,
        ImageMemXfer = 0x0103,
        ImageNativeXfer = 0x0104,
        ImageFileXfer = 0x0105,
        CieColor = 0x0106,
        GrayResponse = 0x0107,
        RgbResponse = 0x0108,
        JpegCompression = 0x0109,
        Palette8 = 0x010a,
        ExtImageInfo = 0x010b,

        SetupFileXfer2 = 0x0301,
    }

    internal enum TwMsg : short
    {
        // MSG_.....
        Null = 0x0000,
        Get = 0x0001,
        GetCurrent = 0x0002,
        GetDefault = 0x0003,
        GetFirst = 0x0004,
        GetNext = 0x0005,
        Set = 0x0006,
        Reset = 0x0007,
        QuerySupport = 0x0008,

        XFerReady = 0x0101,
        CloseDsReq = 0x0102,
        CloseDsok = 0x0103,
        DeviceEvent = 0x0104,

        CheckStatus = 0x0201,

        OpenDsm = 0x0301,
        CloseDsm = 0x0302,

        OpenDs = 0x0401,
        CloseDs = 0x0402,
        UserSelect = 0x0403,

        DisableDs = 0x0501,
        EnableDs = 0x0502,
        EnableDsuiOnly = 0x0503,

        ProcessEvent = 0x0601,

        EndXfer = 0x0701,
        StopFeeder = 0x0702,

        ChangeDirectory = 0x0801,
        CreateDirectory = 0x0802,
        Delete = 0x0803,
        FormatMedia = 0x0804,
        GetClose = 0x0805,
        GetFirstFile = 0x0806,
        GetInfo = 0x0807,
        GetNextFile = 0x0808,
        Rename = 0x0809,
        Copy = 0x080A,
        AutoCaptureDir = 0x080B,

        PassThru = 0x0901,
    }

    internal enum TwRc : short
    {
        // TWRC_....
        Success = 0x0000,
        Failure = 0x0001,
        CheckStatus = 0x0002,
        Cancel = 0x0003,
        DsEvent = 0x0004,
        NotDsEvent = 0x0005,
        XferDone = 0x0006,
        EndOfList = 0x0007,
        InfoNotSupported = 0x0008,
        DataNotAvailable = 0x0009,
    }

    internal enum TwCc : short
    {
        // TWCC_....
        Success = 0x0000,
        Bummer = 0x0001,
        LowMemory = 0x0002,
        NoDs = 0x0003,
        MaxConnections = 0x0004,
        OperationError = 0x0005,
        BadCap = 0x0006,
        BadProtocol = 0x0009,
        BadValue = 0x000a,
        SeqError = 0x000b,
        BadDest = 0x000c,
        CapUnsupported = 0x000d,
        CapBadOperation = 0x000e,
        CapSeqError = 0x000f,
        Denied = 0x0010,
        FileExists = 0x0011,
        FileNotFound = 0x0012,
        NotEmpty = 0x0013,
        PaperJam = 0x0014,
        PaperDoubleFeed = 0x0015,
        FileWriteError = 0x0016,
        CheckDeviceOnline = 0x0017,
    }

    internal enum TwOn : short
    { // TWON_....
        Array = 0x0003,
        Enum = 0x0004,
        One = 0x0005,
        Range = 0x0006,
        DontCare = -1,
    }

    internal enum TwType : short
    { // TWTY_....
        Int8 = 0x0000,
        Int16 = 0x0001,
        Int32 = 0x0002,
        UInt8 = 0x0003,
        UInt16 = 0x0004,
        UInt32 = 0x0005,
        Bool = 0x0006,
        Fix32 = 0x0007,
        Frame = 0x0008,
        Str32 = 0x0009,
        Str64 = 0x000a,
        Str128 = 0x000b,
        Str255 = 0x000c,
        Str1024 = 0x000d,
        Str512 = 0x000e,
    }

    internal enum TwCap
    {
        XRes = 0x1118, // ICAP_XRES (水平分辨率)
        YRes = 0x1119, // ICAP_YRES (垂直分辨率)
        XferCount = 0x0001, // CAP_XFERCOUNT
        Compression = 0x0100, // ICAP_...
        PixelType = 0x0101,
        Units = 0x0102,
        XferMech = 0x0103,
        CapDuplexenabled = 0x1013, //单双面		  类型TwType.Bool
    }

    // ------------------- STRUCTS --------------------------------------------

    [StructLayout(LayoutKind.Sequential, Pack = 2, CharSet = CharSet.Ansi)]
    internal class TwIdentity
    { // TW_IDENTITY
        public IntPtr Id;
        public TwVersion Version;
        public short ProtocolMajor;
        public short ProtocolMinor;
        public int SupportedGroups;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 34)]
        public string Manufacturer;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 34)]
        public string ProductFamily;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 34)]
        public string ProductName;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 2, CharSet = CharSet.Ansi)]
    internal struct TwVersion
    { // TW_VERSION
        public short MajorNum;
        public short MinorNum;
        public short Language;
        public short Country;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 34)]
        public string Info;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 2)]
    internal class TwUserInterface
    { // TW_USERINTERFACE
        public short ShowUI; // bool is strictly 32 bit, so use short
        public short ModalUI;
        public IntPtr ParentHand;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 2)]
    internal class TwStatus
    { // TW_STATUS
        public short ConditionCode; // TwCC
        public short Reserved;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 2)]
    internal struct TwEvent
    { // TW_EVENT
        public IntPtr EventPtr;
        public short Message;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 2)]
    internal class TwImageInfo
    { // TW_IMAGEINFO
        public int XResolution;
        public int YResolution;
        public int ImageWidth;
        public int ImageLength;
        public short SamplesPerPixel;

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public short[] BitsPerSample;

        public short BitsPerPixel;
        public short Planar;
        public short PixelType;
        public short Compression;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 2)]
    internal class TwPendingXfers
    { // TW_PENDINGXFERS
        public short Count;
        public int EOJ;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 2)]
    internal struct TwFix32
    { // TW_FIX32
        public short Whole;
        public ushort Frac;

        public float ToFloat()
        {
            return Whole + (Frac / 65536.0f);
        }

        public void FromFloat(float f)
        {
            int i = (int)((f * 65536.0f) + 0.5f);
            Whole = (short)(i >> 16);
            Frac = (ushort)(i & 0x0000ffff);
        }
    }

    [StructLayout(LayoutKind.Sequential, Pack = 2)]
    internal class TwCapability
    { // TW_CAPABILITY
        public TwCapability(TwCap cap)
        {
            Cap = (short)cap;
            ConType = -1;
        }

        public TwCapability(TwCap cap, short sval)
        {
            Cap = (short)cap;
            ConType = (short)TwOn.One;
            Handle = TwainWin32.GlobalAlloc(0x42, 6);
            IntPtr pv = TwainWin32.GlobalLock(Handle);
            Marshal.WriteInt16(pv, 0, (short)TwType.Int16);
            Marshal.WriteInt32(pv, 2, sval);
            TwainWin32.GlobalUnlock(Handle);
        }

        ~TwCapability()
        {
            if (Handle != IntPtr.Zero)
                TwainWin32.GlobalFree(Handle);
        }

        public short Cap;
        public short ConType;
        public IntPtr Handle;
    }
}

TwainLib.cs

namespace Ztwain
{
    using System;
    using System.Runtime.InteropServices;
    using System.Windows.Forms;

    public enum TwainCommand
    {
        Not = -1,
        Null = 0,
        TransferReady = 1,
        CloseRequest = 2,
        CloseOk = 3,
        DeviceEvent = 4,
    }

    public delegate void ProductNameHandler(string productName);

    public class Twain
    {
        private const short COUNTRY_USA = 1;
        private const short LANGUAGE_USA = 13;
        private readonly ProductNameHandler _productNameHandler;
        private bool _isOpenDs;

        public Twain(ProductNameHandler handler)
        {
            _appid = new TwIdentity();
            _appid.Id = IntPtr.Zero;
            _appid.Version.MajorNum = 1;
            _appid.Version.MinorNum = 1;
            _appid.Version.Language = LANGUAGE_USA;
            _appid.Version.Country = COUNTRY_USA;
            _appid.Version.Info = "Hack 1";
            _appid.ProtocolMajor = TwProtocol.MAJOR;
            _appid.ProtocolMinor = TwProtocol.MINOR;
            _appid.SupportedGroups = (int)(TwDg.Image | TwDg.Control);
            _appid.Manufacturer = "NETMaster";
            _appid.ProductFamily = "Freeware";
            _appid.ProductName = "Hack";

            _srcds = new TwIdentity();
            _srcds.Id = IntPtr.Zero;

            _evtmsg.EventPtr = Marshal.AllocHGlobal(Marshal.SizeOf(_winmsg));
            _productNameHandler = handler;
        }

        ~Twain()
        {
            Marshal.FreeHGlobal(_evtmsg.EventPtr);
        }

        public void Init(IntPtr hwndp)
        {
            Finish();
            TwRc rc = DSMparent(
                _appid,
                IntPtr.Zero,
                TwDg.Control,
                TwDat.Parent,
                TwMsg.OpenDsm,
                ref hwndp
            );
            if (rc == TwRc.Success)
            {
                rc = DSMident(
                    _appid,
                    IntPtr.Zero,
                    TwDg.Control,
                    TwDat.Identity,
                    TwMsg.GetDefault,
                    _srcds
                );
                if (rc == TwRc.Success)
                    _hwnd = hwndp;
                else
                    DSMparent(
                        _appid,
                        IntPtr.Zero,
                        TwDg.Control,
                        TwDat.Parent,
                        TwMsg.CloseDsm,
                        ref hwndp
                    );
            }

            if (_productNameHandler != null)
            {
                _productNameHandler(_srcds.ProductName);
            }
        }

        public void Select()
        {
            CloseDs();
            if (_appid.Id == IntPtr.Zero)
            {
                Init(_hwnd);
                if (_appid.Id == IntPtr.Zero)
                    return;
            }

            DSMident(_appid, IntPtr.Zero, TwDg.Control, TwDat.Identity, TwMsg.UserSelect, _srcds);
            if (_productNameHandler != null)
            {
                _productNameHandler(_srcds.ProductName);
            }
        }

        public void Acquire()
        {
            Acquire(true);
        }

        public void Acquire(bool showUi)
        {
            CloseDs();
            if (_appid.Id == IntPtr.Zero)
            {
                Init(_hwnd);
                if (_appid.Id == IntPtr.Zero)
                    return;
            }
            TwRc rc = DSMident(
                _appid,
                IntPtr.Zero,
                TwDg.Control,
                TwDat.Identity,
                TwMsg.OpenDs,
                _srcds
            );
            if (rc != TwRc.Success)
                return;

            _isOpenDs = true;
            // TwCapability cap = new TwCapability(TwCap.XferCount, 1);
            // rc = DScap(
            //     _appid,
            //     _srcds,
            //     TwDg.Control,
            //     TwDat.Capability,
            //     TwMsg.Set,
            //     cap
            // );
            // Console.WriteLine(rc == TwRc.Success ? @"传输的图像数量 设置成功" : @"传输的图像数量 设置失败");

            //单面,双面
            TwCapability cap2 = new TwCapability(TwCap.CapDuplexenabled, 1); //0单面,1双面
            TwRc rc2 = DScap(_appid, _srcds, TwDg.Control, TwDat.Capability, TwMsg.Set, cap2);
            Console.WriteLine(rc2 == TwRc.Success ? @"双面扫描 设置成功" : @"双面扫描 设置失败");
            if (rc2 != TwRc.Success)
            {
                CloseDs();
                return;
            }

            // 设置分辨率
            short xyResolution = 200; // 设置为 200 DPI
            TwCapability capXRes = new TwCapability(TwCap.XRes, xyResolution);
            TwRc rcXRes = DScap(_appid, _srcds, TwDg.Control, TwDat.Capability, TwMsg.Set, capXRes);
            TwCapability capYRes = new TwCapability(TwCap.YRes, xyResolution);
            TwRc rcYRes = DScap(_appid, _srcds, TwDg.Control, TwDat.Capability, TwMsg.Set, capYRes);
            // 检查返回值
            if (rcXRes != TwRc.Success || rcYRes != TwRc.Success)
            {
                Console.WriteLine(@"分辨率 设置失败");
            }
            else
            {
                Console.WriteLine(@"分辨率 设置成功");
            }
            TwUserInterface guif = new TwUserInterface
            {
                ShowUI = (short)(showUi ? 1 : 0),
                ModalUI = 0,
                ParentHand = _hwnd,
            };
            rc = DSuserif(_appid, _srcds, TwDg.Control, TwDat.UserInterface, TwMsg.EnableDs, guif);
            if (rc != TwRc.Success)
            {
                CloseDs();
            }
        }

        public void TransferPictures(Action<IntPtr> picAction)
        {
            if (_srcds.Id == IntPtr.Zero)
                return;

            TwPendingXfers pxfr = new TwPendingXfers();

            do
            {
                pxfr.Count = 0;
                IntPtr hbitmap = IntPtr.Zero;
                TwImageInfo iinf = new TwImageInfo();
                TwRc rc = DSiinf(_appid, _srcds, TwDg.Image, TwDat.ImageInfo, TwMsg.Get, iinf);
                if (rc != TwRc.Success)
                {
                    CloseDs();
                    return;
                }
                rc = DSixfer(
                    _appid,
                    _srcds,
                    TwDg.Image,
                    TwDat.ImageNativeXfer,
                    TwMsg.Get,
                    ref hbitmap
                );
                if (rc != TwRc.XferDone)
                {
                    CloseDs();
                    return;
                }

                rc = DSpxfer(_appid, _srcds, TwDg.Control, TwDat.PendingXfers, TwMsg.EndXfer, pxfr);
                if (rc != TwRc.Success)
                {
                    CloseDs();
                    return;
                }

                picAction(hbitmap);
            } while (pxfr.Count != 0);

            DSpxfer(_appid, _srcds, TwDg.Control, TwDat.PendingXfers, TwMsg.Reset, pxfr);
        }

        public TwainCommand PassMessage(ref Message m)
        {
            if (_srcds.Id == IntPtr.Zero)
                return TwainCommand.Not;

            int pos = TwainWin32.GetMessagePos();

            _winmsg.hwnd = m.HWnd;
            _winmsg.message = m.Msg;
            _winmsg.wParam = m.WParam;
            _winmsg.lParam = m.LParam;
            _winmsg.time = TwainWin32.GetMessageTime();
            _winmsg.x = (short)pos;
            _winmsg.y = (short)(pos >> 16);

            Marshal.StructureToPtr(_winmsg, _evtmsg.EventPtr, false);
            _evtmsg.Message = 0;
            TwRc rc = DSevent(
                _appid,
                _srcds,
                TwDg.Control,
                TwDat.Event,
                TwMsg.ProcessEvent,
                ref _evtmsg
            );
            if (rc == TwRc.NotDsEvent)
                return TwainCommand.Not;
            if (_evtmsg.Message == (short)TwMsg.XFerReady)
                return TwainCommand.TransferReady;
            if (_evtmsg.Message == (short)TwMsg.CloseDsReq)
                return TwainCommand.CloseRequest;
            if (_evtmsg.Message == (short)TwMsg.CloseDsok)
                return TwainCommand.CloseOk;
            if (_evtmsg.Message == (short)TwMsg.DeviceEvent)
                return TwainCommand.DeviceEvent;

            return TwainCommand.Null;
        }

        public void CloseDs()
        {
            if (_srcds.Id != IntPtr.Zero)
            {
                TwUserInterface guif = new TwUserInterface();
                DSuserif(_appid, _srcds, TwDg.Control, TwDat.UserInterface, TwMsg.DisableDs, guif);
                if (_isOpenDs)
                {
                    DSMident(
                        _appid,
                        IntPtr.Zero,
                        TwDg.Control,
                        TwDat.Identity,
                        TwMsg.CloseDs,
                        _srcds
                    );
                    _isOpenDs = false;
                }
            }
        }

        public void Finish()
        {
            CloseDs();
            if (_appid.Id != IntPtr.Zero)
                DSMparent(
                    _appid,
                    IntPtr.Zero,
                    TwDg.Control,
                    TwDat.Parent,
                    TwMsg.CloseDsm,
                    ref _hwnd
                );
            _appid.Id = IntPtr.Zero;
        }

        private IntPtr _hwnd;
        private readonly TwIdentity _appid;
        private readonly TwIdentity _srcds;
        private TwEvent _evtmsg;
        private Winmsg _winmsg;

        // ------ DSM entry point DAT_ variants:
        [DllImport("twain_32.dll", EntryPoint = "#1")]
        private static extern TwRc DSMparent(
            [In, Out] TwIdentity origin,
            IntPtr zeroptr,
            TwDg dg,
            TwDat dat,
            TwMsg msg,
            ref IntPtr refptr
        );

        [DllImport("twain_32.dll", EntryPoint = "#1")]
        private static extern TwRc DSMident(
            [In, Out] TwIdentity origin,
            IntPtr zeroptr,
            TwDg dg,
            TwDat dat,
            TwMsg msg,
            [In, Out] TwIdentity idds
        );

        [DllImport("twain_32.dll", EntryPoint = "#1")]
        // ReSharper disable once UnusedMember.Local
        private static extern TwRc DSMstatus(
            [In, Out] TwIdentity origin,
            IntPtr zeroptr,
            TwDg dg,
            TwDat dat,
            TwMsg msg,
            [In, Out] TwStatus dsmstat
        );

        // ------ DSM entry point DAT_ variants to DS:
        [DllImport("twain_32.dll", EntryPoint = "#1")]
        private static extern TwRc DSuserif(
            [In, Out] TwIdentity origin,
            [In, Out] TwIdentity dest,
            TwDg dg,
            TwDat dat,
            TwMsg msg,
            TwUserInterface guif
        );

        [DllImport("twain_32.dll", EntryPoint = "#1")]
        private static extern TwRc DSevent(
            [In, Out] TwIdentity origin,
            [In, Out] TwIdentity dest,
            TwDg dg,
            TwDat dat,
            TwMsg msg,
            ref TwEvent evt
        );

        [DllImport("twain_32.dll", EntryPoint = "#1")]
        // ReSharper disable once UnusedMember.Local
        private static extern TwRc DSstatus(
            [In, Out] TwIdentity origin,
            [In] TwIdentity dest,
            TwDg dg,
            TwDat dat,
            TwMsg msg,
            [In, Out] TwStatus dsmstat
        );

        [DllImport("twain_32.dll", EntryPoint = "#1")]
        private static extern TwRc DScap(
            [In, Out] TwIdentity origin,
            [In] TwIdentity dest,
            TwDg dg,
            TwDat dat,
            TwMsg msg,
            [In, Out] TwCapability capa
        );

        [DllImport("twain_32.dll", EntryPoint = "#1")]
        private static extern TwRc DSiinf(
            [In, Out] TwIdentity origin,
            [In] TwIdentity dest,
            TwDg dg,
            TwDat dat,
            TwMsg msg,
            [In, Out] TwImageInfo imginf
        );

        [DllImport("twain_32.dll", EntryPoint = "#1")]
        private static extern TwRc DSixfer(
            [In, Out] TwIdentity origin,
            [In] TwIdentity dest,
            TwDg dg,
            TwDat dat,
            TwMsg msg,
            ref IntPtr hbitmap
        );

        [DllImport("twain_32.dll", EntryPoint = "#1")]
        private static extern TwRc DSpxfer(
            [In, Out] TwIdentity origin,
            [In] TwIdentity dest,
            TwDg dg,
            TwDat dat,
            TwMsg msg,
            [In, Out] TwPendingXfers pxfr
        );

        [StructLayout(LayoutKind.Sequential, Pack = 4)]
        internal struct Winmsg
        {
            public IntPtr hwnd;
            public int message;
            public IntPtr wParam;
            public IntPtr lParam;
            public int time;
            public int x;
            public int y;
        }
    } 
}

TwainDibToBitmap.cs

namespace Ztwain
{
    using System;
    using System.Runtime.InteropServices;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;

    internal static class TwainDibToBitmap
    {
        /// <summary>
        /// Get managed BitmapSource from a DIB provided as a low level windows hadle
        /// </summary>
        /// <param name="dibHandle"></param>
        /// <returns></returns>
        public static BitmapSource FormHDib(IntPtr dibHandle)
        {
            BitmapSource bs = null;
            IntPtr bmpPtr = IntPtr.Zero;
            try
            {
                bmpPtr = TwainWin32.GlobalLock(dibHandle);
                TwainWin32.Bitmapinfoheader bi = new TwainWin32.Bitmapinfoheader();
                Marshal.PtrToStructure(bmpPtr, bi);
                if (bi.biSizeImage == 0)
                {
                    bi.biSizeImage = (uint)(
                        ((((bi.biWidth * bi.biBitCount) + 31) & ~31) >> 3) * bi.biHeight
                    );
                }
                int colorNum = 0;
                if (bi.biClrUsed != 0)
                {
                    colorNum = (int)bi.biClrUsed;
                }
                else
                {
                    switch (bi.biBitCount)
                    {
                        case 1:
                            colorNum = 2;
                            break;
                        case 4:
                            colorNum = 16;
                            break;
                        case 8:
                            colorNum = 256;
                            break;
                        case 24:
                        {
                            colorNum = 0; //对于真彩色图，没用到调色板
                            break;
                        }
                    }
                }
                int paletteSize = colorNum * 4;
                IntPtr pixptr = (IntPtr)((int)bmpPtr + bi.biSize + paletteSize);
                PixelFormat pf;
                switch (bi.biBitCount)
                {
                    case 32:
                        pf = PixelFormats.Bgr32;
                        break;
                    case 24:
                        pf = PixelFormats.Bgr24;
                        break;
                    case 8:
                        pf = PixelFormats.Gray8;
                        break;
                    case 1:
                        pf = PixelFormats.BlackWhite;
                        break;
                    default: // not supported
                        throw new NotSupportedException(
                            "DibToBitmap: Can't determine picture format (biBitCount="
                                + bi.biBitCount
                                + ")"
                        );
                }
                int width = bi.biWidth;
                int height = bi.biHeight;
                int stride = (int)(bi.biSizeImage / height);
                byte[] imageBytes = new byte[stride * height];
                for (
                    int i = 0, j = 0, k = (height - 1) * stride;
                    i < height;
                    i++, j += stride, k -= stride
                )
                {
                    Marshal.Copy(((IntPtr)((int)pixptr + j)), imageBytes, k, stride);
                }
                int xDpi = (int)Math.Round(bi.biXPelsPerMeter * 2.54 / 100); // pels per meter to dots per inch
                int yDpi = (int)Math.Round(bi.biYPelsPerMeter * 2.54 / 100);

                // Create a BitmapSource.
                bs = BitmapSource.Create(width, height, xDpi, yDpi, pf, null, imageBytes, stride);
            }
            catch (Exception)
            {
                // ignored
            }
            finally
            {
                // cleanup
                if (bmpPtr != IntPtr.Zero)
                {
                    // locked sucsessfully
                    TwainWin32.GlobalUnlock(dibHandle);
                }
            }
            return bs;
        }
    }
}

TwainWPF.cs

namespace Ztwain
{
    using System;
    using System.Windows;
    using System.Windows.Interop;
    using System.Windows.Media.Imaging;

    public delegate void TwainEventHandler(TwainWpf sender);

    public delegate void TwainProductNameHandler(TwainWpf sender, string productName);

    public delegate void TwainTransferReadyHandler(TwainWpf sender, BitmapSource imageSource);

    public delegate void TwainTransferFinishHandler(TwainWpf sender);

    public class TwainWpf : DependencyObject
    {
        // events
        public event TwainEventHandler TwainCloseRequest;
        public event TwainEventHandler TwainCloseOk;
        public event TwainEventHandler TwainDeviceEvent;
        public event TwainTransferReadyHandler TwainTransferReady;
        public event TwainTransferFinishHandler TwainTransferFinish;
        public event TwainProductNameHandler TwainProductNameEvent;

        private bool _twainMessageProcessing;
        private Twain _tw;

        private IntPtr _handle = IntPtr.Zero;

        public Window TheMainWindow;

        public uint WmAppAcquire = TwainWin32.RegisterWindowMessage("IBN_WfpTwain_Acquire");

        public IntPtr WindowHandle
        {
            get
            {
                if (_handle == IntPtr.Zero)
                    _handle = (new WindowInteropHelper(TheMainWindow)).Handle;
                return _handle;
            }
        }

        public TwainWpf(Window win)
        {
            TheMainWindow = win;
            if (WindowHandle != IntPtr.Zero)
            {
                HostWindow_Loaded(this, null);
            }
            else
            {
                TheMainWindow.Loaded += HostWindow_Loaded;
            }
            TheMainWindow.Closing += HostWindow_Closing;
        }

        ~TwainWpf()
        {
            TerminateTw();
        }

        /// <summary>
        /// 选择扫描仪驱动
        /// </summary>
        /// <returns></returns>
        public bool Select()
        {
            if (_tw != null)
            {
                _tw.Select();
                return true;
            }

            return false;
        }

        /// <summary>
        /// 开始扫描
        /// </summary>
        /// <param name="showUi">是否显示设置页面</param>
        /// <returns></returns>
        public bool Acquire(bool showUi)
        {
            if (_tw != null)
            {
                _twainMessageProcessing = true;
                bool posted = TwainWin32.PostMessage(
                    WindowHandle,
                    WmAppAcquire,
                    (IntPtr)(showUi ? 1 : 0),
                    IntPtr.Zero
                );
                return posted;
            }
            return false;
        }

        private void HostWindow_Loaded(object sender, RoutedEventArgs e)
        {
            AddMessageHook();
            _tw = new Twain(name =>
            {
                if (TwainProductNameEvent != null)
                {
                    TwainProductNameEvent(this, name);
                }
            });
            _tw.Init(WindowHandle);
        }

        private void HostWindow_Closing(object sender, EventArgs e)
        {
            RemoveMessageHook();
        }

        private void AddMessageHook()
        {
            HwndSource src = HwndSource.FromHwnd(WindowHandle);
            if (src != null)
                src.AddHook(this.WndProc);
        }

        private void RemoveMessageHook()
        {
            HwndSource src = HwndSource.FromHwnd(WindowHandle);
            if (src != null)
                src.AddHook(this.WndProc);
        }

        private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
        {
            System.Windows.Forms.Message m = new System.Windows.Forms.Message();
            m.HWnd = hwnd;
            m.Msg = msg;
            m.WParam = wParam;
            m.LParam = lParam;

            if (handled)
                return IntPtr.Zero;
            if (msg == WmAppAcquire)
            {
                _tw.Acquire(wParam != IntPtr.Zero);
            }

            if (_tw != null)
            {
                PreFilterMessage(m, ref handled);
            }
            return IntPtr.Zero;
        }

        private void TerminateTw()
        {
            if (_tw != null)
            {
                _tw.Finish();
                _tw = null;
            }

            _twainMessageProcessing = false;
        }

        // Twain event callbacks
        protected void OnTwainCloseRequest()
        {
            if (TwainCloseRequest != null)
                TwainCloseRequest(this);
            _tw.CloseDs();
        }

        protected void OnTwainCloseOk()
        {
            if (TwainCloseOk != null)
                TwainCloseOk(this);

            //EndingScan();
            _tw.CloseDs();
        }

        protected void OnTwainDeviceEvent()
        {
            if (TwainDeviceEvent != null)
                TwainDeviceEvent(this);
        }

        protected void OnTwainTransferReady()
        {
            if (TwainTransferReady == null)
                return;
            _tw.TransferPictures(imgHandle =>
            {
                BitmapSource image = TwainDibToBitmap.FormHDib(imgHandle);
                TwainTransferReady(this, image);
                TwainWin32.GlobalFree(imgHandle);
            });
            _tw.CloseDs();
            EndingScan();
            if (TwainTransferFinish != null)
            {
                TwainTransferFinish(this);
            }
        }

        private void EndingScan()
        {
            if (_twainMessageProcessing)
            {
                _twainMessageProcessing = false;
            }
        }

        protected void PreFilterMessage(System.Windows.Forms.Message m, ref bool handled)
        {
            TwainCommand cmd = _tw.PassMessage(ref m);
            if (cmd == TwainCommand.Not || cmd == TwainCommand.Null)
                return;
            switch (cmd)
            {
                case TwainCommand.CloseRequest:
                {
                    OnTwainCloseRequest();
                    break;
                }
                case TwainCommand.CloseOk:
                {
                    OnTwainCloseOk();
                    break;
                }
                case TwainCommand.DeviceEvent:
                {
                    OnTwainDeviceEvent();
                    break;
                }
                case TwainCommand.TransferReady:
                {
                    OnTwainTransferReady();
                    break;
                }
            }

            handled = true;
        }
    }
}

调用方式

using System;
using System.Windows;
using System.Windows.Media.Imaging;
using ztwain;

namespace scanner_test
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        protected TwainWpf TwainInterface;

        public MainWindow()
        {
            InitializeComponent();
            TwainInterface = new TwainWpf(this);
            TwainInterface.TwainTransferReady += TwainInterface_TwainTransferReady;
            TwainInterface.TwainTransferFinish += TwainInterface_TwainTransferFinish;
            TwainInterface.TwainCloseRequest += TwainInterface_TwainCloseRequest;
            TwainInterface.TwainProductNameEvent += TwainInterface_TwainProductNameEvent;

            SelectBtn.Click += Select_btn_Click;
            ScannerBtn.Click += Scanner_btn_Click;
        }


        //选中扫描仪后的回调
        private void TwainInterface_TwainProductNameEvent(TwainWpf sender, string productName)
        {
            ScannerName.Text = productName;
        }

        private void TwainInterface_TwainCloseRequest(TwainWpf sender)
        {
        }

        //单页扫描结果
        private void TwainInterface_TwainTransferReady(TwainWpf sender, BitmapSource imageSource)
        {
            //建议这里保存图片到本地 把图片地址保存在列表中
            Console.WriteLine(@"扫描到一张");
        }

        //一批扫描结束
        private void TwainInterface_TwainTransferFinish(TwainWpf sender)
        {
            //从图片列表中获取图片地址，进行处理
        }

        private void Select_btn_Click(object sender, RoutedEventArgs e)
        {
            TwainInterface.Select();
        }

        private void Scanner_btn_Click(object sender, RoutedEventArgs e)
        {
            TwainInterface.Acquire(true);
        }
    }
}

页面代码

<Window
    x:Class="scanner_test.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    Title="扫描仪测试"
    Width="600"
    Height="100"
    mc:Ignorable="d">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="100" />
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="100" />
        </Grid.ColumnDefinitions>


        <Button
            Name="SelectBtn"
            Width="80"
            Height="30"
            HorizontalAlignment="Center"
            VerticalAlignment="Center"
            Content="选择" />
        <TextBlock
            Name="ScannerName"
            Grid.Column="1"
            Width="200"
            VerticalAlignment="Center" />
        <Button
            Name="ScannerBtn"
            Grid.Column="2"
            Width="80"
            Height="30"
            HorizontalAlignment="Center"
            VerticalAlignment="Center"
            Content="扫描" />

    </Grid>
</Window>

图片保存

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Windows.Media.Imaging;

public class ZImgUtils
{
  private static int _tempnum = 100;

  public static string GetBaseFolder(params string[] pathParas)
  {
    string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
    List<string> stringList = pathParas.ToList();
    stringList.InsertRange(0, new string[] { docPath, "ZProject" });
    string pathAll = Path.Combine(stringList.ToArray());
    DirectoryInfo directoryInfo = new DirectoryInfo(pathAll);
    if (!directoryInfo.Exists)
    {
      System.IO.Directory.CreateDirectory(pathAll);
    }
    return pathAll;
  }

  public static string GetPathJpeg(string basePath, string nameSuffix = "img")
  {
    _tempnum += 1;
    if (_tempnum >= 9999)
    {
      _tempnum = 1000;
    }
    string filename = DateTime.Now.ToString("yyyyMMddHHmmss_ffff") +
      _tempnum +
      "_" +
      nameSuffix +
      ".jpg";
    return Path.Combine(basePath, filename);
  }

  /// <summary>
  /// 保存图片到文件
  /// </summary>
  /// <param name="image">图片数据</param>
  /// <param name="filePath">保存路径</param>
  public static void SaveImageToFile(BitmapSource image, string filePath)
  {
    BitmapEncoder encoder = GetBitmapEncoder(filePath);
    encoder.Frames.Add(BitmapFrame.Create(image));
    using (FileStream stream = new FileStream(filePath, FileMode.Create))
    {
      encoder.Save(stream);
    }
  }

  /// <summary>
  /// 根据文件扩展名获取图片编码器
  /// </summary>
  /// <param name="filePath">文件路径</param>
  /// <returns>图片编码器</returns>
  private static BitmapEncoder GetBitmapEncoder(string filePath)
  {
    string extName = Path.GetExtension(filePath).ToLower();
    if (extName.Equals(".png"))
    {
      return new PngBitmapEncoder();
    }
    return new JpegBitmapEncoder();
  }
}

Twain方式2

这个库在部分扫描仪上有问题，不推荐使用。

添加引用

Nuget 添加依赖 NTwain

命令安装

Install-Package NTwain -Version 3.7.4

Github网址

https://github.com/soukoku/ntwain

初始化

private TwainSession session = null;

//所有的扫描仪
private List<DataSource> sourceList = new List<DataSource>();

//当前使用的扫描仪
private DataSource source_current = null;

private void initScanner()
{
  //Allow old Device DSM drives
  PlatformInfo.Current.PreferNewDSM = false;
  //开始扫描
  var appId = TWIdentity.CreateFromAssembly(DataGroups.Image, Assembly.GetExecutingAssembly());
  session = new TwainSession(appId);
  session.TransferReady += Session_TransferReady;
  session.DataTransferred += Session_DataTransferred;
  if (session.Open() != ReturnCode.Success)
  {
    Console.WriteLine("扫描启动失败");
  }

  var source_list = session.GetSources();
  foreach (DataSource source in source_list)
  {
    sourceList.Add(source);
  }
}

private void Session_TransferReady(object sender, TransferReadyEventArgs e)
{
  Console.WriteLine("Session_TransferReady");
}

private void Session_DataTransferred(object sender, DataTransferredEventArgs e)
{
  //ImageSource img = GenerateThumbnail(e);
  Console.WriteLine(GenerateFile(e));
}

DataSource可用以下的属性

• int Id 如：349 每次重启应用的时候Id会变。
• string Name 如：Canon DR-M160 TWAIN
• string Manufacturer 如：Copyright CANON ELECTRONICS INC.
• string ProductFamily 如：Canon DR-M160 Driver
• bool IsOpen 如：False

对于双面扫描我们可以通过下面的方式来判断

每一页扫描都会先触发一次Session_TransferReady,之后触发两次Session_DataTransferred,从而来判定一个页面的两面。

扫描

private void Scanner_btn_Click(object sender, System.Windows.RoutedEventArgs e)
{
  if (source_current == null)
  {
    source_current = sourceList[0];
  }
  if (!source_current.IsOpen)
  {
    source_current.Open();
  }
  try
  {
    session.CurrentSource.Enable(SourceEnableMode.ShowUI, false, new WindowInteropHelper(this).Handle);
  }
  catch (Exception err)
  {
    System.Windows.MessageBox.Show(err.ToString());
  }
}

其中第一个参数可以传如下的值

• SourceEnableMode.ShowUI 显示扫描仪配置页面，并且能进行扫描。
• SourceEnableMode.NoUI 直接扫描不显示配置页面。
• SourceEnableMode.ShowUIOnly 只显示配置页面，不能扫描，一般和上面的配合使用。

图片处理

在Session_DataTransferred回调中我们可以处理图片

获取扫描图片的地址

private string GenerateFile(DataTransferredEventArgs e)
{
  string imagepath = "";

  switch (e.TransferType)
  {
    case XferMech.Native:
      using (System.IO.Stream stream = e.GetNativeImageStream())
      {
        if (stream != null)
        {
          string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
          var dirPath = Path.Combine(docPath, "scanner_pic");
          DirectoryInfo directoryInfo = new DirectoryInfo(dirPath);
          if (!directoryInfo.Exists)
          {
            System.IO.Directory.CreateDirectory(dirPath);
          }
          string timestr = DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss-ffff");
          imagepath = Path.Combine(dirPath, timestr + ".jpg");
          using (var fileStream = File.Create(imagepath))
          {
            stream.CopyTo(fileStream);
          }
        }
      }
      break;

    case XferMech.File:
      imagepath = e.FileDataPath;
      break;
  }
  return imagepath;
}

获取扫描的缩略图

private ImageSource GenerateThumbnail(DataTransferredEventArgs e)
{
  BitmapSource img = null;

  switch (e.TransferType)
  {
    case XferMech.Native:
      using (System.IO.Stream stream = e.GetNativeImageStream())
      {
        if (stream != null)
        {
          img = stream.ConvertToWpfBitmap(300, 0);
        }
      }
      break;

    case XferMech.File:
      img = new BitmapImage(new Uri(e.FileDataPath));
      if (img.CanFreeze)
      {
        img.Freeze();
      }

      break;
  }
  return img;
}

康佳扫描仪(官方COM)

使用厂家提供的开发COM组件，必须要安装两个东西

• 扫描仪驱动
• 开发包(附带COM组件)

添加COM引用

安装完驱动后

项目中添加啊COM引用TechHeroScanProj1

初始化

private TechHeroScanProj1.TechHeroScan axTechHeroScan1 = null;        

axTechHeroScan1 = new TechHeroScanProj1.TechHeroScan();
//设置参数
axTechHeroScan1.Pixel_Type = 2;         // 扫描类型：0黑白 1灰度 2彩色
axTechHeroScan1.Resolution = 200;       // 分辨率
axTechHeroScan1.Duplex = true;          // 双面扫描：true双面 false单面
axTechHeroScan1.SetAutoDeskew(true);
axTechHeroScan1.PaperSize = -1;          // 纸张大小：-1时为自动判断纸张大小  1 A4  2 B5 具体请看help.doc
axTechHeroScan1.Rotation = 0;           //旋转角度： 0 90 180 270 为旋转角度 360为根据文字方向自动旋转
axTechHeroScan1.ShowSetupBeforeScan = false;   //扫描前显示驱动界面
axTechHeroScan1.ShowIndicators = false;  //显示扫描进度条
axTechHeroScan1.SetDetectDoubleFeed(2);  //双张检测 0不检测  1长度检测  2超声波检测

选择扫描仪

private void Select_btn_Click(object sender, System.Windows.RoutedEventArgs e)
{
  axTechHeroScan1.SelectScanner();
}

开始和错误回调

axTechHeroScan1.OnBeforeScan += AxTechHeroScan1_OnBeforeScan;
axTechHeroScan1.OnScanError += AxTechHeroScan1_OnScanError;

private void AxTechHeroScan1_OnBeforeScan()
{
  Console.WriteLine("扫描前");
}

private void AxTechHeroScan1_OnScanError(int ErrorCode, int Additional)
{
  Console.WriteLine("扫描失败", ErrorCode);
}

扫描

两种扫描方式使用一种即可，如果没有文件命名的需求建议直接使用内部重命名的方式。

内部重命名

axTechHeroScan1.OnPageDone += AxTechHeroScan1_OnPageDone;
axTechHeroScan1.OnScanDone += AxTechHeroScan1_OnScanDone;

private void AxTechHeroScan1_OnPageDone(string strFileName)
{
  Console.WriteLine(strFileName);
}

private void AxTechHeroScan1_OnScanDone()
{
  Console.WriteLine("扫描结束");
}

// 按钮事件
private void Scanner_btn_Click(object sender, System.Windows.RoutedEventArgs e)
{
  //开始扫描
  axTechHeroScan1.ScanImage(0, "D:\\scanner_pic\\", "img_", "jpg");
}

手动重命名

axTechHeroScan1.OnPageDoneDib += AxTechHeroScan1_OnPageDoneDib;
axTechHeroScan1.OnScanDone += AxTechHeroScan1_OnScanDone;

private void AxTechHeroScan1_OnPageDoneDib(int dib, int Resolution)
{
  string timestr = DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss-ffff");
  axTechHeroScan1.SaveJpgFile("D:\\scanner_pic\\" + timestr + ".jpg", dib, Resolution, 75);
  axTechHeroScan1.FreeDib(dib);
}

private void AxTechHeroScan1_OnScanDone()
{
  Console.WriteLine("扫描结束");
}

// 按钮事件
private void Scanner2_btn_Click(object sender, System.Windows.RoutedEventArgs e)
{
  //开始扫描
  axTechHeroScan1.ScanToDib(0);
}

WIA对接

在COM里导入

一般最近年头的扫描仪都支持这个协议。

错误代码

https://docs.microsoft.com/zh-cn/windows/win32/wia/-wia-error-codes

弹窗设置

ImageFile imageFile = null;
CommonDialog cdc = new WIA.CommonDialog();

try
{
  imageFile = cdc.ShowAcquireImage(
    WIA.WiaDeviceType.ScannerDeviceType,
    WIA.WiaImageIntent.TextIntent,
    WIA.WiaImageBias.MaximizeQuality,
    "{00000000-0000-0000-0000-000000000000}",
    true,
    true,
    false
  );
  string fileName = Path.GetTempFileName() + ".png";
  Console.WriteLine(fileName);
  File.Delete(fileName);
  imageFile.SaveFile(fileName);//保存temp文件;
}
catch (System.Runtime.InteropServices.COMException)
{
  imageFile = null;
}