lmh188
/
code_app
mirror of http://192.168.10.5:8099/sane/code_app.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
code_app/sdk/oldwebscan/hgscannersdk/HG_SCANNER_API.cpp

934 lines
34 KiB
C++
Raw Normal View History

提交旧版websdk
2022-11-18 01:12:13 +00:00
#include "HG_SCANNER_API.h"
#include <stdio.h>
#include <thread>
#include <memory>
#include <string>
#include <iostream>
#include "scannerlib/HGScannerLib.h"
#include <map>
#include "base/HGImage.h"
#include "imgfmt/HGImgFmt.h"
#include "huagao/hgscanner_error.h"
#include <vector>
调整老版sdk接口调整c#demo
2022-11-19 03:49:41 +00:00
#include <opencv2/opencv.hpp>
#include "assert.h"
提交旧版websdk
2022-11-18 01:12:13 +00:00
using namespace std;
HG_SCANPARAMS m_params;
std::string img_type_ = ".jpg";
void* m_obj_usb = nullptr;
void* m_obj_img = nullptr;
static const char* SDKVersion = "1.22.9.30";
调整老版sdk接口调整c#demo
2022-11-19 03:49:41 +00:00
char deviceList[60];
新增设置图像压缩率
2022-11-22 09:05:53 +00:00
unsigned int compression_data = 80;
提交旧版websdk
2022-11-18 01:12:13 +00:00
HG_OnDevice_Event_Callback m_callback_OnDevcie_Event = nullptr;
HG_OnImage_Callback m_callback_OnImage_Event = nullptr;
unsigned int m_scannum = 0;
void callback_USBEvent(int conditioncode, void* obj)
{
if (m_callback_OnDevcie_Event)
m_callback_OnDevcie_Event((HG_STATUSCODE)conditioncode, m_obj_usb);
}
//有图事件回调
static int indeximg = 10;
static void HGAPI DeviceScanImageFunc(HGLibDevice device, HGLibImage image, HGPointer param)
{
if (image == NULL)
{
return;
}
HGImageInfo info;
uint8_t* data = NULL;
HG_IMG img;
HGBase_GetImageInfo((HGImage)image, &info);
HGImage image2 = NULL;
if (info.type == HGBASE_IMGTYPE_BINARY)
{
HGBase_CloneImage((HGImage)image, HGBASE_IMGTYPE_GRAY, 0, &image2);
if (NULL == image2)
{
return;
}
}
else
image2 = (HGImage)image;
HGBase_GetImageInfo(image2, &info);
assert(info.type == HGBASE_IMGTYPE_RGB || info.type == HGBASE_IMGTYPE_GRAY || info.type == HGBASE_IMGTYPE_BINARY);
HGBase_GetImageData(image2, &data);
//HGImgFmt_SaveImage(image2, 0, 0, "D:/123.tif");
vector<unsigned char> bmpdata;
int channels = (info.type == HGBASE_IMGTYPE_RGB) ? 3 : 1;
cv::Mat mat = cv::Mat(info.height, info.width, CV_8UC(channels), data, info.widthStep);
if (channels == 3)
{
cv::cvtColor(mat, mat, cv::COLOR_RGB2BGR);
}
调整老版sdk接口调整c#demo
2022-11-19 03:49:41 +00:00
新增设置图像压缩率
2022-11-22 09:05:53 +00:00
vector<int>compress;
if (img_type_ == ".jpg")
compress.push_back(CV_IMWRITE_JPEG_QUALITY);
else if (img_type_ == ".png")
compress.push_back(CV_IMWRITE_PNG_COMPRESSION);
compress.push_back(compression_data);
提交旧版websdk
2022-11-18 01:12:13 +00:00
新增设置图像压缩率
2022-11-22 09:05:53 +00:00
cv::imencode(img_type_, mat, bmpdata, compress); //图像压缩参数，该参数取值范围为0-100，数值越高，图像质量越高
提交旧版websdk
2022-11-18 01:12:13 +00:00
img.height = mat.rows; //info.height
img.width = mat.cols;// info.width;
img.pimgdata = bmpdata.data();
img.bufferlength = bmpdata.size();
//img.bufferlength = mat.rows * mat.cols;
img.bitdepth = (mat.channels() == 3) ? 24 : 8;
img.bytesperline = mat.step;
m_callback_OnImage_Event(&img, m_obj_img);
if (image2 != (HGImage)image)
{
HGBase_DestroyImage(image2);
}
}
//扫描状态事件回调
static void HGAPI DeviceScanEvent(HGLibDevice device, HGUInt event, HGBool err, const HGChar* info, HGPointer param)
{
if (m_callback_OnDevcie_Event == nullptr)
{
return;
}
switch (event)
{
case HGLIB_DEVSCAN_EVENT_BEGIN:
m_callback_OnDevcie_Event(HG_STATUS_SCANNING, m_obj_usb);
break;
case HGLIB_DEVSCAN_EVENT_END:
m_callback_OnDevcie_Event(HG_STATUS_SCANSTOP, m_obj_usb);
break;
case HGLIB_DEVSCAN_EVENT_INFO:
{
if (err)
{
if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER) == 0)
m_callback_OnDevcie_Event(HG_STATUS_NO_FEED, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_COVER_OPENNED) == 0)
m_callback_OnDevcie_Event(HG_STATUS_COVEROPEN, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_FEEDING_PAPER) == 0)
m_callback_OnDevcie_Event(HG_STATUS_FEED_IN_ERROR, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_PAPER_JAMMED) == 0)
m_callback_OnDevcie_Event(HG_STATUS_PAPER_JAM, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_STAPLE_ON) == 0)
m_callback_OnDevcie_Event(HG_STATUS_DETECT_STAPLE, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_DOUBLE_FEEDING) == 0)
m_callback_OnDevcie_Event(HG_STATUS_DETECT_DOUBLE_FEED, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_SIZE_CHECK) == 0)
m_callback_OnDevcie_Event(HG_STATUS_DETECT_SIZECHECKERROR, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_PAPER_SKEW) == 0)
m_callback_OnDevcie_Event(HG_STATUS_PAPER_SKEW, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_USB_INIT_FAILED) == 0)
m_callback_OnDevcie_Event(HG_STATUS_USBERROR, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_TIMEOUT) == 0)
m_callback_OnDevcie_Event(HG_STATUS_TIMEOUT, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_DOGEAR) == 0)
m_callback_OnDevcie_Event(HG_STATUS_DOGEAR, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_NO_IMAGE) == 0)
m_callback_OnDevcie_Event(HG_STATUS_AQULRE_ERROR, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_COUNT_MODE) == 0)
m_callback_OnDevcie_Event(HG_STATUS_COUNTMODE, m_obj_usb);
else if (strcmp(info, STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING) == 0)
m_callback_OnDevcie_Event(HG_STATUS_SLEEP, m_obj_usb);
}
break;
}
}
}
void HG_Init()
{
//初始化
m_params.PixelType = HG_Gray;
m_params.MultiOutput = HG_Unused;
m_params.PaperSize = HG_None;
m_params.PaperAlign = HG_Rot0;
m_params.Resolution = 200;
m_params.ScanSide.Duplex = 1;
m_params.ScanSide.DiscardBlank = 0;
m_params.ScanSide.DiscardBlankVince = 0;
m_params.ScanSide.Fold = 0;
m_params.ScanSide.SwitchFrontBack = 0;
m_params.ImageProcess.AutoCrop = 1;
m_params.ImageProcess.Noise = 8;
m_params.ImageProcess.Is_convex = true;
m_params.ImageProcess.Indent = 5;
m_params.ImageProcess.NosieDetach = 6;
m_params.ImageProcess.Brightness = 128;
m_params.ImageProcess.Contrast = 4;
m_params.ImageProcess.Gamma = 1.0f;
m_params.ImageProcess.FillBlackRect = 1;
m_params.ImageProcess.AutoDescrew = 0;
m_params.ImageProcess.RefuseInflow = 0;
m_params.ImageProcess.FillHole.enable = 0;
m_params.ImageProcess.FillHole.ratio = 0;
m_params.ImageProcess.Filter = HG_FILTER_NONE;
m_params.ImageProcess.ColorCorrection = 0;
m_params.ImageProcess.RemoveMorr = 0;
m_params.ImageProcess.ErrorExtention = 0;
m_params.ImageProcess.NosieDetach = 6;
m_params.ImageProcess.TextureRemove = 0;
m_params.ImageProcess.Indent = 5;
m_params.ImageProcess.Noise = 8;
m_params.ImageProcess.AutoCrop_threshold = 40;
m_params.ImageProcess.Is_convex = 1;
m_params.ImageProcess.SharpenType = HG_STNone;
m_params.ImageProcess.MultiOutFilterRed = 0;
m_params.ImageProcess.AnswerSheetFilterRed = 0;
m_params.ImageProcess.Orentation = HG_ROTATE_NONE;
m_params.ImageProcess.BackRotate180 = 0;
m_params.ImageProcess.SplitImage = 0;
m_params.HardwareParam.bindingDetection = 0;
m_params.HardwareParam.capturepixtype = 48;
m_params.HardwareParam.doubleFeedDetection = 1;
HGBool ret = HGLib_InitDevice(NULL, 0);
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
printf("ret:%d\r\n", ret);
}
void HG_ImgSaveType(const char* img_type)
{
新增设置图像压缩率
2022-11-22 09:05:53 +00:00
if (!img_type)
return;
if ((strcmp(img_type, ".jpg") == 0) || (strcmp(img_type, ".png") == 0))
提交旧版websdk
2022-11-18 01:12:13 +00:00
img_type_ = img_type;
新增设置图像压缩率
2022-11-22 09:05:53 +00:00
else
{
img_type_ = ".jpg";
cout << "error unsupport image type,default image buffer will be jpg format" << endl;
}
if ((strcmp(img_type, ".png") == 0))
{
compression_data = 3;
提交旧版websdk
2022-11-18 01:12:13 +00:00
}
}
char* HG_GetDevices(char* strSeperator)
{
HGChar** devNameList = HGLib_GetDeviceNameList();
if (devNameList == NULL)
{
cout << "devNameList is null " << endl;
return NULL;
}
strcpy(deviceList, devNameList[0]);
HGLib_ReleaseDeviceNameList(devNameList);
return deviceList;
}
HG_Scanner_Handle HG_OpenScanner(char* scannername)
{
return (HG_Scanner_Handle)HGLib_OpenDevice(scannername);
}
void HG_CloseScanner(HG_Scanner_Handle pScanner)
{
HGLib_CloseDevice((HGLibDevice)pScanner);
}
调整老版sdk接口调整c#demo
2022-11-19 03:49:41 +00:00
int GetDeviceParam(HG_Scanner_Handle pScanner)
提交旧版websdk
2022-11-18 01:12:13 +00:00
{
HGUInt count = 0;
HGLibDeviceParamGroup* group = HGLib_GetDeviceParamGroupList((HGLibDevice)pScanner, &count);
if (NULL == group)
{
return -1;
}
for (HGUInt i = 0; i < count; i++)
{
for (HGUInt j = 0; j < group[i].paramCount; ++j)
{
const HGLibDeviceParam* devParam = &group[i].param[j];
if (devParam->option == HGLIB_OPTION_NAME_YSMS && devParam->type == HGLIB_OPTION_VALUETYPE_ENUM)
{
if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_YSMS_24WCS)
m_params.PixelType = HG_RGB;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_YSMS_256JHD)
m_params.PixelType = HG_Gray;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_YSMS_HB)
m_params.PixelType = HG_BlackWhite;
}
else if (devParam->option == HGLIB_OPTION_NAME_DLSCLX && devParam->type == HGLIB_OPTION_VALUETYPE_ENUM)
{
if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_DLSCLX_W)
m_params.MultiOutput = HG_Unused;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_DLSCLX_CS_HD_HB)
m_params.MultiOutput = HG_All;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_DLSCLX_CS_HD)
m_params.MultiOutput = HG_ColorGray;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_DLSCLX_CS_HB)
m_params.MultiOutput = HG_ColorBw;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_DLSCLX_HD_HB)
m_params.MultiOutput = HG_GrayBw;
}
else if (devParam->option == HGLIB_OPTION_NAME_HDHHBTX_CS && devParam->type == HGLIB_OPTION_VALUETYPE_ENUM)
{
if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_BCS)
m_params.ImageProcess.Filter = HG_FILTER_NONE;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_CHS)
m_params.ImageProcess.Filter = HG_FILTER_RED;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_CLS)
m_params.ImageProcess.Filter = HG_FILTER_GREEN;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_CHULANSE)
m_params.ImageProcess.Filter = HG_FILTER_BLUE;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_HSZQ)
m_params.ImageProcess.Filter = HG_ENHANCE_RED;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_LSZQ)
m_params.ImageProcess.Filter = HG_ENHANCE_GREEN;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_LANSEZENGQIANG)
m_params.ImageProcess.Filter = HG_ENHANCE_BLUE;
}
else if (devParam->option == HGLIB_OPTION_NAME_24WCSTX_DLSCCH && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.ImageProcess.MultiOutFilterRed = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_24WCSTX_DTKCH && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.ImageProcess.AnswerSheetFilterRed = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_RHYMH && devParam->type == HGLIB_OPTION_VALUETYPE_ENUM)
{
if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_RHYMH_W)
m_params.ImageProcess.SharpenType = HG_STNone;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_RHYMH_RH)
m_params.ImageProcess.SharpenType = HG_Sharpen;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_RHYMH_JYBRH)
m_params.ImageProcess.SharpenType = HG_SharpenMore;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_RHYMH_MH)
m_params.ImageProcess.SharpenType = HG_Blur;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_RHYMH_JYBMH)
m_params.ImageProcess.SharpenType = HG_BlurMore;
}
else if (devParam->option == HGLIB_OPTION_NAME_QCMW && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.ImageProcess.RemoveMorr = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_CWW && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.ImageProcess.TextureRemove = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_HBTXZDYH && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.ImageProcess.NosieDetach = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_ZZCC && devParam->type == HGLIB_OPTION_VALUETYPE_ENUM)
{
if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_A3)
{
m_params.PaperSize = HG_A3;
m_params.PaperAlign = HG_Rot0;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_A4)
{
m_params.PaperSize = HG_A4;
m_params.PaperAlign = HG_Rot0;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_A4HX)
{
m_params.PaperSize = HG_A4;
m_params.PaperAlign = HG_Rot270;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_A5)
{
m_params.PaperSize = HG_A5;
m_params.PaperAlign = HG_Rot0;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_A5HX)
{
m_params.PaperSize = HG_A5;
m_params.PaperAlign = HG_Rot270;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_A6)
{
m_params.PaperSize = HG_A6;
m_params.PaperAlign = HG_Rot0;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_A6HX)
{
m_params.PaperSize = HG_A6;
m_params.PaperAlign = HG_Rot270;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_B4)
{
m_params.PaperSize = HG_B4;
m_params.PaperAlign = HG_Rot0;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_B5)
{
m_params.PaperSize = HG_B5;
m_params.PaperAlign = HG_Rot0;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_B5HX)
{
m_params.PaperSize = HG_B5;
m_params.PaperAlign = HG_Rot270;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_B6)
{
m_params.PaperSize = HG_B6;
m_params.PaperAlign = HG_Rot0;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_B6HX)
{
m_params.PaperSize = HG_B6;
m_params.PaperAlign = HG_Rot270;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_Letter)
{
m_params.PaperSize = HG_USLetter;
m_params.PaperAlign = HG_Rot0;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_LetterHX)
{
m_params.PaperSize = HG_USLetter;
m_params.PaperAlign = HG_Rot270;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_LEGAL)
{
m_params.PaperSize = HG_USLegal;
m_params.PaperAlign = HG_Rot0;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_ZZCC_ZDSMCC)
{
m_params.PaperSize = HG_MaxSize;
m_params.PaperAlign = HG_Rot0;
}
}
else if (devParam->option == HGLIB_OPTION_NAME_SMYM && devParam->type == HGLIB_OPTION_VALUETYPE_ENUM)
{
if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_SMYM_DM)
m_params.ScanSide.Duplex = 0;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_SMYM_SM)
m_params.ScanSide.Duplex = 1;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_SMYM_TGKBYTY)
{
m_params.ScanSide.DiscardBlank = 1;
m_params.ScanSide.DiscardBlankVince = 0;
m_params.ScanSide.Fold = 0;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_SMYM_TGKBYFPZ)
{
m_params.ScanSide.DiscardBlank = 0;
m_params.ScanSide.DiscardBlankVince = 1;
m_params.ScanSide.Fold = 0;
}
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_SMYM_DZ)
{
m_params.ScanSide.Fold = 1;
m_params.ScanSide.DiscardBlank = 0;
m_params.ScanSide.DiscardBlankVince = 0;
}
}
else if (devParam->option == HGLIB_OPTION_NAME_TGKBYLMD && devParam->type == HGLIB_OPTION_VALUETYPE_INT)
m_params.ImageProcess.DiscardBlankThre = devParam->intValue;
else if (devParam->option == HGLIB_OPTION_NAME_FBL && devParam->type == HGLIB_OPTION_VALUETYPE_INT)
m_params.Resolution = devParam->intValue;
else if (devParam->option == HGLIB_OPTION_NAME_JHZFM && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.ScanSide.SwitchFrontBack = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_TXCF && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.ImageProcess.SplitImage = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_ZDJP && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.ImageProcess.AutoDescrew = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_LDZ && devParam->type == HGLIB_OPTION_VALUETYPE_INT)
m_params.ImageProcess.Brightness = devParam->intValue;
else if (devParam->option == HGLIB_OPTION_NAME_DBD && devParam->type == HGLIB_OPTION_VALUETYPE_INT)
m_params.ImageProcess.Contrast = devParam->intValue;
else if (devParam->option == HGLIB_OPTION_NAME_GMZ && devParam->type == HGLIB_OPTION_VALUETYPE_DOUBLE)
m_params.ImageProcess.Gamma = devParam->doubleValue;
else if (devParam->option == HGLIB_OPTION_NAME_XCHK && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.ImageProcess.FillBlackRect = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_BYSJ && devParam->type == HGLIB_OPTION_VALUETYPE_INT)
m_params.ImageProcess.Indent = devParam->intValue;
else if (devParam->option == HGLIB_OPTION_NAME_FZST && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.ImageProcess.RefuseInflow = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_CSBJC && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.HardwareParam.doubleFeedDetection = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_ZDJC && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.HardwareParam.bindingDetection = devParam->boolValue;
else if (devParam->option == HGLIB_OPTION_NAME_WGFX && devParam->type == HGLIB_OPTION_VALUETYPE_ENUM)
{
if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_WGFX_0)
m_params.ImageProcess.Orentation = HG_ROTATE_NONE;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_WGFX_90)
m_params.ImageProcess.Orentation = HG_ROTATE_270;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_WGFX_180)
m_params.ImageProcess.Orentation = HG_ROTATE_180;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_WGFX__90)
m_params.ImageProcess.Orentation = HG_ROTATE_90;
else if (devParam->enumValue == HGLIB_OPTION_ENUMVALUE_WGFX_ZDWBFXSB)
m_params.ImageProcess.Orentation = HG_AUTOTEXT_DETECT;
}
else if (devParam->enumValue == HGLIB_OPTION_NAME_BMXZ180 && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
m_params.ImageProcess.BackRotate180 = devParam->boolValue;
}
}
HGLib_ReleaseDeviceParamGroupList(group, count);
return 0;
}
调整老版sdk接口调整c#demo
2022-11-19 03:49:41 +00:00
int SetDeviceParam(HG_Scanner_Handle pScanner)
提交旧版websdk
2022-11-18 01:12:13 +00:00
{
HGUInt enumValue = 0;
HGBool boolValue = false;
HGInt intValue = 0;
HGDouble doubleValue = 0.0f;
if (m_params.PixelType == HG_BlackWhite)
{
enumValue = HGLIB_OPTION_ENUMVALUE_YSMS_HB;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_YSMS, &enumValue);
}
else if (m_params.PixelType == HG_Gray)
{
enumValue = HGLIB_OPTION_ENUMVALUE_YSMS_256JHD;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_YSMS, &enumValue);
}
else if (m_params.PixelType == HG_RGB)
{
enumValue = HGLIB_OPTION_ENUMVALUE_YSMS_24WCS;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_YSMS, &enumValue);
}
if (m_params.MultiOutput == HG_Unused)
{
boolValue = false;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_DLSC, &boolValue);
}
else
{
boolValue = true;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_DLSC, &boolValue);
}
if (m_params.MultiOutput == HG_All)
{
enumValue = HGLIB_OPTION_ENUMVALUE_DLSCLX_CS_HD_HB;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_DLSCLX, &enumValue);
}
else if (m_params.MultiOutput == HG_ColorGray)
{
enumValue = HGLIB_OPTION_ENUMVALUE_DLSCLX_CS_HD;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_DLSCLX, &enumValue);
}
else if (m_params.MultiOutput == HG_ColorBw)
{
enumValue = HGLIB_OPTION_ENUMVALUE_DLSCLX_CS_HB;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_DLSCLX, &enumValue);
}
else if (m_params.MultiOutput == HG_GrayBw)
{
enumValue = HGLIB_OPTION_ENUMVALUE_DLSCLX_HD_HB;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_DLSCLX, &enumValue);
}
if (m_params.ImageProcess.Filter == HG_FILTER_NONE)
{
enumValue = HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_BCS;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_HDHHBTX_CS, &enumValue);
}
else if (m_params.ImageProcess.Filter == HG_FILTER_RED)
{
enumValue = HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_CHS;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_HDHHBTX_CS, &enumValue);
}
else if (m_params.ImageProcess.Filter == HG_FILTER_GREEN)
{
enumValue = HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_CLS;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_HDHHBTX_CS, &enumValue);
}
else if (m_params.ImageProcess.Filter == HG_FILTER_BLUE)
{
enumValue = HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_CHULANSE;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_HDHHBTX_CS, &enumValue);
}
else if (m_params.ImageProcess.Filter == HG_ENHANCE_RED)
{
enumValue = HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_HSZQ;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_HDHHBTX_CS, &enumValue);
}
else if (m_params.ImageProcess.Filter == HG_ENHANCE_GREEN)
{
enumValue = HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_LSZQ;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_HDHHBTX_CS, &enumValue);
}
else if (m_params.ImageProcess.Filter == HG_ENHANCE_BLUE)
{
enumValue = HGLIB_OPTION_ENUMVALUE_HDHHBTX_CS_LANSEZENGQIANG;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_HDHHBTX_CS, &enumValue);
}
boolValue = m_params.ImageProcess.MultiOutFilterRed;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_24WCSTX_DLSCCH, &boolValue);
boolValue = m_params.ImageProcess.AnswerSheetFilterRed;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_24WCSTX_DTKCH, &boolValue);
boolValue = m_params.ImageProcess.RemoveMorr;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_QCMW, &boolValue);
boolValue = m_params.ImageProcess.TextureRemove;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_CWW, &boolValue);
boolValue = m_params.ImageProcess.NosieDetach;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_HBTXZDYH, &boolValue);
if (m_params.ImageProcess.SharpenType == HG_STNone)
{
enumValue = HGLIB_OPTION_ENUMVALUE_RHYMH_W;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_RHYMH, &enumValue);
}
else if (m_params.ImageProcess.SharpenType == HG_Sharpen)
{
enumValue = HGLIB_OPTION_ENUMVALUE_RHYMH_RH;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_RHYMH, &enumValue);
}
else if (m_params.ImageProcess.SharpenType == HG_SharpenMore)
{
enumValue = HGLIB_OPTION_ENUMVALUE_RHYMH_JYBRH;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_RHYMH, &enumValue);
}
else if (m_params.ImageProcess.SharpenType == HG_Blur)
{
enumValue = HGLIB_OPTION_ENUMVALUE_RHYMH_MH;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_RHYMH, &enumValue);
}
else if (m_params.ImageProcess.SharpenType == HG_BlurMore)
{
enumValue = HGLIB_OPTION_ENUMVALUE_RHYMH_JYBMH;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_RHYMH, &enumValue);
}
if (m_params.PaperSize == HG_A3 && m_params.PaperAlign == HG_Rot0)
{
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_A3;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZZCC, &enumValue);
}
else if (m_params.PaperSize == HG_A4 && m_params.PaperAlign == HG_Rot0)
{
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_A4;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZZCC, &enumValue);
}
else if (m_params.PaperSize == HG_A4 && m_params.PaperAlign == HG_Rot270)
{
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_A4HX;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZZCC, &enumValue);
}
else if (m_params.PaperSize == HG_A5 && m_params.PaperAlign == HG_Rot0)
{
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_A5;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZZCC, &enumValue);
}
else if (m_params.PaperSize == HG_A5 && m_params.PaperAlign == HG_Rot270)
{
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_A5HX;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZZCC, &enumValue);
}
else if (m_params.PaperSize == HG_A6 && m_params.PaperAlign == HG_Rot0)
{
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_A6;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZZCC, &enumValue);
}
else if (m_params.PaperSize == HG_A6 && m_params.PaperAlign == HG_Rot270)
{
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_A6HX;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZZCC, &enumValue);
}
else if (m_params.PaperSize == HG_USLetter && m_params.PaperAlign == HG_Rot0)
{
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_Letter;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZZCC, &enumValue);
}
else if (m_params.PaperSize == HG_USLetter && m_params.PaperAlign == HG_Rot270)
{
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_LetterHX;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZZCC, &enumValue);
}
else if (m_params.PaperSize == HG_USLegal)
{
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_LEGAL;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZZCC, &enumValue);
}
else if (m_params.PaperSize == HG_MaxSize)
{
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_ZDSMCC;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZZCC, &enumValue);
}
if (m_params.ScanSide.DiscardBlank == 1)
{
enumValue = HGLIB_OPTION_ENUMVALUE_SMYM_TGKBYTY;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_SMYM, &enumValue);
}
else if (m_params.ScanSide.DiscardBlankVince == 1)
{
enumValue = HGLIB_OPTION_ENUMVALUE_SMYM_TGKBYFPZ;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_SMYM, &enumValue);
}
else if (m_params.ScanSide.Fold == 1)
{
enumValue = HGLIB_OPTION_ENUMVALUE_SMYM_DZ;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_SMYM, &enumValue);
}
enumValue = m_params.ScanSide.Duplex == 1 ? HGLIB_OPTION_ENUMVALUE_SMYM_SM : HGLIB_OPTION_ENUMVALUE_SMYM_DM;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_SMYM, &enumValue);
intValue = m_params.ImageProcess.DiscardBlankThre;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_TGKBYLMD, &intValue);
intValue = m_params.Resolution;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_FBL, &intValue);
boolValue = m_params.ScanSide.SwitchFrontBack;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_JHZFM, &boolValue);
boolValue = m_params.ImageProcess.SplitImage;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_TXCF, &boolValue);
boolValue = m_params.ImageProcess.AutoDescrew;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZDJP, &boolValue);
intValue = m_params.ImageProcess.Brightness;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_LDZ, &intValue);
intValue = m_params.ImageProcess.Contrast;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_DBD, &intValue);
doubleValue = m_params.ImageProcess.Gamma;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_GMZ, &doubleValue);
boolValue = m_params.ImageProcess.FillBlackRect;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_XCHK, &boolValue);
intValue = m_params.ImageProcess.Indent;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_BYSJ, &intValue);
boolValue = m_params.ImageProcess.RefuseInflow;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_FZST, &boolValue);
boolValue = m_params.HardwareParam.doubleFeedDetection;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_CSBJC, &boolValue);
boolValue = m_params.HardwareParam.bindingDetection;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_ZDJC, &boolValue);
if (m_params.ImageProcess.Orentation == HG_ROTATE_NONE)
{
enumValue = HGLIB_OPTION_ENUMVALUE_WGFX_0;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_WGFX, &enumValue);
}
else if (m_params.ImageProcess.Orentation == HG_ROTATE_270)
{
enumValue = HGLIB_OPTION_ENUMVALUE_WGFX_90;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_WGFX, &enumValue);
}
else if (m_params.ImageProcess.Orentation == HG_ROTATE_180)
{
enumValue = HGLIB_OPTION_ENUMVALUE_WGFX_180;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_WGFX, &enumValue);
}
else if (m_params.ImageProcess.Orentation == HG_ROTATE_90)
{
enumValue = HGLIB_OPTION_ENUMVALUE_WGFX__90;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_WGFX, &enumValue);
}
else if (m_params.ImageProcess.Orentation == HG_AUTOTEXT_DETECT)
{
enumValue = HGLIB_OPTION_ENUMVALUE_WGFX_ZDWBFXSB;
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_WGFX, &enumValue);
}
boolValue = m_params.ImageProcess.BackRotate180;
HGBool ret = HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_BMXZ180, &boolValue);
return ret ? 0 : -1;
}
int HG_Get_Scan_Params(HG_Scanner_Handle pScanner, HG_SCANPARAMS* param)
{
if (NULL == param)
return -1;
调整老版sdk接口调整c#demo
2022-11-19 03:49:41 +00:00
GetDeviceParam(pScanner);
提交旧版websdk
2022-11-18 01:12:13 +00:00
*param = m_params;
return 0;
}
int HG_Set_Scan_Params(HG_Scanner_Handle pScanner, HG_SCANPARAMS param)
{
m_params = param;
调整老版sdk接口调整c#demo
2022-11-19 03:49:41 +00:00
int ret = SetDeviceParam(pScanner);
提交旧版websdk
2022-11-18 01:12:13 +00:00
return ret;
}
int HG_StartScan(HG_Scanner_Handle pScanner, int count)
{
HGBool ret = false;
HGUInt enumValue = HGLIB_OPTION_ENUMVALUE_SMZS_LXSM;
if (count == -1 || count == 65536)
{
enumValue = HGLIB_OPTION_ENUMVALUE_SMZS_LXSM;
ret = HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_SMZS, &enumValue);
}
else if(count >= 1)
{
enumValue = HGLIB_OPTION_ENUMVALUE_SMZS_SMZDZS;
ret = HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_SMZS, &enumValue);
HGInt intValue = count;
ret = HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_SMSL, &intValue);
}
else
{
return -1;
}
if (!ret)
{
return -1;
}
return HGLib_StartDeviceScan((HGLibDevice)pScanner, DeviceScanEvent, 0, DeviceScanImageFunc, 0) ? 0 : -1;
}
int HG_StopScan(HG_Scanner_Handle pScanner)
{
新增异步停止
2022-11-22 01:13:25 +00:00
return HGLib_StopDeviceScanAsyn((HGLibDevice)pScanner) ? 0 : -1;
提交旧版websdk
2022-11-18 01:12:13 +00:00
}
int HG_Is_Running(HG_Scanner_Handle pScanner)
{
return 0;
}
int HG_Is_FeederLoaded(HG_Scanner_Handle pScanner)
{
return HGLib_DeviceIsPaperOn((HGLibDevice)pScanner) ? 1 : 0;
}
void HG_Set_AquireImg_callback(HG_OnImage_Callback onimg_callback, void* obj)
{
m_obj_img = obj;
m_callback_OnImage_Event = onimg_callback;
}
void HG_Set_OnDeviceEvent_callback(HG_OnDevice_Event_Callback onevent_callback, void* obj)
{
m_obj_usb = obj;
m_callback_OnDevcie_Event = onevent_callback;
}
char* HG_GetSDKVersion()
{
return const_cast<char*>(SDKVersion);
}
const char* HG_GetSerialNum(HG_Scanner_Handle pScanner)
{
static HGChar sn[256] = { 0 };
memset(sn, 0, sizeof(sn));
HGUInt maxLen = 256;
HGLib_GetDeviceSN((HGLibDevice)pScanner, sn, maxLen);
return sn;
}
const char* HG_GetFwVersion(HG_Scanner_Handle pScanner)
{
static HGChar fwVersion[256] = { 0 };
memset(fwVersion, 0, sizeof(fwVersion));
HGUInt maxLen = 256;
HGLib_GetDeviceFWVersion((HGLibDevice)pScanner, fwVersion, maxLen);
return fwVersion;
}
int HG_GET_IS_SLEEP_STATUS(HG_Scanner_Handle pScanner)
{
/*if (pScanner == nullptr || m_scanner.get() == nullptr || pScanner != m_scanner.get())
return -1;
StopWatch sw;
auto ret = m_scanner->get_is_sleep();
if (ret == 0)
return 0;
while (1)
{
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
ret = m_scanner->get_is_sleep();
if(sw.elapsed_s() > 10)
return 1;
if(ret == 0)*/
return 0;
//}
}
int HG_REBOOT_DEVICE(HG_Scanner_Handle pScanner)
{
return HGLib_DeviceRestart(HGLibDevice(pScanner)) ? 1 : -1;
}
新增设置图像压缩率
2022-11-22 09:05:53 +00:00
void HG_SET_IMG_COMPRESSION(unsigned int compressiondata)
{
if (img_type_ ==".png")
{
compressiondata /= 10;
}
compression_data = compressiondata;
}
提交旧版websdk
2022-11-18 01:12:13 +00:00
/*void img2tiff(TIFF* tif_file, int pageIndex, cv::Mat image, int jpg_quality)
{
if (!tif_file)
return;
TIFFSetDirectory(tif_file, static_cast<ushort>(pageIndex));//set current operation page number
TIFFSetField(tif_file, TIFFTAG_SUBFILETYPE, FILETYPE_PAGE);//set page type
TIFFSetField(tif_file, TIFFTAG_IMAGEWIDTH, image.cols);//set page width
TIFFSetField(tif_file, TIFFTAG_IMAGELENGTH, image.rows);//set page height
TIFFSetField(tif_file, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);//set store style
TIFFSetField(tif_file, TIFFTAG_COMPRESSION, COMPRESSION_JPEG);//set compress type
TIFFSetField(tif_file, TIFFTAG_XRESOLUTION, 200.0);
TIFFSetField(tif_file, TIFFTAG_YRESOLUTION, 200.0);
//if (ctype == COMPRESSION_JPEG)
TIFFSetField(tif_file, TIFFTAG_JPEGQUALITY, 80);//set jpeg compress quality
int depth = image.channels();
if (depth == 1)//gray
{
TIFFSetField(tif_file, TIFFTAG_SAMPLESPERPIXEL, 1);//set every pixel channels
TIFFSetField(tif_file, TIFFTAG_BITSPERSAMPLE, 8);//set every channel depth
TIFFSetField(tif_file, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);//set color type
}
else//color
{
TIFFSetField(tif_file, TIFFTAG_SAMPLESPERPIXEL, 3);//set every pixel channels
TIFFSetField(tif_file, TIFFTAG_BITSPERSAMPLE, 8);//set every channel depth
TIFFSetField(tif_file, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);//set color type
}
uchar* imgData = image.data;//get image data
for (int i = 0; i < image.rows; i++)//write tiff by lines
TIFFWriteScanline(tif_file, imgData + image.step * i, static_cast<uint>(i));
TIFFWriteDirectory(tif_file);//write page
}*/
DLL_HG_SCHANNER_API int HG_Create_MultiTiff(char** srcFiles, int srcnum, char* dstFile)
{
/*int ret = 0;
if (dstFile == nullptr || srcFiles == nullptr)
return ret;
std::string dstfilepath(dstFile);
LOG("dstFile = %s \n", dstfilepath.c_str());
TIFF* tif_file = TIFFOpen(dstfilepath.c_str(), "w");
if (!tif_file)
return ret;
int pageIndex = 0;//init page number
for (int i = 0; i < srcnum; i++)//convert imgs to tiff loop
{
std::string filepath(srcFiles[i]);
if (filepath.length() > 4)
{
cv::Mat img = cv::imread(srcFiles[i], cv::ImreadModes::IMREAD_ANYCOLOR);
if (!img.empty())
{
if (img.channels() == 3)
cv::cvtColor(img, img, CV_BGR2RGB);
img2tiff(tif_file, pageIndex, img, 80);
pageIndex++;
}
}
}
TIFFClose(tif_file);*/
return -1;
}