#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" 
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";
char deviceList[60];

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);
	}
	vector<int>compress;
	compress.push_back(CV_IMWRITE_JPEG_QUALITY);
	compress.push_back(80);     //图像压缩参数，该参数取值范围为0-100，数值越高，图像质量越高

	cv::imencode(img_type_, mat, bmpdata, compress);

	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)
{
	if (img_type)
	{
		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;
		}
	}
}
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)
{
	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;
}
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);
	}


	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;
	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_StopDeviceScan((HGLibDevice)pScanner) ? 0 : -1;
}
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;
}
/*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;
}