1068 lines
38 KiB
C++
1068 lines
38 KiB
C++
#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>
|
||
#include <opencv2/opencv.hpp>
|
||
#include "assert.h"
|
||
#include <tiff.h>
|
||
#include <tiffio.h>
|
||
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 = "4.52.11.21";
|
||
char deviceList[60];
|
||
unsigned int compression_data = 80;
|
||
HG_OnDevice_Event_Callback m_callback_OnDevcie_Event = nullptr;
|
||
HG_OnImage_Callback m_callback_OnImage_Event = nullptr;
|
||
unsigned int m_scannum = 0;
|
||
|
||
void G4TiffExcept(bool condition, const std::string& message);
|
||
void* allocate_memory(size_t bytes, const char* log_msg)
|
||
{
|
||
bytes += 7;
|
||
bytes /= 8;
|
||
bytes *= 8;
|
||
|
||
return new char[bytes];
|
||
}
|
||
|
||
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 = 0;
|
||
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);
|
||
}
|
||
|
||
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);
|
||
|
||
cv::imencode(img_type_, mat, bmpdata, compress); //图像压缩参数，该参数取值范围为0-100，数值越高，图像质量越高
|
||
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.ImageProcess.DiscardBlankThre = 50;
|
||
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)
|
||
{
|
||
if (!img_type)
|
||
return;
|
||
|
||
if ((strcmp(img_type, ".jpg") == 0) || (strcmp(img_type, ".png") == 0))
|
||
img_type_ = img_type;
|
||
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;
|
||
}
|
||
}
|
||
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);
|
||
}
|
||
int GetDeviceParam(HG_Scanner_Handle pScanner)
|
||
{
|
||
HGBool is_MultiOutput = false;
|
||
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_DLSC && devParam->type == HGLIB_OPTION_VALUETYPE_BOOL)
|
||
{
|
||
is_MultiOutput = devParam->boolValue;
|
||
}
|
||
else if (devParam->option == HGLIB_OPTION_NAME_DLSCLX && devParam->type == HGLIB_OPTION_VALUETYPE_ENUM)
|
||
{
|
||
if (is_MultiOutput)
|
||
{
|
||
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
|
||
{
|
||
m_params.MultiOutput = HG_Unused;
|
||
}
|
||
is_MultiOutput = false;
|
||
}
|
||
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;
|
||
}
|
||
int SetDeviceParam(HG_Scanner_Handle pScanner)
|
||
{
|
||
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);
|
||
}
|
||
|
||
boolValue = m_params.MultiOutput == HG_Unused ? false : true;
|
||
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_DLSC, &boolValue);
|
||
if (boolValue)
|
||
{
|
||
if (m_params.MultiOutput == HG_All)
|
||
enumValue = HGLIB_OPTION_ENUMVALUE_DLSCLX_CS_HD_HB;
|
||
else if (m_params.MultiOutput == HG_ColorGray)
|
||
enumValue = HGLIB_OPTION_ENUMVALUE_DLSCLX_CS_HD;
|
||
else if (m_params.MultiOutput == HG_ColorBw)
|
||
enumValue = HGLIB_OPTION_ENUMVALUE_DLSCLX_CS_HB;
|
||
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.NosieDetachEnable;
|
||
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_HBTXZDYH, &boolValue);
|
||
|
||
intValue = m_params.ImageProcess.NosieDetach;
|
||
HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_HBTXZDYH, &intValue);
|
||
|
||
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);
|
||
}
|
||
else if (m_params.PaperSize == HG_None)
|
||
{
|
||
enumValue = HGLIB_OPTION_ENUMVALUE_ZZCC_PPYSCC;
|
||
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);
|
||
}
|
||
else
|
||
{
|
||
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;
|
||
GetDeviceParam(pScanner);
|
||
*param = m_params;
|
||
return 0;
|
||
}
|
||
int HG_Set_Scan_Params(HG_Scanner_Handle pScanner, HG_SCANPARAMS param)
|
||
{
|
||
m_params = param;
|
||
int ret = SetDeviceParam(pScanner);
|
||
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)
|
||
{
|
||
return HGLib_StopDeviceScanAsyn((HGLibDevice)pScanner) ? 0 : -1;
|
||
}
|
||
int HG_Is_Running(HG_Scanner_Handle pScanner)
|
||
{
|
||
return 0;
|
||
}
|
||
int HG_Is_FeederLoaded(HG_Scanner_Handle pScanner)
|
||
{
|
||
return HGLib_GetDeviceStatus((HGLibDevice)pScanner);
|
||
}
|
||
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;
|
||
}
|
||
void HG_SET_IMG_COMPRESSION(unsigned int compressiondata)
|
||
{
|
||
if (img_type_ ==".png")
|
||
{
|
||
compressiondata /= 10;
|
||
}
|
||
compression_data = compressiondata;
|
||
}
|
||
bool HG_Set_Img_Quality(HG_Scanner_Handle pScanner, bool compressiondata)
|
||
{
|
||
HGUInt enumValue = compressiondata ? HGLIB_OPTION_ENUMVALUE_HZ_HZYX : HGLIB_OPTION_ENUMVALUE_HZ_SDYX;
|
||
return HGLib_SetDeviceParam((HGLibDevice)pScanner, HGLIB_OPTION_NAME_HZ, &enumValue);
|
||
}
|
||
/*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);
|
||
printf("dstFile = %s \n", dstfilepath.c_str());
|
||
int pageIndex = 0;//init page number
|
||
HGImgFmtLoadInfo info;
|
||
HGImage hgimg = NULL;
|
||
HGTiffWriter tifwriter;
|
||
HGImgFmt_OpenTiffWriter(dstfilepath.c_str(), &tifwriter);
|
||
HGTiffSaveInfo saveinfo;
|
||
saveinfo.compression = HGIMGFMT_TIFFCOMP_JPEG;
|
||
saveinfo.jpegQuality = 90;
|
||
saveinfo.resolutionUnit = HGIMGFMT_TIFFRESUNIT_INCH;
|
||
HGResult hgret;
|
||
for (int i = 0; i < srcnum; i++)//convert imgs to tiff loop
|
||
{
|
||
printf("filepath = %s \n", srcFiles[i]);
|
||
std::string filepath(srcFiles[i]);
|
||
if (filepath.length() > 4)
|
||
{
|
||
hgret = HGImgFmt_LoadImage(srcFiles[i], 0, &info, 0, 0, &hgimg);
|
||
if (hgret == HGBASE_ERR_OK)
|
||
{
|
||
saveinfo.xResolution = info.xDpi;
|
||
saveinfo.yResolution = info.yDpi;
|
||
hgret = HGImgFmt_SaveImageToTiffWriter(tifwriter, hgimg, &saveinfo);
|
||
printf("\nHGImgFmt_SaveImageToTiffWriter %d", hgret);
|
||
}
|
||
else
|
||
{
|
||
printf("\nHGImgFmt_LoadImage error %d", hgret);
|
||
}
|
||
}
|
||
}
|
||
hgret = HGImgFmt_CloseTiffWriter(tifwriter);
|
||
printf("\nHGImgFmt_CloseTiffWriter %d", hgret);
|
||
return 1;
|
||
}
|
||
|
||
|
||
void G4TiffExcept(bool condition, const std::string& message)
|
||
{
|
||
if (!condition)
|
||
throw std::runtime_error("Error " + message);
|
||
}
|
||
|
||
DLL_HG_SCHANNER_API bool G4TiffSave(char* m_tmppath)
|
||
{
|
||
if (!m_tmppath)
|
||
{
|
||
printf("filename is not find\r\n");
|
||
return false;
|
||
}
|
||
cv::Mat mat = cv::imread(m_tmppath);
|
||
if (mat.empty())
|
||
{
|
||
printf("opencv mat read image fial\r\n");
|
||
return false;
|
||
}
|
||
if (mat.channels() == 3)
|
||
{
|
||
cvtColor(mat, mat, cv::COLOR_RGB2GRAY);
|
||
}
|
||
int compression = COMPRESSION_CCITT_T6;
|
||
|
||
if (compression == COMPRESSION_CCITT_T6 && mat.channels() != 1)
|
||
throw std::runtime_error("mat channel error");
|
||
|
||
TIFF* pTiffHandle = TIFFOpen(m_tmppath, "w");
|
||
if (!pTiffHandle)
|
||
{
|
||
printf("can't open TIFF descriptor\n");
|
||
return false;
|
||
}
|
||
int width = mat.cols;
|
||
int height = mat.rows;
|
||
try
|
||
{
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_IMAGEWIDTH, width), "width");
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_IMAGELENGTH, height), "length");
|
||
if (compression == COMPRESSION_CCITT_T6)
|
||
{
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_BITSPERSAMPLE, 1), "bits per sample");
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_SAMPLESPERPIXEL, 1), "samples per pixel");
|
||
}
|
||
else
|
||
{
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_BITSPERSAMPLE, /*mat.depth()*/8), "bits per sample");
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_SAMPLESPERPIXEL, mat.channels()), "samples per pixel");
|
||
}
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_ROWSPERSTRIP, height), "rows per strip");
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_COMPRESSION, compression), "compression");
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE), "photometric");
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB), "photometric");
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG), "planar config");
|
||
// not necessary
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_XRESOLUTION, (float)m_params.Resolution), "res x");
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_YRESOLUTION, (float)m_params.Resolution), "res y");
|
||
G4TiffExcept(TIFFSetField(pTiffHandle, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH), "res unit");
|
||
|
||
if (compression == COMPRESSION_CCITT_T6)
|
||
{
|
||
std::vector<uchar> _buffer(width / 8 + 8, 0);
|
||
//std::vector<uchar> _buffer(width / 8 + 1, 0);
|
||
uchar* buffer = &_buffer[0];
|
||
//int bytes = int(width / 8.0 + 0.5);
|
||
for (int y = 0; y < height; ++y)
|
||
{
|
||
uint8_t* src_row = mat.ptr(y);
|
||
for (int x = 0; x < width; ++x, ++src_row)
|
||
{
|
||
uint8_t eight_pixels = buffer[x / 8];
|
||
eight_pixels = eight_pixels << 1;
|
||
if (*src_row < 127)
|
||
eight_pixels = eight_pixels | 1; //
|
||
buffer[x / 8] = eight_pixels;
|
||
}
|
||
G4TiffExcept(TIFFWriteScanline(pTiffHandle, buffer, y, 0) != -1, "write scanline");
|
||
}
|
||
}
|
||
else
|
||
{
|
||
int l = mat.total() / mat.rows * mat.channels();
|
||
for (int y = 0; y < height; ++y)
|
||
{
|
||
uint8_t* src = mat.ptr(y);
|
||
G4TiffExcept(TIFFWriteScanline(pTiffHandle, src, y, 0) != -1, "write scanline");
|
||
}
|
||
}
|
||
}
|
||
catch (const std::runtime_error& e)
|
||
{
|
||
printf("TIFF writing: %s\n", e.what());
|
||
// TIFFClose(pTiffHandle);
|
||
}
|
||
TIFFClose(pTiffHandle);
|
||
return true;
|
||
}
|