获取扫描仪图片-TWAIN协议

最新推荐文章于 2023-05-24 17:04:36 发布
最新推荐文章于 2023-05-24 17:04:36 发布
阅读量7.8k 收藏 8
点赞数 1
分类专栏： 网络编程 文章标签： twain 图片 扫描仪
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hacode/article/details/4601792
版权

源代码(连接另存为方式下载，重命名为zip文件再解压就可以到到源文件了)

下载链接http://hi.csdn.net/attachment/201107/19/0_1311044325WNjx.gif


请先到twain官方网站下载twain32头文件定义。


BOOL SaveBitmap(HGLOBAL _hDIB, const int serial_number){ 
    BITMAPFILEHEADER bfh = {0};
    BITMAPINFOHEADER *pBIH = NULL;
    HANDLE hf = NULL;
    
    // 获取临时文件
    char _szTempFile [MAX_PATH] = {0};
    char _szTempDir [MAX_PATH] = {0};
    srand(GetTickCount());
    GetTempPathA(sizeof(_szTempDir), _szTempDir);
    
    sprintf_s(_szTempFile
            , sizeof(_szTempFile)
            , "%s//%d-%d.bmp"
            , _szTempDir
            , serial_number
            , rand());
            
    hf = CreateFileA(_szTempFile
            , GENERIC_WRITE
            , 0
            , NULL
            , CREATE_ALWAYS
            , FILE_ATTRIBUTE_NORMAL
            , NULL);

    if(hf == INVALID_HANDLE_VALUE) 
        GlobalFree(_hDIB);
        return FALSE;

    // 解析成位图文件头
    pBIH = (BITMAPINFOHEADER*)GlobalLock(_hDIB);

    DWORD dwBytesWritten = 0l;
    bfh.bfType = ( (WORD) ('M' << 8) | 'B');

    bfh.bfSize = sizeof(BITMAPFILEHEADER) 
        + sizeof(BITMAPINFOHEADER) 
        +((((pBIH->biWidth*pBIH->biBitCount+31)/32)*4)*pBIH->biHeight)
        + pBIH->biClrUsed * sizeof(RGBQUAD);
    bfh.bfReserved1 = 0;

    bfh.bfReserved2 = 0;

    bfh.bfOffBits = sizeof(BITMAPFILEHEADER) 
                + sizeof(BITMAPINFOHEADER) 
                + pBIH->biClrUsed * sizeof(RGBQUAD);
    
    // 写入位图到文件
    WriteFile(hf
            , &bfh
            , sizeof(BITMAPFILEHEADER)
            , &dwBytesWritten
            , NULL);
    WriteFile(hf
            , pBIH
            , bfh.bfSize-sizeof(BITMAPFILEHEADER)
            , &dwBytesWritten
            , NULL);
    CloseHandle(hf);hf=INVALID_HANDLE_VALUE;
    TRACE("save bitmap to:");TRACE(_szTempFile);
    
    GlobalUnlock(_hDIB);
    GlobalFree(_hDIB);
    return TRUE;
}

unsigned long __stdcall ScanThread(void * args)
{ 
    HWND _hWnd = NULL;
    MSG _msg = {0};
    HMODULE _hDSM = NULL;
    HBITMAP _hBitmap = NULL;
    int _nCount = 0;
    TW_CAPABILITY _cap = {0};
    TW_UINT16 _twRC = TWRC_FAILURE;
    pTW_ENUMERATION _pEnumeration = NULL;
    pTW_ONEVALUE _pOneValue = NULL;
    TW_EVENT _twEvent = {0};
    TW_IDENTITY _dsid = {0};
    TW_USERINTERFACE _twUI = {0};
    TW_PENDINGXFERS _twPendingXfer = {0};
    TW_UINT16 _ModeType = -1;
    TW_UINT32 _index = 0;    
    TW_IDENTITY _dsmid = { 
        0,     
        { 1, 703, TWLG_USA, TWCY_USA, "twain-1.7.0.3" },
        1,
        7, 
        (DG_IMAGE | DG_CONTROL), 
        "xxxx IT Corp. Ltd.", 
        "xxxx webctrl", "wuzh1230" 
    }; 

    // 初始化 
    _hDSM = LoadLibraryA("TWAIN_32.DLL");

    // 获取接口指针
    DSMENTRYPROC _pDSMEntryProc = (DSMENTRYPROC)
                    GetProcAddress(_hDSM, "DSM_Entry");

    // 创建窗口，利用窗口的消息循环收取位图
    _hWnd = CreateWindowExA(0
                , "#32770"
                , "Scan Client"
                , WS_OVERLAPPEDWINDOW
                , 0, 0, 1, 1
                , NULL
                , NULL
                , GetModuleHandleA(0)
                , NULL);

    // 打开数据源管理器 
    _twRC = CallDSMEntry(&_dsmid
                    , NULL
                    , DG_CONTROL
                    , DAT_PARENT
                    , MSG_OPENDSM
                    , (TW_MEMREF)&_hWnd);

    // 选择数据源 
    _twRC = CallDSMEntry(&_dsmid
                    , NULL
                    , DG_CONTROL
                    , DAT_IDENTITY
                    , MSG_GETDEFAULT
                    , (TW_MEMREF)&_dsid);

    _twRC = CallDSMEntry(&_dsmid
                    , NULL
                    , DG_CONTROL
                    , DAT_IDENTITY
                    , MSG_USERSELECT
                    , (TW_MEMREF)&_dsid);

    // 打开数据源 
    _twRC = CallDSMEntry(&_dsmid
                    , NULL
                    , DG_CONTROL
                    , DAT_IDENTITY
                    , MSG_OPENDS
                    , &_dsid);

    // 读取并设置传输模式ICAP_XFERMECH 
    memset(&_cap, 0, sizeof(TW_CAPABILITY));
    _cap.Cap = ICAP_XFERMECH;
    _cap.ConType = TWON_ENUMERATION;
    _twRC = CallDSMEntry(&_dsmid
                    , &_dsid
                    , DG_CONTROL
                    , DAT_CAPABILITY
                    , MSG_GET
                    , (TW_MEMREF)&_cap);
                    
    _pEnumeration = (pTW_ENUMERATION)GlobalLock(_cap.hContainer);

    // 搜索native模式的索引
    for (_index = 0; _index < _pEnumeration->NumItems; _index++) 
    { 
        if (((TW_UINT16*)_pEnumeration->ItemList)[_index] == TWSX_NATIVE) 
        { break;}
    }
    // 没有搜索到native模式的索引
    if (_index == _pEnumeration->NumItems)
    {    
        goto end_of_function;
    }
    // 如果当前索引位置的模式已经是NATIVE
    if (_index == _pEnumeration->CurrentIndex) 
    { 
        TRACE("Current xfer mode is 'native(TWSX_NATIVE)'");
        _ModeType = TWSX_NATIVE;
        GlobalUnlock(_cap.hContainer);
        GlobalFree(_cap.hContainer);
    } 
    else 
    { 
        TRACE("Current Mode is not 'native(TWSX_NATIVE)'");
        
        // 设置native模式, _index是搜索到的native模式的索引
        _pEnumeration->CurrentIndex = _index; 
        _pEnumeration->DefaultIndex = _index;
        GlobalUnlock(_cap.hContainer);
        _twRC = CallDSMEntry(&_dsmid
                        , &_dsid
                        , DG_CONTROL
                        , DAT_CAPABILITY
                        , MSG_SET
                        , (TW_MEMREF)&_cap);
        
        if (_twRC != TWRC_SUCCESS) 
        { 
            TRACE("Failed to set xfer mode to 'native(TWSX_NATIVE)'");
            goto end_of_function;
        }
        GlobalFree(_cap.hContainer);
        
        // 再次读取模式
        _twRC = CallDSMEntry(&_dsmid
                            , &_dsid
                            , DG_CONTROL
                            , DAT_CAPABILITY
                            , MSG_GET
                            , (TW_MEMREF)&_cap);
        if (_twRC != TWRC_SUCCESS) 
        { 
            TRACE("Failed to read back xfer mode.");
            goto end_of_function;
        }
        _pEnumeration = (pTW_ENUMERATION)GlobalLock(_cap.hContainer);
        // 读取
        _ModeType = ((TW_UINT16*)
                    _pEnumeration->ItemList)[_pEnumeration->CurrentIndex];
        GlobalUnlock(_cap.hContainer);
        GlobalFree(_cap.hContainer);

        // 检查模式是否是native
        if (_ModeType != TWSX_NATIVE) 
        { 
            TRACE("xfer mode NOT 'native(TWSX_NATIVE)',quit.");
            goto end_of_function;
        } 
    }
 
    TRACE("Current xfer mode is 'native(TWSX_NATIVE)'");
 
    // 读取送纸参数CAP_FEEDERENABLED 
    TRACE("Read capability 'feed enabled(CAP_FEEDERENABLED)'.");

    memset(&_cap, 0, sizeof(TW_CAPABILITY));
    _cap.Cap = CAP_FEEDERENABLED;
    _cap.ConType = TWON_ONEVALUE;
    _twRC = CallDSMEntry(&_dsmid
                    , &_dsid
                    , DG_CONTROL
                    , DAT_CAPABILITY
                    , MSG_GET
                    , (TW_MEMREF)&_cap);
    GlobalFree(_cap.hContainer);
    // 读取自动喂纸设备失败，可能是没有硬件支持
    if (_twRC != TWRC_SUCCESS) 
    { 
        TRACE("Failed to read 'feed enabled(CAP_FEEDERENABLED)'");
        TRACE("[possiblly NO this hardware.].");
        if (FEED_ENABLED) 
        { 
            TRACE("NO Hardware to support feed, so Unable to set, quit.");
            goto end_of_function;
        }
    }
    else 
    {
        // 有送纸硬件 
        TRACE("OK to read 'feed enabled(CAP_FEEDERENABLED)'");
        TRACE("[Hardware present].");
        
        // 先检查是否启用了 
        memset(&_cap, 0, sizeof(TW_CAPABILITY));
        _cap.Cap = CAP_FEEDERENABLED;
        _cap.ConType = TWON_ONEVALUE;
        _twRC = CallDSMEntry(&_dsmid
                        , &_dsid
                        , DG_CONTROL
                        , DAT_CAPABILITY
                        , MSG_GET
                        , (TW_MEMREF)&_cap);
                        
        if (_twRC != TWRC_SUCCESS) 
        { 
            TRACE("Failed to set 'feed enabled(CAP_FEEDERENABLED)'");
            GlobalFree(_cap.hContainer);
            goto end_of_function;
        }
        
        _pOneValue = (pTW_ONEVALUE)GlobalLock(_cap.hContainer);
        // 如果已经启用了
        if (_pOneValue->Item == FEED_ENABLED) 
        { 
            TRACE("[feeder enabled(CAP_FEEDERENABLED)] is same as parameter")
            GlobalUnlock(_cap.hContainer);
            GlobalFree(_cap.hContainer);
        }
        // 没有启用,启用喂纸设备    
        else 
        { 
             _pOneValue->Item = FEED_ENABLED;
            GlobalUnlock(_cap.hContainer);
            _twRC = CallDSMEntry(&_dsmid
                            , &_dsid
                            , DG_CONTROL
                            , DAT_CAPABILITY
                            , MSG_SET
                            , (TW_MEMREF)&_cap);
            GlobalFree(_cap.hContainer);
            if (_twRC != TWRC_SUCCESS) 
            {
                TRACE("Faile to set [feeder enabled(CAP_FEEDERENABLED)]");
                goto end_of_function;
            }
        }
        
        // 再次读取，检查是否设置成功
        memset(&_cap, 0, sizeof(TW_CAPABILITY));
        _cap.Cap = CAP_FEEDERENABLED;
        _cap.ConType = TWON_ONEVALUE;
        _twRC = CallDSMEntry(&_dsmid
                            , &_dsid
                            , DG_CONTROL
                            , DAT_CAPABILITY
                            , MSG_GET
                            , (TW_MEMREF)&_cap);
        if (_twRC != TWRC_SUCCESS) 
        { 
            GlobalFree(_cap.hContainer);
            TRACE("Failed to read [feeder enabled(CAP_FEEDERENABLED)]");
            goto end_of_function;
        }
        _pOneValue = (pTW_ONEVALUE)GlobalLock(_cap.hContainer);
        GlobalUnlock(_cap.hContainer);
        GlobalFree(_cap.hContainer);
        
        // 设置成功
        TRACE("OK to read [feed enabled(CAP_FEEDERENABLED)]");    
        
    #if 0 
        // 启用送纸:read 
        memset(&_cap, 0, sizeof(TW_CAPABILITY));
         _cap.Cap = CAP_AUTOFEED;
         _cap.ConType = TWON_ONEVALUE;
         _twRC = CallDSMEntry(&_dsmid
                            , &_dsid
                            , DG_CONTROL
                            , DAT_CAPABILITY
                            , MSG_GET
                            , (TW_MEMREF)&_cap);
         if (_twRC != TWRC_SUCCESS) 
         { 
             GlobalFree(_cap.hContainer);
             TRACE("设置'自动送纸(CAP_AUTOFEED)'失败");
             goto end_of_function;
         }
     
        // 如果已经启用送纸 
        _pOneValue = (pTW_ONEVALUE)GlobalLock(_cap.hContainer);
         if (_pOneValue->Item == AUTOFEED_ENABLED) 
         { 
             GlobalUnlock(_cap.hContainer);
             GlobalFree(_cap.hContainer);
         }
         // 没有启用，设置
         else 
         {
             _pOneValue->Item = AUTOFEED_ENABLED;
             GlobalUnlock(_cap.hContainer);
             _twRC = CallDSMEntry(&_dsmid
                            , &_dsid
                            , DG_CONTROL
                            , DAT_CAPABILITY
                            , MSG_SET
                            , (TW_MEMREF)&_cap);
             GlobalFree(_cap.hContainer);
             if (_twRC != TWRC_SUCCESS) 
             { 
                 TRACE("设置'自动送纸(CAP_AUTOFEED)'失败");
                 goto end_of_function;
             }
         }
         
        // 再次读取，检查是否成功启用送纸
        memset(&_cap, 0, sizeof(TW_CAPABILITY));
        _cap.Cap = CAP_AUTOFEED;
        _cap.ConType = TWON_ONEVALUE;
        _twRC = CallDSMEntry(&_dsmid
                        , &_dsid
                        , DG_CONTROL
                        , DAT_CAPABILITY
                        , MSG_GET
                        , (TW_MEMREF)&_cap);
        if (_twRC != TWRC_SUCCESS) 
        {
            GlobalFree(_cap.hContainer);
            TRACE("设置'自动送纸(CAP_AUTOFEED)'失败");
            goto end_of_function;
        }
        _pOneValue = (pTW_ONEVALUE)GlobalLock(_cap.hContainer);
        GlobalUnlock(_cap.hContainer);
        GlobalFree(_cap.hContainer);
        
        // 设置成功
        TRACE("设置'自动送纸(CAP_AUTOFEED)'成功");
    #endif 
    }

    // 显示界面，扫描 
    _twUI.hParent = GetActiveWindow();
    _twUI.ShowUI = TRUE;
    _twRC = CallDSMEntry(&_dsmid
                    , &_dsid
                    , DG_CONTROL
                    , DAT_USERINTERFACE
                    , MSG_ENABLEDS
                    , (TW_MEMREF)&_twUI);
    if (_twRC != TWRC_SUCCESS) 
    { 
        TRACE("Faile to enable UI.");
        goto end_of_function;
    }

    // 消息循环 
    _twEvent.pEvent = (TW_MEMREF)&_msg;
     while (GetMessage(&_msg, NULL, 0, 0)) 
     {
        _twRC = TWRC_FAILURE;
        _twEvent.TWMessage = -1;
        _twRC = CallDSMEntry(&_dsmid
                        , &_dsid
                        , DG_CONTROL
                        , DAT_EVENT
                        , MSG_PROCESSEVENT
                        , (TW_MEMREF)&_twEvent);
        if (_twRC == TWRC_FAILURE || _twEvent.TWMessage == -1) 
        { 
            TRACE("Failed to get message.");
            goto end_of_function;
        }

        // 不是数据源发送过来的消息，交给窗口默认处理
        if (_twRC == TWRC_NOTDSEVENT) 
        { 
            TranslateMessage(&_msg);
            DispatchMessage(&_msg);
            continue;
        }
        
        // 处理数据源发送来的消息
        switch (_twEvent.TWMessage) 
        { 
            // 位图在扫描仪内就绪了
            case MSG_XFERREADY: 
            { 
                // 循环接受每一张位图
                memset(&_twPendingXfer, 0, sizeof(TW_PENDINGXFERS));
                do {
                    _hBitmap = NULL;
                    // 接受一张位图
                    _twRC = CallDSMEntry(&_dsmid
                                    , &_dsid
                                    , DG_IMAGE
                                    , DAT_IMAGENATIVEXFER
                                    , MSG_GET
                                    , (TW_MEMREF)&_hBitmap);
                    switch (_twRC) 
                    { 
                        case TWRC_XFERDONE: // 传输完成，保存位图                 
                        { 
                            TRACE("xfer is done.(TWRC_XFERDONE)");
                            if (SaveBitmap((HGLOBAL)_hBitmap, _nCount++)) 
                            { 
                                TRACE("OK to save bitmap to file.");
                            }
                            else 
                            { 
                                TRACE("Failed to save bitmap to file.");
                            }
                            TRACE("send endxfer[MSG_ENDXFER] message.");
                            _twRC = CallDSMEntry(&_dsmid
                                            , &_dsid
                                            , DG_CONTROL
                                            , DAT_PENDINGXFERS
                                            , MSG_ENDXFER
                                            , (TW_MEMREF)&_twPendingXfer);
                        }break;
                        case TWRC_CANCEL:    // 取消
                        case TWRC_FAILURE:     // 失败
                        default:                         
                        { 
                            //    结束位图传输
                            TRACE("User canceld(TWRC_CANCEL)，");
                            TRACE("or xfer failed(TWRC_FAILURE).");
                            _twRC = CallDSMEntry(&_dsmid
                                            , &_dsid
                                            , DG_CONTROL
                                            , DAT_PENDINGXFERS
                                            , MSG_ENDXFER
                                            , (TW_MEMREF)&_twPendingXfer);
                            TRACE("send endxfer message.");
                        }break;
                    }
                }while (_twPendingXfer.Count != 0); // 如果有多张位图
            }break;

            
            case MSG_CLOSEDSREQ:     // 关闭数据源请求
            case MSG_CLOSEDSOK:      // 数据源成功关闭
            case MSG_NULL:          // 空消息            
                TRACE("MSG_CLOSEDSREQ or MSG_CLOSEDSOK or MSG_NULL)");
            default: break;            // 忽略
        }        
        
        // 如果是关闭请求，就退出外层循环
        if (_twEvent.TWMessage != MSG_NULL) 
        { 
            TRACE("Break up from Message loop.");
            break;
        }
     }
     
end_of_function: 

    TRACE("Start to cleanup resources of thread.");
     
    // 关闭用户界面 
     memset(&_twUI, 0, sizeof(TW_USERINTERFACE));
     _twUI.hParent = _hWnd;
     _twUI.ShowUI = TWON_DONTCARE8;
     _twRC = CallDSMEntry(&_dsmid
                 , &_dsid
                 , DG_CONTROL
                 , DAT_USERINTERFACE
                 , MSG_DISABLEDS
                 , (TW_MEMREF)&_twUI);
     
    // 关闭数据源 
     _twRC = CallDSMEntry(&_dsmid
                        , NULL
                        , DG_CONTROL
                        , DAT_IDENTITY
                        , MSG_CLOSEDS
                        , &_dsid);

    // 关闭数据源管理器 
     _twRC = CallDSMEntry(&_dsmid
                        , NULL
                        , DG_CONTROL
                        , DAT_PARENT
                        , MSG_CLOSEDSM
                        , &_hWnd);

    // 关闭窗口 
    DestroyWindow(_hWnd);

    // 释放管理库 
     FreeLibrary(_hDSM);
     
     return 0;
}

开心乐源
关注
专栏目录
TWAIN学习笔记006 探索TWAIN之DS连接及扫描
TomIsFondOfCats的博客
04-16 2799
前一篇中我们已经成功连接了DSM并找到了所有可用的DS。本文中我们试着连接其中一个DS并完成一次扫描。 第一步，选择并连接一个DS，将TWAIN状态由3转到4。 注：本文选用了测试用的DS - TWAIN2 FreeImage Software Scanner 前文提到每个DS的结构都是这样 typedef struct { TW_UINT32 Id; TW_VERSION ...
从 TWAIN 设备中扫描图像
微尘的专栏
11-09 1970
从 TWAIN 设备中扫描图像  一、简介    TWAIN 数据源管理程序 (DSM) 工业标准的软件库，用于从静态图像设备提取图像。绝大部分的扫描仪和数码相机都提供了 TWAIN 驱动程序，利用统一的 TWAIN 接口，应用程序可以非常方便地从这些设备中获取图像。二、使用步骤    互联网上关于 TWAIN 编程的中文资料很少，代码更是难找到，因为我不得不仔
TWAIN Specification Chapter 4 “Advanced Application Implementation”译——应用程序端的高级实现...
weixin_34179762的博客
07-13 224
本文是对TWAIN规范的第四章《应用程序端的高级实现》的翻译。因工作需要了解TWAIN，所以顺便译了一下。这是私人工作，您可以参考，但本人不保证不存在翻译的差错或不合宜。如果您发现有不妥的地方，敬请告之我(yedaoq@126.com)。 4.1 性能 应用程序与源进行性能协商的能力使人们能够控制TWAIN兼容的程序。在第四章“应用程序端的高级实现”中，你将看到对CAP_XFERCOUN...
TWAIN 操作
liutzh_2008的专栏
06-09 1644
<br />扫描程序设计 说明文档<br /> 一、TWAIN 的文件 组成<br /><br /> TWAIN共包括4个二进制文件。如果要使用该接口 ，就必须要保证他们被成功地安装在本地计算机上。<br /><br /> 文 件 名<br />  说 明<br />  <br /> TWAIN_32.DLL<br />  32位应用 程序的支持文件，32位程序使用TWAIN通讯必须使用该文件。<br />  <br /> TWAIN.DLL<br />  16位应用程序的支持
TWAIN扫描仪的接口名字是不是很怪？
qq_31042143的博客
12-31 353
TWAIN 是 Technology Without A Interesting Name 缩写，直译为没有“没有让人感兴趣名字的技术”，真是一个让人摸不着头脑的名字
Windows驱动开发学习记录 根据DeviceObject获取设备名称和硬件ID
时空之中的灵魂
05-24 329
根据DeviceObject获取设备名称和硬件ID
[原创]从 TWAIN 设备中扫描图像
Yonsm.NET
11-08 3207
 一、简介    TWAIN 数据源管理程序 (DSM) 工业标准的软件库，用于从静态图像设备提取图像。绝大部分的扫描仪和数码相机都提供了 TWAIN 驱动程序，利用统一的 TWAIN 接口，应用程序可以非常方便地从这些设备中获取图像。二、使用步骤    互联网上关于 TWAIN 编程的中文资料很少，代码更是难找到，因为我不得不仔细阅读了 www.twain.org 提供的 TWA
C#基于Twain协议调用扫描仪.zip
最新发布
12-29
本主题聚焦于一个特定的应用场景：通过Twain协议在C#中调用扫描仪。Twain（Technology Without An Interesting Name）是一个业界标准，允许应用程序与图像输入设备如扫描仪或摄像头进行通信。下面我们将深入探讨如何...
C#通过Twain连接打印机扫描仪,winform通过Twain连接扫描仪,c#Twain扫描仪
07-17
在IT行业中，TWAIN是一种广泛使用的接口标准，它允许应用程序（如C#的Winform应用）与图像输入设备，如扫描仪和某些类型的相机进行通信。这个标准使得开发者能够轻松地集成扫描功能到他们的应用程序中，而无需关心...
javatwain 使用扫描仪
10-17
本程序实现了在web页面上，用JAVA的方式，调用扫描仪进行扫描，并上传至远程服务器。并且可以设置扫描范围、扫描精度、以及扫描UI显示等！ 该版本在uploadpath参数设置为“http://localhost/xxx.action”，即使用...
.net C#Twain连接打印机扫描仪,winform通过Twain连接扫描仪,c#Twain扫描仪
09-12
这个过程涉及到TWAIN协议的理解、TWAIN库的使用以及Winform界面的交互设计。记住，每个扫描仪设备可能有不同的特性，因此在实际应用中可能需要根据具体设备调整扫描参数。同时，保持对TWAIN库更新的关注，以获取最新...
使用Twain调用扫描仪demo
11-12
【标题】"使用Twain调用扫描仪demo"是一个基于C#编程语言的示例项目，它演示了如何利用Twain接口与扫描仪进行交互，从而实现从物理扫描设备获取图像数据的功能。这个demo适用于Visual Studio 2008或更高版本的开发...
TWAIN学习笔记005 探索TWAIN之DSM连接
TomIsFondOfCats的博客
04-16 3207
接上文，我们从TWAIN状态的改变开始。 第一步，将状态1转到2，即从软件打开到获取在DSM的入口。 HMODULE gpDSM = 0; /**< global pointer to the DSM library */ DSMENTRYPROC gpDSM_Entry = 0; /**< global pointer to the D...
[最后版本]利用TWAIN－实现与图像输入设备的通讯--孙涛--
孙涛的专栏
12-07 7890
<!--google_ad_client = "pub-8303851053100251";google_ad_width = 468;google_ad_height = 60;google_ad_format = "468x60_as";google_ad_type = "text_image";google_ad_channel ="";//--><script
利用TWAIN－实现与图像输入设备的通讯
05-04 2837
利用TWAIN－实现与图像输入设备的通讯TWAIN工作组是一个非盈利的国际组织。它旨在提供一个统一的标准接口，通过该接口就可以实现应用程序与图像输入设备间的通讯。其实该标准目前已经成为了应用程序与图像输入设备间通讯的事实标准。TWAIN的文件组成TWAIN共包括4个二进制文件。如果要使用该接口，就必须要保证他们被成功地安装在本地计算机上。文件名TWAIN_32.DLL32位
TWAIN 操作教程
02-03 5049
  一、TWAIN的文件组成TWAIN共包括4个二进制文件。如果要使用该接口，就必须要保证他们被成功地安装在本地计算机上。 文 件 名说 明TWAIN_32.DLL32位应用程序的支持文件，32位程序使用TWAIN通讯必须使用该文件。TWAIN.DLL
iperf测试udp带宽
热门推荐
开心乐源的专栏
01-18 3万+
客户端命令行：iperf -u -c 211.160.178.10 -p 20001 -l 1380 -t 10 -B 172.16.28.173 -t 10 -i 1 -b 1800K 服务器命令行：iperf.exe -s -u -i 1 -p 8080 -l 1380 /* * Bandwidth Test with iperf * * Client Command L
TWAIN 2.1协议详解：应用、管理器与设备通讯
"TWAIN 2.1协议中文版提供了统一的应用程序与图像输入设备（如打印机、扫描仪）之间的通讯接口。这个非盈利的国际组织制定的标准已经成为事实上的行业标准。协议包含四个关键文件，用于不同类型的程序和数据源之间的...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值