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

发表于 | 分类于
扫描仪对接（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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
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;
        }
    }
}

调用方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
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);
        }
    }
}

页面代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
<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>

图片保存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
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

image-20220729142158095

命令安装

1
Install-Package NTwain -Version 3.7.4

Github网址

https://github.com/soukoku/ntwain

初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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,从而来判定一个页面的两面。

扫描

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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回调中我们可以处理图片

获取扫描图片的地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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;
}

获取扫描的缩略图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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

初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
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超声波检测

选择扫描仪

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

开始和错误回调

1
2
3
4
5
6
7
8
9
10
11
12
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);
}

扫描

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

内部重命名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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");
}

手动重命名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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里导入

image-20220803100347269

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

错误代码

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

弹窗设置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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;
}