diff --git a/changelog.txt b/changelog.txt new file mode 100644 index 00000000..3c7c29b3 --- /dev/null +++ b/changelog.txt @@ -0,0 +1,11 @@ +2021年11月16日 + 版本：3.3.5.4 + 1.添加搓纸轮使用过多提示 + 2.修改扫描提示 + 3.修复保存首选项不能保存高级设置参数问题 + 4.新增奥鸽G139型号 +2021年11月20日 + 版本：3.3.5.4 + 1.添加配置文件，可开关显示滚轴弹框以及打印协议设置信息 + 2.调整twain协议 + 3.更新穿孔算法 \ No newline at end of file diff --git a/huagao/CAboutDlg.cpp b/huagao/CAboutDlg.cpp index d5ae3e82..0141d146 100644 --- a/huagao/CAboutDlg.cpp +++ b/huagao/CAboutDlg.cpp @@ -54,13 +54,15 @@ BOOL CAboutDlg::OnInitDialog() #ifdef MAKEHUAGAO HBITMAP hBitmap = ::LoadBitmap(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDB_BMPABOUTDLG)); #elif defined HANVON - HBITMAP hBitmap = ::LoadBitmap(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDB_BITMAP3)); -#else defined LANXUM + HBITMAP hBitmap = ::LoadBitmap(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDB_BITMAP1)); +#elif defined LANXUM HBITMAP hBitmap = ::LoadBitmap(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDB_BITMAP2)); +#elif defined AUGE + HBITMAP hBitmap = ::LoadBitmap(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDB_BITMAP4)); #endif pStatic->ModifyStyle(0xF, SS_BITMAP | SS_CENTERIMAGE); pStatic->SetBitmap(hBitmap); -#if defined MAKEHUAGAO || defined LANXUM || defined HANVON +#if defined MAKEHUAGAO || defined LANXUM || defined HANVON || defined AUGE GetDlgItem(IDC_PICABOUTHUAGO)->ShowWindow(TRUE); #else GetDlgItem(IDC_PICABOUTHUAGO)->ShowWindow(FALSE); diff --git a/huagao/CAdvancedDLG.cpp b/huagao/CAdvancedDLG.cpp index b5218f7f..c94a1e28 100644 --- a/huagao/CAdvancedDLG.cpp +++ b/huagao/CAdvancedDLG.cpp @@ -42,7 +42,7 @@ BOOL CAdvancedDLG::OnInitDialog() CTabPageSSL::OnInitDialog(); m_Edit_noise.SetSlideLink(this, IDC_SLIDER_NOISE); - m_Edit_noise.SetParams(1, 10, 1); + m_Edit_noise.SetParams(1, 20, 1); m_Edit_noise.SetValue(noise); m_Edit_indent.SetSlideLink(this, IDC_SLIDER_INDENT); diff --git a/huagao/CAttributeDlg.cpp b/huagao/CAttributeDlg.cpp new file mode 100644 index 00000000..72d656f1 --- /dev/null +++ b/huagao/CAttributeDlg.cpp @@ -0,0 +1,46 @@ +// CAttributeDlg.cpp: 实现文件 +// + +#include "CAttributeDlg.h" + + +// CAttributeDlg 对话框 + +IMPLEMENT_DYNAMIC(CAttributeDlg, CDialogEx) + +CAttributeDlg::CAttributeDlg(CWnd* pParent /*=nullptr*/) + : CDialogEx(IDD_ATTRIBUTE, pParent) +{ + +} + +CAttributeDlg::~CAttributeDlg() +{ +} + +BOOL CAttributeDlg::OnInitDialog() +{ + this->SetWindowTextW(L"扫描仪属性"); + return TRUE; +} + +void CAttributeDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); +} + + +BEGIN_MESSAGE_MAP(CAttributeDlg, CDialogEx) + ON_BN_CLICKED(IDC_BTN_ATTOK, &CAttributeDlg::OnBnClickedBtnAttok) +END_MESSAGE_MAP() + + +// CAttributeDlg 消息处理程序 + + +void CAttributeDlg::OnBnClickedBtnAttok() +{ + CDialogEx::OnOK(); + // TODO: 在此添加控件通知处理程序代码 +} + diff --git a/huagao/CAttributeDlg.h b/huagao/CAttributeDlg.h new file mode 100644 index 00000000..ce0d89a0 --- /dev/null +++ b/huagao/CAttributeDlg.h @@ -0,0 +1,25 @@ +#pragma once +#include "stdafx.h" +#include "resource.h" +// CAttributeDlg 对话框 + +class CAttributeDlg : public CDialogEx +{ + DECLARE_DYNAMIC(CAttributeDlg) + +public: + CAttributeDlg(CWnd* pParent = nullptr); // 标准构造函数 + virtual ~CAttributeDlg(); + +// 对话框数据 +#ifdef AFX_DESIGN_TIME + enum { IDD = IDD_ATTRIBUTE }; +#endif + virtual BOOL OnInitDialog(); +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持 + + DECLARE_MESSAGE_MAP() +public: + afx_msg void OnBnClickedBtnAttok(); +}; diff --git a/huagao/CBasicPage.cpp b/huagao/CBasicPage.cpp index 379291d4..c2381540 100644 --- a/huagao/CBasicPage.cpp +++ b/huagao/CBasicPage.cpp @@ -6,6 +6,7 @@ #include "afxdialogex.h" #include "resource.h" #include "CAboutDlg.h" +#include "CAttributeDlg.h" #include "CTwainUI.h" #include "CDiscardBlankSetting.h" #include "CcardblankDlg.h" @@ -84,9 +85,11 @@ static std::vector surportStyles = { _T("Double Letter"),//pass _T("LEGAL"), _T("匹配原始尺寸"), +#ifndef ANDROIDSERIAL _T("最大扫描尺寸自动裁切"), _T("最大扫描尺寸"), _T("三联试卷"), +#endif // !ANDROIDSERIAL }; #endif // G400 @@ -170,6 +173,7 @@ BOOL CBasicPage::OnInitDialog() #ifndef UV GetDlgItem(IDC_CKBENABLEUV)->ShowWindow(FALSE); #endif + GetDlgItem(IDC_BTN_ATTRIBYTE)->ShowWindow(SW_HIDE); return true; } @@ -182,6 +186,7 @@ BEGIN_MESSAGE_MAP(CBasicPage, CTabPageSSL) ON_CBN_SELCHANGE(IDC_CMBDUPLEX, &CBasicPage::OnCbnSelchangeCmbduplex) ON_BN_CLICKED(IDC_BTNDISCARDSETTING, &CBasicPage::OnClickedBtndiscardsetting) ON_NOTIFY(NM_RELEASEDCAPTURE, IDC_SLIDERDPI, &CBasicPage::OnNMReleasedcaptureSliderdpi) + ON_BN_CLICKED(IDC_BTN_ATTRIBYTE, &CBasicPage::OnBnClickedBtnAttribyte) END_MESSAGE_MAP() @@ -295,6 +300,7 @@ void CBasicPage::updateCmbDuplex(BOOL insert) m_cmBoxDuplex->InsertString(4, TEXT("对折")); } } +#ifdef G200 if (m_Slider_Dpi.m_iPosition > 300 && m_cmBoxSS->GetCount() > 20) { if (m_cmBoxSS->GetCurSel() >= 20) @@ -309,6 +315,7 @@ void CBasicPage::updateCmbDuplex(BOOL insert) m_cmBoxSS->InsertString(21, _T("最大扫描尺寸")); m_cmBoxSS->InsertString(22, _T("三联试卷")); } +#endif // G200 #ifndef G300 if (tmp_paperindex == 19 || tmp_paperindex == 20 || tmp_paperindex == 21 || tmp_paperindex == 22 || tmp_paperindex == 1|| tmp_paperindex == 4|| tmp_paperindex == 5){ (((CButton*)GetDlgItem(IDC_CKBSIZEDETECT)))->SetCheck(false); @@ -330,10 +337,6 @@ void CBasicPage::updateCmbDuplex(BOOL insert) } - - - - void CBasicPage::OnNMReleasedcaptureSliderdpi(NMHDR* pNMHDR, LRESULT* pResult) { // TODO: 在此添加控件通知处理程序代码 @@ -368,3 +371,11 @@ void CBasicPage::OnNMReleasedcaptureSliderdpi(NMHDR* pNMHDR, LRESULT* pResult) #endif // G200 } + + +void CBasicPage::OnBnClickedBtnAttribyte() +{ + // TODO: 在此添加控件通知处理程序代码 + CAttributeDlg attributedlg(this); + attributedlg.DoModal(); +} diff --git a/huagao/CBasicPage.h b/huagao/CBasicPage.h index cd62f446..d599f177 100644 --- a/huagao/CBasicPage.h +++ b/huagao/CBasicPage.h @@ -55,4 +55,5 @@ private: public: afx_msg void OnCbnSelchangeCblowpowermode(); afx_msg void OnNMReleasedcaptureSliderdpi(NMHDR* pNMHDR, LRESULT* pResult); + afx_msg void OnBnClickedBtnAttribyte(); }; diff --git a/huagao/CFeedPaperPage.cpp b/huagao/CFeedPaperPage.cpp index d3c3e2ca..a5044608 100644 --- a/huagao/CFeedPaperPage.cpp +++ b/huagao/CFeedPaperPage.cpp @@ -61,6 +61,7 @@ void CFeedPaperPage::DoDataExchange(CDataExchange* pDX) DDX_Control(pDX, IDC_SLDDETECTLEVEL, m_sldSkrewDetecttion); DDX_Control(pDX, IDC_EDSCANNUM, m_editNum); DDX_Control(pDX, IDC_DogEarDetection, dogear); + DDX_Control(pDX, IDC_SLIDER_DOGEAR, m_slider_dogear); } BOOL CFeedPaperPage::OnInitDialog() @@ -72,6 +73,11 @@ BOOL CFeedPaperPage::OnInitDialog() OnInitcmBoxOrentation(0); m_sldSkrewDetecttion.SetSlideRange(1, 5); m_sldSkrewDetecttion.SetSlidePos(3); + + m_slider_dogear.SetSlideRange(10, 300); + m_slider_dogear.SetSlidePos(50); + m_slider_dogear.SetTicFreq(50); + #ifndef G200 for (size_t i = 0; i < g400hiden.size(); i++) { @@ -93,6 +99,7 @@ BEGIN_MESSAGE_MAP(CFeedPaperPage, CTabPageSSL) ON_BN_CLICKED(IDC_RDSPECIFYSCANNUM, &CFeedPaperPage::OnBnClickedScanMode) ON_BN_CLICKED(IDC_CKSKEWDETECT, &CFeedPaperPage::OnBnClickedCkskewdetect) ON_CBN_SELCHANGE(IDC_CMBORENTATION, &CFeedPaperPage::OnCbnSelchangeCmborentation) + ON_BN_CLICKED(IDC_DogEarDetection, &CFeedPaperPage::OnBnClickedDogeardetection) END_MESSAGE_MAP() BOOL CFeedPaperPage::PreTranslateMessage(MSG* pMsg) @@ -178,3 +185,15 @@ void CFeedPaperPage::OnCbnSelchangeCmborentation() // TODO: 在此添加控件通知处理程序代码 FeedPaperPageUpdate(comboxduplux); } + + +void CFeedPaperPage::OnBnClickedDogeardetection() +{ + // TODO: 在此添加控件通知处理程序代码 + UpdateData(TRUE); + if (((CButton*)GetDlgItem(IDC_DogEarDetection))->GetCheck() != 1) + m_slider_dogear.EnableWindow(FALSE); + else + m_slider_dogear.EnableWindow(TRUE); + +} diff --git a/huagao/CFeedPaperPage.h b/huagao/CFeedPaperPage.h index 53241242..b567014e 100644 --- a/huagao/CFeedPaperPage.h +++ b/huagao/CFeedPaperPage.h @@ -23,6 +23,7 @@ public: BOOL m_cbSkew; CComboBox m_cmBoxOrentation; CLinkSlider m_sldSkrewDetecttion; + CLinkSlider m_slider_dogear; int m_radioGroupScanMode; CSmartEdit m_editNum; @@ -47,4 +48,6 @@ private: public: afx_msg void OnCbnSelchangeCmborentation(); + + afx_msg void OnBnClickedDogeardetection(); }; diff --git a/huagao/CTwainUI.cpp b/huagao/CTwainUI.cpp index 65d6d559..2c777b3e 100644 --- a/huagao/CTwainUI.cpp +++ b/huagao/CTwainUI.cpp @@ -86,9 +86,14 @@ BOOL CTwainUI::OnInitDialog() UpdateUI(); UpdateListConfig(); dataChangeFunction(); - //setvisable_size(false); -#ifdef G200 +#ifdef ANDROIDSERIAL + setvisable_size(false); +#endif // ANDROIDSERIAL setvisable_sleepmode(false); +#ifdef G200 + setvisable_dogear(true); +#else + setvisable_dogear(false); #endif // G200 return true; } @@ -234,6 +239,8 @@ void CTwainUI::UpdateUI() m_pageFeedPaper->m_cmBoxOrentation.SetCurSel(settings->is_autotext?4:getRotateCmbIndex(settings->imageRotateDegree));//旋转方向; m_pageFeedPaper->m_sldSkrewDetecttion.SetPos(m_pageFeedPaper->m_cbSkew?settings->hardwarecaps.skrewdetectlevel:3);//歪斜检测等级 m_pageFeedPaper->m_sldSkrewDetecttion.EnableWindow(m_pageFeedPaper->m_cbSkew); + m_pageFeedPaper->m_slider_dogear.SetPos(settings->dogeardistance); + m_pageFeedPaper->m_slider_dogear.EnableWindow(((CButton*)m_pageFeedPaper->GetDlgItem(IDC_DogEarDetection))->GetCheck()); ((CComboBox*)m_pageFeedPaper->GetDlgItem(IDC_CBLOWPOWERMODE))->SetCurSel(settings->hardwarecaps.lowpowermode); if (settings->scannum == 65535)//连续扫描 { @@ -515,6 +522,7 @@ void CTwainUI::UpDateScanParam(PCONFIGPARAMS configItem, bool updateDs) settings->hardwarecaps.skrewdetectlevel = (int)configItem->ScrewDetectLevel; settings->hardwarecaps.en_stapledetect = configItem->EnBindingDetect; settings->hardwarecaps.en_doublefeed = configItem->EnUltrasonicDetect; + settings->dogeardistance = m_pageFeedPaper->m_slider_dogear.GetPos(); settings->en_fold = configItem->EnFlod ? 1 : 0; if (configItem->ScanCount == -1) settings->scannum = configItem->ScanCount; @@ -638,6 +646,16 @@ void CTwainUI::setvisable_sleepmode(bool flag) ((CComboBox*)m_pageFeedPaper->GetDlgItem(IDC_CBLOWPOWERMODE))->SetCurSel(0); } +void CTwainUI::setvisable_dogear(bool flag) +{ + m_pageFeedPaper->GetDlgItem(IDC_DogEarDetection)->ShowWindow(flag ? SW_SHOW : SW_HIDE); + m_pageFeedPaper->GetDlgItem(IDC_SLIDER_DOGEAR)->ShowWindow(flag ? SW_SHOW : SW_HIDE); + m_pageFeedPaper->GetDlgItem(IDC_LBSDL2)->ShowWindow(flag ? SW_SHOW : SW_HIDE); + m_pageFeedPaper->GetDlgItem(IDC_LBSDR2)->ShowWindow(flag ? SW_SHOW : SW_HIDE); + if (!flag) + ((CButton*)m_pageFeedPaper->GetDlgItem(IDC_DogEarDetection))->SetCheck(false); +} + void CTwainUI::EnableID_OKorID_Cancel(bool enable) { GetDlgItem(IDC_CONFIRM)->EnableWindow(enable); diff --git a/huagao/CTwainUI.h b/huagao/CTwainUI.h index feb1e336..ecec415e 100644 --- a/huagao/CTwainUI.h +++ b/huagao/CTwainUI.h @@ -175,6 +175,7 @@ public: void UpdateUi(); void setvisable_size(bool flag); void setvisable_sleepmode(bool flag); + void setvisable_dogear(bool flag); void EnableID_OKorID_Cancel(bool enable); // 对话框数据 #ifdef AFX_DESIGN_TIME diff --git a/huagao/Device/G400ScanConfig.cpp b/huagao/Device/G400ScanConfig.cpp index 511f6833..2a16e9e5 100644 --- a/huagao/Device/G400ScanConfig.cpp +++ b/huagao/Device/G400ScanConfig.cpp @@ -38,3 +38,37 @@ unsigned int G400ScanConfig::GetData() { return cfg.value; } + + +G400AndroidScanConfig::G400AndroidScanConfig(GScanCap& gcap) +{ + cfg = { 0 }; + cfg.params.doubleFeeded = gcap.hardwarecaps.en_doublefeed == 0 ? 0 : 1; + cfg.params.dpi = G400_DPI::G400_D200;//gcap.resolution_dst <= 200.0f ? G400_DPI::G400_D200 : (gcap.resolution_dst <= 300.0f ? G400_DPI::G400_D300 : G400_DPI::G400_D600); + cfg.params.enableLed = 1; + if (gcap.filter != 3 || gcap.enhance_color) + cfg.params.isColor = 1; + else + cfg.params.isColor = SupPixelTypes[gcap.pixtype]; + //cfg.params.isColor = 1; + cfg.params.isCorrect = 1;//1 У + PaperStatus ps = { gcap.papertype,gcap.paperAlign }; + cfg.params.pageSize = SupPaperTyps[ps]; + CSize size; +#ifdef G300 + size = PaperSize.GetPaperSize(TwSS::A4, 200.0f, gcap.paperAlign);//G300 ֧A4 +#else + size = PaperSize.GetPaperSize(gcap.papertype, 200.0f, gcap.paperAlign); +#endif// G300 + cfg.params.dstHeight = (int)((size.cy + 200) / 100); + cfg.params.reversed1 = cfg.params.reversed2 = cfg.params.reversed3 = 0; +} + +G400AndroidScanConfig::~G400AndroidScanConfig() +{ +} + +unsigned int G400AndroidScanConfig::GetData() +{ + return cfg.value; +} diff --git a/huagao/Device/G400ScanConfig.h b/huagao/Device/G400ScanConfig.h index 0002bee9..429a86d7 100644 --- a/huagao/Device/G400ScanConfig.h +++ b/huagao/Device/G400ScanConfig.h @@ -33,3 +33,32 @@ private: Device::PaperSize PaperSize; }; + +class G400AndroidScanConfig : + public IConfig +{ +public: + union Configuration + { + struct + { + unsigned int pageSize : 5; + unsigned int isColor : 1; + unsigned int dpi : 2; + unsigned int doubleFeeded : 1; + unsigned int reversed3 : 1; + unsigned int enableLed : 1; + unsigned int reversed1 : 6; + unsigned int isCorrect : 1; + unsigned int dstHeight : 8; + unsigned int reversed2 : 6; + }params; + unsigned int value; + }; + G400AndroidScanConfig(GScanCap& gcap); + virtual ~G400AndroidScanConfig(); + virtual unsigned int GetData() override; +private: + Configuration cfg; + Device::PaperSize PaperSize; +}; diff --git a/huagao/Device/GScan.h b/huagao/Device/GScan.h index ef9bba92..5567b77b 100644 --- a/huagao/Device/GScan.h +++ b/huagao/Device/GScan.h @@ -140,7 +140,6 @@ class IScanner public: IScanner() { imgreadednum = imgtransfered = roller_num = lose_image_num = 0; - is_Android = false; } virtual ~IScanner() { @@ -149,32 +148,44 @@ public: /// ñɨ /// /// - void set_scannum(int val) { scannum = val; }; + void set_scannum(int val) { + scannum = val; + }; /// /// ȡɨ /// /// - int get_scannum() { return scannum; }; + int get_scannum() { + return scannum; + }; /// /// ȡPCȡͼҳ /// /// - int get_imgnReaded() { return imgreadednum; }; + int get_imgnReaded() { + return imgreadednum; + }; /// /// ȡͼ /// /// - int get_imgTransfered() { return imgtransfered; }; + int get_imgTransfered() { + return imgtransfered; + }; /// /// ȡʧͼ /// /// - int get_lose_image_num() { return lose_image_num; }; + int get_lose_image_num() { + return lose_image_num; + }; /// /// öʧͼ /// /// - void set_lose_image_num(int value) { lose_image_num = value; }; + void set_lose_image_num(int value) { + lose_image_num = value; + }; /// /// ȡԭʼͼԼһ /// @@ -263,7 +274,6 @@ protected: int roller_num; int scannum; int lose_image_num; - bool is_Android; int error_index; }; \ No newline at end of file diff --git a/huagao/Device/GScanO1003399.cpp b/huagao/Device/GScanO1003399.cpp index d2a81a6a..56496f29 100644 --- a/huagao/Device/GScanO1003399.cpp +++ b/huagao/Device/GScanO1003399.cpp @@ -246,6 +246,7 @@ void GScanO1003399::config_params(GScanCap& param) } cfg.g200params.dpi = SupResolutions.count(param.resolution_native)>0 ? SupResolutions[param.resolution_native] : 1; cfg.g200params.double_feed_enbale = (unsigned int)param.hardwarecaps.en_doublefeed; + //cfg.g200params.stable_enbale = 0; cfg.g200params.stable_enbale = (unsigned int)param.hardwarecaps.en_stapledetect; cfg.g200params.screw_detect_enable = (unsigned int)param.hardwarecaps.en_skrewdetect; cfg.g200params.screw_detect_level = (unsigned int)cfg.g200params.screw_detect_enable ? secrewMaps[param.hardwarecaps.skrewdetectlevel] : 0; @@ -313,6 +314,7 @@ void GScanO1003399::config_params(GScanCap& param) param39.papertype = param.papertype; param39.pixtype = param.pixtype; param39.resolution_dst = param.resolution_dst; + //param39.resolution_dst = param.resolution_dst > 300 ? 300 : param.resolution_dst; param39.resolution_native = param.resolution_native; param39.scannum = param.scannum; param39.sharpen = param.sharpen; @@ -320,7 +322,25 @@ void GScanO1003399::config_params(GScanCap& param) param39.multiOutput = MultiOutput::Unused; param39.normalCrop = param.normalCrop; m_usb->write_bulk(¶m39, sizeof(param39)); - + if (param.is_autotext) + { + TCHAR szIniFile[MAX_PATH] = { 0 }; + SHGetSpecialFolderPath(NULL, szIniFile, CSIDL_WINDOWS, TRUE); +#ifdef LANXUM + _tcscat(szIniFile, _T("\\twain_32\\LANXUMSCAN\\tessdata")); +#elif defined AUGE + _tcscat(szIniFile, _T("\\twain_32\\AuGeScan\\tessdata")); +#elif defined HANVON + _tcscat(szIniFile, _T("\\twain_32\\HanvonScan\\tessdata")); +#else + _tcscat(szIniFile, _T("\\twain_32\\HuaGoScan\\tessdata")); +#endif // + int iLen = WideCharToMultiByte(CP_ACP, 0, szIniFile, -1, NULL, 0, NULL, NULL); + char* chRtn = new char[iLen * sizeof(char)]; + WideCharToMultiByte(CP_ACP, 0, szIniFile, -1, chRtn, iLen, NULL, NULL); + m_autotext.reset(new CImageApplyRotation(CImageApplyRotation::RotationType::AutoTextOrientation, false, param.resolution_dst, chRtn)); + delete[] chRtn; + } } void GScanO1003399::Scanner_StartScan(UINT16 count) @@ -427,7 +447,7 @@ void GScanO1003399::Stop_scan() int GScanO1003399::notifyscan() { - return 0; + return 1; } void GScanO1003399::ResetScanner() @@ -693,7 +713,6 @@ int GScanO1003399::read_data(void* data, int length, int timeout) int reading = 0; const int buffer_size = 512 * 1024; StopWatch sw; - FileTools::writelog(log_INFO, "read_data timeout =" + to_string(timeout)); while (readed < length) { if (sw.elapsed_ms() < timeout &&m_usb.get()) { @@ -762,32 +781,7 @@ void GScanO1003399::imgproce(std::shared_ptr>& buff) buffs.clear(); if (m_param.is_autotext) { - CImageApplyRotation::RotationType type; - /*if (m_param.imageRotateDegree > 89.0f && m_param.imageRotateDegree < 91.0f) - type = CImageApplyRotation::RotationType::Rotate_90_clockwise; - else if (m_param.imageRotateDegree > 269.0f && m_param.imageRotateDegree < 271.0f) - type = CImageApplyRotation::RotationType::Rotate_90_anti_clockwise; - else if (m_param.imageRotateDegree > 179.0f && m_param.imageRotateDegree < 181.0f) - type = CImageApplyRotation::RotationType::Rotate_180; - else*/ - - if (m_param.is_autotext) - type = CImageApplyRotation::RotationType::AutoTextOrientation; - else - type = CImageApplyRotation::RotationType::Invalid;//ֻԶıʶ IJ - - TCHAR szIniFile[MAX_PATH] = { 0 }; - SHGetSpecialFolderPath(NULL, szIniFile, CSIDL_WINDOWS, TRUE); -#ifdef LANXUM - _tcscat(szIniFile, _T("\\twain_32\\LANXUMSCAN\\tessdata")); -#else - _tcscat(szIniFile, _T("\\twain_32\\HuaGoScan\\tessdata")); -#endif // - int iLen = WideCharToMultiByte(CP_ACP, 0, szIniFile, -1, NULL, 0, NULL, NULL); - char* chRtn = new char[iLen * sizeof(char)]; - WideCharToMultiByte(CP_ACP, 0, szIniFile, -1, chRtn, iLen, NULL, NULL); - CImageApplyRotation(type, m_param.is_backrotate180, m_param.resolution_dst, chRtn).apply(mats,m_param.is_duplex); - delete[] chRtn; + m_autotext->apply(mats, m_param.is_duplex); } if (m_param.automaticcolor) { diff --git a/huagao/Device/GScanO1003399.h b/huagao/Device/GScanO1003399.h index 62ef67c4..660181e6 100644 --- a/huagao/Device/GScanO1003399.h +++ b/huagao/Device/GScanO1003399.h @@ -83,6 +83,7 @@ private: BlockingQueue m_paths; //std::queue> fu_imgpro; + std::shared_ptr m_autotext; std::shared_ptr m_imgprocthread; std::shared_ptr m_usbthread; std::shared_ptr> im_data; diff --git a/huagao/Device/GScanO200.cpp b/huagao/Device/GScanO200.cpp index 893d83fd..3099d886 100644 --- a/huagao/Device/GScanO200.cpp +++ b/huagao/Device/GScanO200.cpp @@ -446,7 +446,7 @@ void GScanO200::Scanner_StartScan(UINT16 count) int GScanO200::notifyscan() { - return -1; + return 1; } void GScanO200::Stop_scan() diff --git a/huagao/Device/GScanO400.cpp b/huagao/Device/GScanO400.cpp index 461592bb..eaa0bcbf 100644 --- a/huagao/Device/GScanO400.cpp +++ b/huagao/Device/GScanO400.cpp @@ -187,10 +187,6 @@ void GScanO400::open(int vid, int pid) USBCB status = { GET_DSP_STATUS ,0,0 }; if (m_usb.get() && m_usb->is_connected()) { - //m_usb->write_bulk(&status, sizeof(status)); - //m_usb->read_bulk(&status, sizeof(status)); - //std::this_thread::sleep_for(std::chrono::milliseconds(20)); - //notifyscan(); GetFWVersion(); } } @@ -264,10 +260,6 @@ std::string GScanO400::GetFWVersion() m_usb->read_bulk(&fwVersion[0], fwVersion.size()); std::this_thread::sleep_for(chrono::milliseconds(10)); } - if (fwVersion.substr(0, 2) == "G3" || fwVersion.substr(0, 2) == "G4" ||fwVersion.substr(0,2)== "GU") - is_Android = false; - else - is_Android = true; return fwVersion; } return ""; @@ -431,7 +423,6 @@ void GScanO400::Scanner_StartScan(UINT16 count) devState = DEV_WRONG; int errorcode = 0; readlenght == 0 ? errorcode = USB_DISCONNECTED : errorcode = NO_FEED; - Set_ErrorCode(errorcode); if (huagods) dev_callback(errorcode, huagods); @@ -617,8 +608,6 @@ void GScanO400::usbmain() this_thread::sleep_for(chrono::milliseconds(200)); break; } - - if (sw.elapsed_ms() > 30000) { m_pImages->setscanflags(false); @@ -667,9 +656,7 @@ void GScanO400::usbmain() #else UpdateScanInfo(countNReaded(), get_imgTransfered()); #endif - - if (!is_Android) - Pop_Image(); + Pop_Image(); FileTools::writelog(log_INFO, "ɨǽ" + to_string(get_imgnReaded()) + "ļʱ " + to_string(sw.elapsed_ms())); sw.reset(); break; @@ -677,7 +664,7 @@ void GScanO400::usbmain() case STOP_SCAN: { m_pImages->setscanflags(false); - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); + std::this_thread::sleep_for(std::chrono::milliseconds(500)); devState = haveError ? DevState::DEV_WRONG : DevState::DEV_STOP; break; } @@ -695,25 +682,11 @@ void GScanO400::usbmain() case USB_BULK_ERROR: if (!haveError) { - //if (is_Android) - //{ haveError = true; Set_ErrorCode(usbcb.u32_Data); - //} - //else - //{ - // haveError = true; - // devState = DEV_WRONG; - // m_pImages->setscanflags(false); - // Set_ErrorCode(usbcb.u32_Data); - // std::this_thread::sleep_for(std::chrono::milliseconds(1000)); - // auto rollernew = Get_Roller_num(); - // if (get_aquire_image_count() != (rollernew - roller_num)) - // set_lose_image_num(std::abs((rollernew - roller_num) - get_aquire_image_count())); - //} + if (huagods) dev_callback(usbcb.u32_Data, huagods); - } break; case NORMAL: @@ -726,12 +699,8 @@ void GScanO400::usbmain() } catch (const std::exception& e) { - //writelog(e.what()); FileTools::writelog(log_ERROR, e.what()); } - - ////FileTools::write_log("D:\\1.txt", "thread usb exit"); - } /////////////////////////////////////////////////////////////////////////// @@ -745,18 +714,6 @@ USBCB GScanO400::Get_Scanner_Status() m_usb->write_bulk(&usbcb, sizeof(usbcb)); if (m_usb.get() && m_usb->is_connected()) m_usb->read_bulk(&usbcb, sizeof(usbcb)); - if (usbcb.u32_CMD != GET_DSP_STATUS) - { - std::this_thread::sleep_for(std::chrono::microseconds(50)); - if (m_usb.get() && m_usb->is_connected()) - m_usb->read_bulk(&usbcb, 512); - if (m_usb.get() && m_usb->is_connected()) - m_usb->write_bulk(&usbcb, sizeof(usbcb)); - if (m_usb.get() && m_usb->is_connected()) - m_usb->read_bulk(&usbcb, 512); - FileTools::writelog(log_ERROR, "get dsp status error"); - return { NO_COMMAND,USB_BULK_ERROR,0 }; - } return usbcb; } @@ -768,26 +725,6 @@ std::shared_ptr> GScanO400::Get_Img_Data(int bufferSize) return std::shared_ptr>(new std::vector()); std::shared_ptr> imData(new std::vector(bufferSize)); - /*StopWatch sw; - int readed = 0; - USBCB usbcb = { GET_IMAGE,0,bufferSize }; - m_usb->write_bulk(&usbcb, sizeof(usbcb)); - int totalength = bufferSize; - int startindex = 0; - while (totalength > 0) - { - int dstlength = 1024 * 1024; - if (totalength <= dstlength) - { - dstlength = totalength; - totalength = 0; - } - else - totalength -= dstlength; - - int tt = m_usb->read_bulk(imData->data() + startindex, dstlength); - startindex += dstlength; - }*/ StopWatch sw; int readed = 0; USBCB usbcb = { GET_IMAGE,0,bufferSize }; diff --git a/huagao/Device/GScanO400.h b/huagao/Device/GScanO400.h index 86a66138..a45d3f34 100644 --- a/huagao/Device/GScanO400.h +++ b/huagao/Device/GScanO400.h @@ -1,7 +1,7 @@ #pragma once #include "GScan.h" #include - +#include "StopWatch.h" class GScanO400 : public IScanner { diff --git a/huagao/Device/GScanO400Android.cpp b/huagao/Device/GScanO400Android.cpp new file mode 100644 index 00000000..72baa2cb --- /dev/null +++ b/huagao/Device/GScanO400Android.cpp @@ -0,0 +1,810 @@ +#include "stdafx.h" +#include "GScanO400Android.h" +#include "UsbScanEx.h" +#include "StopWatch.h" +#include "scn_config.h" +#include "ImageMatQueue.h" +#include "ImageProcess/ImageApplyDogEarDetection.h" +#include "filetools.h" +#include "GetMemoryUsage.h" +#include "G400ScanConfig.h" + +//u32_CMD +typedef enum tagUsbKeyWords : UINT32 +{ + // + NO_COMMAND = 0, + //ȡdsp ״̬ + GET_DSP_STATUS = 1, + //ȡͼ + GET_IMAGE = 2, + //DSPפͼ + POP_IMAGE = 3, + //ʼɨ + START_COMMAND = 4, + //ֹͣɨ + STOP = 5, + //ȡɨɨģʽ + GET_SCAN_MODE = 6, + //ȡ̼汾 + GET_FW_VERSION = 7, + //PC˵״̬ + SEND_STATUS_PC = 8, + //·ɨò + CONFIGURED_DATA = 9, + //·̼Ϣ + SEND_FW = 10, + //ȡɨ + GET_CONFIG_DATA = 11, + //ȡɨ + GET_SCANN_NUM = 12, + //ȡֽ״̬ + GET_PAPERFEEDER_STATUS = 13, + //DSPʼ + INIT_HARDWARE_SYS = 14, + //ȡֽ״̬ + GET_PAPER_STATUS = 0x0d, + //·ԪòҶȣLED Rعʱ䣩 + SEND_COMPONENTS_GR = 15, + //·ԪòLED G/Bعʱ䣩 + SEND_COMPONENTS_GB = 16, + //·ɨģʽ + SEND_SCAN_MODE = 17, + //ʼƽ + START_FLAT = 18, + //ֹͣƽ + STOP_FLAT = 19, + //·200dpiɫƽ + SEND_200_COLOR_FLAT_DATA = 20, + //·300dpiɫƽ + SEND_300_COLOR_FLAT_DATA = 21, + //ȡ200dpiɫƽ + GET_200_COLOR_FLAT_DATA = 22, + //ȡ300dpiɫƽ + GET_300_COLOR_FLAT_DATA = 23, + //·200dpiҶƽУ + SEND_200_GRAY_FLAT_DATA = 24, + //·300dpiҶƽУ + SEND_300_GRAY_FLAT_DATA = 25, + //ȡ200DPIҶƽУ + GET_200_GRAY_FLAT_DATA = 26, + //ȡ300DPIҶƽУ + GET_300_GRAY_FLAT_DATA = 27, + //·к + SEND_SERIAL = 28, + //ȡк + GET_SERIAL = 29, + //ȡ + GET_ROLLER_NUM = 0x1e, + // + CLR_ROLLER_NUM = 0x1f, + //ɨ + CLR_SCAN_NUM = 0x20, + //׼¹̼ + PRE_UPGRADE = 0X21, + //ʼ¹̼ + START_UPGRADE = 0x22, + //ɫAD + RGB_ADI_PARA = 0x23, + //ҶȵAD + ADI_PARA = 0x24, + //ȡCISعʱ䣬ad) + GET_CIS_PARA = 0x25, + //ɨ + START_COMMAND_COUNT = 0x26, + //·ʱ + SET_SLEEP_TIME = 0x27, + //ȡʱ + GET_SLEEP_TIME = 0x28, + // + CLR_CACHE = 0x29, + //·ٶģʽ + SET_SPEED_MODE = 0x2a, + //ȡɨٶģʽ + GET_SPEED_MODE = 0X2b, + //ù̼汾һ8ֽ + SET_FW_VERSION = 0X2c, + //ȡDSP汾 + GET_DSP_VERSION = 0X2d, + //ɼFPGA̼汾 + GET_SCANFPGA_VERSION = 0x2e, + //FPGA̼汾 + GET_MOTORFPGA_VERSION = 0X2f, + //Ϣ + SET_USB_INFOR_MANUFACTURE = 0X30, + //ȡϢ + GET_USB_INFOR_MANUFACTURE = 0X31, + //òƷͺϢ + SET_USB_INFOR_MODEL_NAME = 0X32, + //ȡƷͺϢ + GET_USB_INFOR_MODEL_NAME = 0X33, + //USB PID / VIDϢ + SET_USB_INFOR_VIDPID = 0X34, + GET_USB_INFOR_VIDPID = 0X35, + //ÿֽͣ + SET_JAM_DETECT_SENSITIVE = 0X36, + //ȡֽͣ + GET_JAM_DETECT_SENSITIVE = 0X37, + //úϵ + SET_JUST_COF_H = 0x38, + //ȡϵ + GET_JUST_COF_H = 0x39, + CLEAR_HWERROR = 0x40,//G400 Ӳ쳣 + //ϵ + SET_JUST_COF_V = 0x41, + //ȡϵ + GET_JUST_COF_V = 0x42, + //ɨDZ + GET_CODE_G400 = 0x59, + //ȡɨDZ + SET_CODE_G400 = 0x60, + //ɨDZ + SET_CODE_G200 = 0x63, + //ȡɨDZ + GET_CODE_G200 = 0x64, + +} UsbKeyWords, * PUsbKeyWords; + +GScanO400Android::GScanO400Android() : + huagods(NULL), + image_num(0), + m_bread_fixed_ratio_fromDSP(false) +{ + m_pImages.reset(new ImageMatQueue()); + auto getimgnum = [&](bool isadd, int num) + { + isadd ? image_num += num : image_num -= num; + }; + m_pImages->SetGetimgnumcall(getimgnum); +} + +GScanO400Android::~GScanO400Android() +{ + if (m_threadUsb && m_threadUsb->joinable()) { + devState = DEV_STOP; + m_threadUsb->join(); + m_threadUsb.reset(); + } + if (m_usb.get()) + m_usb.reset(); + +} + +void GScanO400Android::DogEar_callback(std::function fun) +{ + m_pImages->SetDogEarCallback(fun); +} + +void GScanO400Android::open(int vid, int pid) +{ + auto usbs = UsbScan_List::find_vid_pid(vid, pid); + + if (!usbs.empty()) + { + m_usb = *usbs.begin(); + m_usb->set_usbhotplug_callback(usbhotplug_callback, this); + bool ret = m_usb->open(); + USBCB status = { GET_DSP_STATUS ,0,0 }; + if (m_usb.get() && m_usb->is_connected()) + { + //m_usb->write_bulk(&status, sizeof(status)); + //m_usb->read_bulk(&status, sizeof(status)); + //std::this_thread::sleep_for(std::chrono::milliseconds(20)); + //notifyscan(); + GetFWVersion(); + } + } +} + +void GScanO400Android::regist_deviceevent_callback(deviceevent_callback callback, void* usrdata) +{ + huagods = usrdata; + dev_callback = callback; +} + +int GScanO400Android::aquire_bmpdata(std::vector& bmpdata) +{ + StopWatch sw; + while (true) + { + if (m_pImages->empty()) { + DoEvents(); + this_thread::sleep_for(chrono::milliseconds(1)); + if (sw.elapsed_s() > 30.00) + { + int roller_num_new = Get_Roller_num(); + if (m_threadUsb && m_threadUsb->joinable()) { + devState = DEV_STOP; + m_threadUsb->join(); + m_threadUsb.reset(); + FileTools::writelog(log_ERROR, "aquire_bmpdata m_threadUsb.reset()"); + } + Stop_scan();//ֹͣɨ + ResetScanner(); + set_scannum(abs(roller_num_new - roller_num)); + return HARDWARE_ERROR; + } + + if (!is_scan()) { + int roller_num_new = Get_Roller_num(); + set_scannum(abs(roller_num_new - roller_num)); + if (devState == DEV_WRONG) { + return get_ErrorCode(); + } + return -1; + } + } + else { + if (m_pImages->valid()) { + bmpdata = *(m_pImages->popBmpdata()); + UpdateScanInfo(get_imgnReaded(), countNTransfered()); + return 0; + } + DoEvents(); + this_thread::sleep_for(chrono::milliseconds(2)); + } + } +} + +BOOL GScanO400Android::IsConnected() +{ + return m_usb.get() && m_usb->is_connected(); +} + +std::string GScanO400Android::GetFWVersion() +{ + if (m_usb.get() && m_usb->is_connected()) { + //lock_guard< mutex> lock(m_imgLocker); + if (fwVersion.empty()) { + fwVersion.resize(10); + USBCB cmd = { GET_FW_VERSION,fwVersion.size(),0, }; + m_usb->write_bulk(&cmd, sizeof(cmd)); + std::this_thread::sleep_for(chrono::milliseconds(10)); + if (m_usb.get() && m_usb->is_connected()) + m_usb->read_bulk(&fwVersion[0], fwVersion.size()); + std::this_thread::sleep_for(chrono::milliseconds(10)); + } + //if (fwVersion.substr(0, 2) == "G3" || fwVersion.substr(0, 2) == "G4" ||fwVersion.substr(0,2)== "GU") + // is_Android = false; + //else + // is_Android = true; + return fwVersion; + } + return ""; +} + +std::string GScanO400Android::GetSerialNum() +{ + //return "G20018000298"; + if (m_usb.get() && m_usb->is_connected()) + { + std::lock_guard lck(m_imgLocker); + if (SerialNum.empty()) { + SerialNum.resize(14); + USBCB usbcb = { GET_SERIAL,SerialNum.size(),0 }; + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + if (m_usb.get() && m_usb->is_connected()) + m_usb->read_bulk(&SerialNum[0], SerialNum.size()); + } + return SerialNum; + } + return ""; +} + +std::uint32_t GScanO400Android::GetMotorFPGA() +{ + if (m_usb.get() && m_usb->is_connected()) + { + std::lock_guard lck(m_imgLocker); + USBCB usbcb = { GET_MOTORFPGA_VERSION,0,sizeof(MotorFpga) }; + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + m_usb->read_bulk(&usbcb, sizeof(usbcb)); + MotorFpga = usbcb.u32_Data; + return MotorFpga; + } + return 0; +} + +std::uint32_t GScanO400Android::GetScanFPGA() +{ + if (m_usb.get() && m_usb->is_connected()) + { + std::lock_guard lck(m_imgLocker); + USBCB usbcb = { GET_SCANFPGA_VERSION,0,4 }; + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + m_usb->read_bulk(&usbcb, sizeof(usbcb)); + ScanFpga = usbcb.u32_Data; + return ScanFpga; + } + return 0; +} + + +bool GScanO400Android::is_scan() +{ + //std::lock_guard lck(m_imgLocker); + return devState == DEV_ISRUNNING; +} + +BOOL GScanO400Android::Get_Scanner_PaperOn() +{ + if (!(m_usb.get() && m_usb->is_open())) + { + Set_ErrorCode(USB_DISCONNECTED); + return true; + } + + USBCB usbcb = { GET_PAPER_STATUS ,2,0 }; + std::lock_guard lck(m_imgLocker); + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + if (m_usb.get() && m_usb->is_connected()) { + m_usb->read_bulk(&usbcb, sizeof(usbcb)); + if (usbcb.u32_Data == 2) + { + Set_ErrorCode(USB_DISCONNECTED); + return true; + } + } + else { + Set_ErrorCode(USB_DISCONNECTED); + return true; + } + return usbcb.u32_Data != 0; +} + +int GScanO400Android::Get_Roller_num() +{ + if (!(m_usb.get() && m_usb->is_open())) + return false; + USBCB usbcb = { GET_ROLLER_NUM ,0,4 }; + std::lock_guard lck(m_imgLocker); + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + m_usb->read_bulk(&usbcb, sizeof(usbcb)); + if (usbcb.u32_CMD != GET_ROLLER_NUM) + { + FileTools::writelog(log_ERROR, "get roller usb bulk error"); + } + FileTools::writelog(log_INFO, "get roller num " + to_string(usbcb.u32_Data)); + return usbcb.u32_Data; +} + +void GScanO400Android::config_params(GScanCap& params) +{ + + if (m_usb.get() && m_usb->is_connected()) { + G400AndroidScanConfig cfg = G400AndroidScanConfig(params); + gcap = params; + UINT32 cfgdata = cfg.GetData(); + USBCB usbcb = { CONFIGURED_DATA,cfgdata,0 }; + FileTools::writelog(log_INFO, "config hardware param" + to_string(cfgdata)); + m_usb->write_bulk(&usbcb, sizeof(USBCB)); + this_thread::sleep_for(std::chrono::milliseconds(200)); + m_pImages->setparam(params); + } +} + +void GScanO400Android::Scanner_StartScan(UINT16 count) +{ + scanfalg = false; + Set_ErrorCode(0); + roller_num = Get_Roller_num(); + std::lock_guard lck(m_imgLocker); + if (m_threadUsb && m_threadUsb->joinable()) { + devState = DEV_STOP; + m_threadUsb->join(); + } + USBCB status = { GET_DSP_STATUS ,0,0 }; + if (m_usb.get() && m_usb->is_connected()) + m_usb->write_bulk(&status, sizeof(status)); + if (m_usb.get() && m_usb->is_connected()) + m_usb->read_bulk(&status, sizeof(status)); + switch (status.u32_Data) + { + case COUNT_MODE: + case NO_FEED: + case OPEN_COVER: + case FEED_IN_ERROR: + case PAPER_JAM: + case DETECT_DOUBLE_FEED: + case DETECT_STAPLE: + case PAPER_SKEW: + case HARDWARE_ERROR: + case PC_SCAN_BUSY_or_ERROR: + m_pImages->setscanflags(false); + devState = DEV_WRONG; + Set_ErrorCode(status.u32_Data); + if (huagods) + dev_callback(status.u32_Data, huagods); + return; + default: + break; + } + + int readlenght = 0; + USBCB paperstatus = { GET_PAPER_STATUS ,0,0 }; + if (m_usb.get() && m_usb->is_connected()) + m_usb->write_bulk(&paperstatus, sizeof(paperstatus)); + if (m_usb.get() && m_usb->is_connected()) + readlenght = m_usb->read_bulk(&paperstatus, sizeof(paperstatus)); + if (paperstatus.u32_Data == 0) { + m_pImages->setscanflags(false); + devState = DEV_WRONG; + int errorcode = 0; + readlenght == 0 ? errorcode = USB_DISCONNECTED : errorcode = NO_FEED; + + Set_ErrorCode(errorcode); + if (huagods) + dev_callback(errorcode, huagods); + return; + } + m_pImages->reset_DogEar(); + if (gcap.is_duplex) + count = count == 65535 ? 65535 : count / 2; + USBCB usbcb = { START_COMMAND,(UINT32)count ,0 }; + if (m_usb.get() && m_usb->is_connected()) + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + this_thread::sleep_for(std::chrono::milliseconds(200)); + if (m_usb.get() && m_usb->is_connected()) + { + m_pImages->setscanflags(true); + m_threadUsb.reset(new std::thread(&GScanO400Android::usbmain, this)); + m_pImages->run(); + } +} + +int GScanO400Android::notifyscan() +{ + //if (!m_usb.get() && !m_usb->is_connected()) + // return -1; + //USBCB notify = { 0x100,0,0 }; + //m_usb->write_bulk(¬ify, sizeof(notify)); + //m_usb->read_bulk(¬ify, sizeof(notify)); + //if ((notify.u32_Data != 0x10 && GetFWVersion().length() < 10) || notify.u32_Data == 0x100) + //{ + // ShellExecute(NULL, TEXT("open"), GetHidedlgPath(), CString("ɨǴ״̬,밴Դѣ ʾ "), NULL, SW_HIDE); + // return -1; + //} + return 1; +} + + +void GScanO400Android::Stop_scan() +{ + std::lock_guard lck(m_imgLocker); + USBCB usbcb = { STOP ,0,0 }; + if (m_usb.get() && m_usb->is_connected()) + { + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + scanfalg = true; + FileTools::writelog(log_INFO, "user stop scan"); + } +} + + +void GScanO400Android::ResetScanner() +{ + if (!(m_usb.get() && m_usb->is_connected())) + return; + + std::lock_guard lck(m_imgLocker); + USBCB usbcb = { INIT_HARDWARE_SYS ,0,0 }; + if (m_usb.get() && m_usb->is_connected()) + m_usb->write_bulk(&usbcb, sizeof(usbcb)); +} + +bool GScanO400Android::Get_IsImageQueueEmpty() +{ + return m_pImages->empty(); +} + +void GScanO400Android::reset() +{ + while (!m_pImages->empty()) + m_pImages->clear(); +} + + +UINT32 GScanO400Android::get_ErrorCode() +{ + return Error_Code; +} + +void GScanO400Android::Set_ErrorCode(UINT32 value) +{ + Error_Code = value; +} + +int GScanO400Android::get_scanned_num() +{ + std::lock_guard lck(m_imgLocker); + USBCB usbcb = { GET_SCANN_NUM ,0,0 }; + if (m_usb.get() && m_usb->is_connected()) + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + + return usbcb.u32_Count; +} + +void GScanO400Android::clear_hwerror() +{ + std::lock_guard lck(m_imgLocker); + USBCB usbcb = { CLEAR_HWERROR ,0,0 }; + if (m_usb.get() && m_usb->is_connected()) + m_usb->write_bulk(&usbcb, sizeof(usbcb)); +} + +void GScanO400Android::set_sleep_time(int mode) +{ + return; +} + +bool GScanO400Android::set_scannercode(std::string str) +{ + if (str.size() != 32) + return false; + if (!(m_usb.get() && m_usb->is_connected())) + return false; + for (int i = 0; i < str.size(); i += 4) + { + USBCB usbcb = { SET_CODE_G400,UINT32(str[i]) + ((UINT32(str[i + 1])) << 8) + (((UINT32)str[i + 2]) << 16) + (((UINT32)str[i + 3]) << 24),i }; + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + } + return true; +} + +std::string GScanO400Android::get_scannercode() +{ + if (!(m_usb.get() && m_usb->is_connected())) + return NULL; + USBCB usb{ GET_CODE_G400,0,32 }; + m_usb->write_bulk(&usb, sizeof(USBCB)); + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + scannercode.resize(32); + m_usb->read_bulk(&scannercode[0], 32); + return scannercode.c_str(); +} + +void GScanO400Android::usbhotplug_callback(bool isconnect, void* userdata) +{ + GScanO400Android* This = (GScanO400Android*)userdata; + This->usbhotplug(isconnect); +} + +void GScanO400Android::usbhotplug(bool isleft) +{ + FileTools::writelog(log_ERROR, "enable usb callback "); + if (isleft) { + devState = DEV_WRONG; + Error_Code = USB_DISCONNECTED; + m_pImages->setscanflags(false); + if (m_usb.get()) + m_usb.reset(); + if (huagods) + dev_callback(USB_DISCONNECTED, huagods); + } +} + +void GScanO400Android::updateHVRatio() +{ + if (!(m_usb.get() && m_usb->is_connected())) + return; + if (m_bread_fixed_ratio_fromDSP) { + USBCB usbcb = { GET_JUST_COF_H ,0,0 }; + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + m_usb->read_bulk(&usbcb, sizeof(usbcb)); + float hratio = *((float*)(&usbcb.u32_Data)); + usbcb = { GET_JUST_COF_V ,0,0 }; + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + m_usb->read_bulk(&usbcb, sizeof(usbcb)); + float vratio = *((float*)(&usbcb.u32_Data)); + m_pImages->updatefixratio(hratio, vratio); + } +} + +void GScanO400Android::usbmain() +{ + std::shared_ptr> imgData; + devState = DEV_ISRUNNING; + image_last = true; + bool haveError = false; + try + { + StopWatch sw; + while (devState == DEV_ISRUNNING) { + if (!(m_usb.get() && m_usb->is_connected())) { + this_thread::sleep_for(chrono::milliseconds(200)); + break; + } + if (sw.elapsed_ms() > 30000) + { + m_pImages->setscanflags(false); + Set_ErrorCode(AQUIRE_IMAGE_TIMEOUT); + devState = DevState::DEV_WRONG; + //devState = haveError ? DevState::DEV_WRONG : DevState::DEV_STOP; + FileTools::writelog(log_ERROR, "USBmain aquire image timeout"); + return; + } + + USBCB usbcb = Get_Scanner_Status(); + switch (usbcb.u32_Data) { + case HAVE_IMAGE: + { + int totalNum = usbcb.u32_Count&0x3fffffff; + if (totalNum < 1) + { + image_last = false; + break; + } + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + m_usb->set_timeout(2000); + imgData = Get_Img_Data(totalNum); + m_usb->set_timeout(200); + if (!imgData->size()) { + Stop_scan(); + FileTools::writelog(log_ERROR, "imgData->size() error"); + break; + } + FileTools::writelog(log_INFO, " get image data size " + to_string(totalNum)); + if (imgData->size() != totalNum) + { + FileTools::writelog(log_ERROR, " get image data size error totalnum " + to_string(totalNum) + " imgdata size " + to_string(imgData->size())); + } + if (!m_pImages->get_isDogEar()) + m_pImages->pushMat(std::shared_ptr(new G400Decode(imgData))); + + UpdateScanInfo(countNReaded(), get_imgTransfered()); + FileTools::writelog(log_INFO, "ɨǽ" + to_string(get_imgnReaded()) + "ļʱ " + to_string(sw.elapsed_ms())); + sw.reset(); + break; + } + case STOP_SCAN: + { + //m_pImages->setscanflags(false); + //std::this_thread::sleep_for(std::chrono::milliseconds(500)); + devState = haveError ? DevState::DEV_WRONG : DevState::DEV_STOP; + break; + } + case COUNT_MODE: + case NO_FEED: + case OPEN_COVER: + case FEED_IN_ERROR: + case PAPER_JAM: + case DETECT_DOUBLE_FEED: + case DETECT_STAPLE: + case PAPER_SKEW: + case HARDWARE_ERROR: + case PC_SCAN_BUSY_or_ERROR: + case SIZE_ERROR: + case USB_BULK_ERROR: + if (!haveError) + { + haveError = true; + Set_ErrorCode(usbcb.u32_Data); + if (huagods) + dev_callback(usbcb.u32_Data, huagods); + } + break; + case NORMAL: + break; + default: + break; + } + this_thread::sleep_for(chrono::milliseconds(10)); + } + + while (image_last) + { + auto usbcb = Get_Scanner_Status(); + if (usbcb.u32_Data != 0x47) + { + this_thread::sleep_for(chrono::milliseconds(10)); + continue; + } + int totalNum = usbcb.u32_Count & 0x3fffffff; + if (totalNum < 1) + { + image_last = false; + break; + } + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + m_usb->set_timeout(2000); + imgData = Get_Img_Data(totalNum); + m_usb->set_timeout(200); + if (!imgData->size()) { + Stop_scan(); + FileTools::writelog(log_ERROR, "imgData->size() error"); + break; + } + FileTools::writelog(log_INFO, " get image data size " + to_string(totalNum)); + if (imgData->size() != totalNum) + { + FileTools::writelog(log_ERROR, " get image data size error totalnum " + to_string(totalNum) + " imgdata size " + to_string(imgData->size())); + } + if (!m_pImages->get_isDogEar()) + m_pImages->pushMat(std::shared_ptr(new G400Decode(imgData))); + UpdateScanInfo(countNReaded(), get_imgTransfered()); + FileTools::writelog(log_INFO, "ɨǽ" + to_string(get_imgnReaded()) + "ļʱ " + to_string(sw.elapsed_ms())); + } + m_pImages->setscanflags(false); + + } + catch (const std::exception& e) + { + FileTools::writelog(log_ERROR, e.what()); + } +} + +/////////////////////////////////////////////////////////////////////////// +USBCB GScanO400Android::Get_Scanner_Status() +{ + if (!(m_usb.get() && m_usb->is_connected())) { + return { NO_COMMAND ,PC_SCAN_BUSY_or_ERROR ,0 }; + } + USBCB usbcb = { GET_DSP_STATUS ,0,0 }; + if (m_usb.get() && m_usb->is_connected()) + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + if (m_usb.get() && m_usb->is_connected()) + m_usb->read_bulk(&usbcb, sizeof(usbcb)); + //if (usbcb.u32_CMD != GET_DSP_STATUS) + //{ + // std::this_thread::sleep_for(std::chrono::milliseconds(50)); + // if (m_usb.get() && m_usb->is_connected()) + // m_usb->read_bulk(&usbcb, 512); + // FileTools::writelog(log_ERROR, "get dsp status error"); + // //return { NO_COMMAND,USB_BULK_ERROR,0 }; + //} + return usbcb; +} + +std::shared_ptr> GScanO400Android::Get_Img_Data(int bufferSize) +{ + try + { + bool ZLP = false; + if (!(m_usb.get() && m_usb->is_connected())) + return std::shared_ptr>(new std::vector()); + if ((bufferSize & 511) == 0) + { + bufferSize += 1; + ZLP = true; + } + std::shared_ptr> imData(new std::vector(bufferSize)); + StopWatch sw; + int readed = 0; + USBCB usbcb = { GET_IMAGE,0,bufferSize }; + m_usb->write_bulk(&usbcb, sizeof(usbcb)); + this_thread::sleep_for(chrono::milliseconds(50)); + int totalength = 512 * 1024; + int startindex = 0; + std::this_thread::sleep_for(std::chrono::microseconds(20)); + while (startindex < bufferSize) + { + startindex += m_usb->read_bulk(imData->data() + startindex, (bufferSize - startindex) < totalength ? (bufferSize - startindex) : totalength); //ݽСڵڹܵʧ + std::this_thread::sleep_for(std::chrono::microseconds(10)); + if (ZLP &&(startindex == (bufferSize - 1))) + { + break; + } + } + if (sw.elapsed_ms() > 5000) + { + FileTools::writelog(log_ERROR, "Usb read data timeout\n"); + } + return imData; + } + catch (const std::exception& e) + { + FileTools::writelog(log_ERROR, e.what()); + } +} + +/////////////////////////////////////////////////////////////////////////// +void GScanO400Android::Pop_Image() +{ + if (!(m_usb.get() && m_usb->is_open())) + return; + + USBCB usbcb = { POP_IMAGE ,0,0 }; + m_usb->write_bulk(&usbcb, sizeof(usbcb)); +} + diff --git a/huagao/Device/GScanO400Android.h b/huagao/Device/GScanO400Android.h new file mode 100644 index 00000000..c3972768 --- /dev/null +++ b/huagao/Device/GScanO400Android.h @@ -0,0 +1,59 @@ +#pragma once +#include "GScan.h" +#include +#include "StopWatch.h" + +class GScanO400Android : public IScanner +{ +public: + GScanO400Android(); + virtual ~GScanO400Android(); + // อจน IGScan ผฬณะ + virtual void open(int vid, int pid) override; + virtual void regist_deviceevent_callback(deviceevent_callback callback, void* usrdata = 0) override; + virtual int aquire_bmpdata(std::vector& bmpdata) override; + virtual BOOL IsConnected() override; + virtual std::string GetFWVersion() override; + virtual std::string GetSerialNum() override; + virtual std::uint32_t GetMotorFPGA() override; + virtual std::uint32_t GetScanFPGA() override; + virtual bool is_scan() override; + virtual BOOL Get_Scanner_PaperOn() override; + virtual int Get_Roller_num() override; + virtual void config_params(GScanCap& params) override; + virtual void Scanner_StartScan(UINT16 count) override; + virtual int notifyscan() override; + virtual void Stop_scan() override; + virtual void ResetScanner() override; + virtual bool Get_IsImageQueueEmpty() override; + virtual void reset() override; + virtual UINT32 get_ErrorCode() override; + virtual void Set_ErrorCode(UINT32 value) override; + virtual int get_scanned_num() override; + virtual void clear_hwerror() override; + virtual void set_sleep_time(int mode) override; + virtual bool set_scannercode(std::string str); + virtual std::string get_scannercode(); + virtual void DogEar_callback(std::function fun) override; + +private: + static void usbhotplug_callback(bool isleft, void* userdata); + void usbhotplug(bool isleft); + void updateHVRatio(); + void usbmain(); + USBCB Get_Scanner_Status(); + void Getimagenumber(bool isadd); + std::shared_ptr> Get_Img_Data(int buffersize); + void Pop_Image(); +private: + bool m_bread_fixed_ratio_fromDSP; + std::shared_ptr m_usb; + std::unique_ptr m_threadUsb; + GScanCap gcap; + volatile int image_num; + volatile bool scanfalg; + volatile bool image_last; + void* huagods; + deviceevent_callback dev_callback; +}; + diff --git a/huagao/Device/ImageMatQueue.cpp b/huagao/Device/ImageMatQueue.cpp index c4918e94..6b55413c 100644 --- a/huagao/Device/ImageMatQueue.cpp +++ b/huagao/Device/ImageMatQueue.cpp @@ -159,28 +159,13 @@ void ImageMatQueue::setparam(const GScanCap& param) //scanParam.imageRotateDegree = 90.0f; m_iaList.clear(); + if (scanParam.fillhole.is_fillhole) { float ratio = scanParam.fillhole.fillholeratio / 100.0; - m_iaList.push_back(shared_ptr(new CImageOutHole(200, ratio, 50))); + m_iaList.push_back(shared_ptr(new CImageApplyOutHole(200, ratio, 50))); } //ȷܹȡͼ - { - bool islongcustomcrop = param.papertype == TwSS::USStatement; - //bool isautocrop = param.papertype == TwSS::None; - CSize fixedSize; -#ifdef REAL300DPI - fixedSize = papersize.GetPaperSize(param.papertype, param.resolution_dst > 240.0f ? 300.0f : 200.0f, param.paperAlign); -#else // REAL300DPI - fixedSize = papersize.GetPaperSize(param.papertype, 200.0f, param.paperAlign); -#endif - bool normalCrop = ((param.autodescrew) || (islongcustomcrop ? islongcustomcrop : param.is_autocrop) || (param.fillbackground)) ? false : param.normalCrop; - m_iaList.push_back(shared_ptr(new CImageApplyAutoCrop(islongcustomcrop ? islongcustomcrop : param.is_autocrop, - param.autodescrew, param.fillbackground, cv::Size(fixedSize.cx, fixedSize.cy), param.is_convex, false, param.AutoCrop_threshold, param.noise, param.indent, normalCrop))); - /* m_iaList.push_back(shared_ptr(new CImageApplyAutoCrop(true, param.autodescrew, param.fillbackground, cv::Size(fixedSize.cx, fixedSize.cy), param.is_convex, false, param.AutoCrop_threshold, param.noise, param.indent))); - if(!(islongcustomcrop ? islongcustomcrop : param.is_autocrop)) - m_iaList.push_back(shared_ptr(new CImageApplyResize(CImageApplyResize::ResizeType::DSIZE, cv::Size(fixedSize.cx, fixedSize.cy), 1.0, 1.0)));*/ - } if (param.is_autodiscradblank_normal || param.is_autodiscradblank_vince) { //m_iaList.push_back(shared_ptr(new CImageApplyDiscardBlank())); CImageApplyDiscardBlank* disBlank = new CImageApplyDiscardBlank(); @@ -228,6 +213,25 @@ void ImageMatQueue::setparam(const GScanCap& param) //m_iaList.push_back(shared_ptr(new CImageApplyDiscardBlank(param.areanum,param.devnmax))); } + { + bool islongcustomcrop = param.papertype == TwSS::USStatement; + //bool isautocrop = param.papertype == TwSS::None; + CSize fixedSize; +#ifdef REAL300DPI + fixedSize = papersize.GetPaperSize(param.papertype, param.resolution_dst > 240.0f ? 300.0f : 200.0f, param.paperAlign); +#else // REAL300DPI + fixedSize = papersize.GetPaperSize(param.papertype, 200.0f, param.paperAlign); +#endif + bool normalCrop = ((param.autodescrew) || (islongcustomcrop ? islongcustomcrop : param.is_autocrop) || (param.fillbackground)) ? false : param.normalCrop; + m_iaList.push_back(shared_ptr(new CImageApplyAutoCrop(islongcustomcrop ? islongcustomcrop : param.is_autocrop, + param.autodescrew, param.fillbackground, cv::Size(fixedSize.cx, fixedSize.cy), param.is_convex, false, param.AutoCrop_threshold, param.noise, param.indent, normalCrop))); + + /* m_iaList.push_back(shared_ptr(new CImageApplyAutoCrop(true, param.autodescrew, param.fillbackground, cv::Size(fixedSize.cx, fixedSize.cy), param.is_convex, false, param.AutoCrop_threshold, param.noise, param.indent))); + if(!(islongcustomcrop ? islongcustomcrop : param.is_autocrop)) + m_iaList.push_back(shared_ptr(new CImageApplyResize(CImageApplyResize::ResizeType::DSIZE, cv::Size(fixedSize.cx, fixedSize.cy), 1.0, 1.0)));*/ + } + + //filter 0 r 1 g 2 b 3 none enhance color 0 none 1 r 2 g 3 b if (param.filter != 3 || param.enhance_color) { int channel = 0; //filter none r g b enhance none r g b @@ -311,6 +315,8 @@ void ImageMatQueue::setparam(const GScanCap& param) SHGetSpecialFolderPath(NULL, szIniFile, CSIDL_WINDOWS, TRUE); #ifdef LANXUM _tcscat(szIniFile, _T("\\twain_32\\LANXUMSCAN\\tessdata")); +#elif defined AUGE + _tcscat(szIniFile, _T("\\twain_32\\AuGeScan\\tessdata")); #elif defined HANVON _tcscat(szIniFile, _T("\\twain_32\\HanvonScan\\tessdata")); #else @@ -322,6 +328,7 @@ void ImageMatQueue::setparam(const GScanCap& param) m_iaList.push_back(shared_ptr(new CImageApplyRotation(type, param.is_backrotate180, param.resolution_dst, chRtn))); delete[] chRtn; } + } void ImageMatQueue::EnqueueBmpBuffer(std::shared_ptr> bmpdata) @@ -435,6 +442,7 @@ bool ImageMatQueue::queuesempty() return atm_orgin_image_remains <= 0 && m_imagedata.Size() == 0; } +static int indeximg = 0; void ImageMatQueue::proc() { @@ -509,23 +517,25 @@ void ImageMatQueue::proc() else { auto mat = imread(info.path, rmc); + //cv::imwrite("D:\\img"+to_string(indeximg++)+".jpg", mat); //auto mat = imread(info.path, IMREAD_COLOR); //if (rmc == IMREAD_GRAYSCALE) // cvtColor(mat, mat, CV_RGB2GRAY); if (!mat.empty()) { - Mat front = mat(Rect(0, 0, mat.cols / 2, mat.rows)); - Mat back = mat(Rect(mat.cols / 2, 0, mat.cols / 2, mat.rows)); + Mat front = mat(Rect(0, 0, mat.cols / 2, mat.rows-10));//ͼβЧݶ10 + Mat back = mat(Rect(mat.cols / 2, 0, mat.cols / 2, mat.rows-10));//ͼβЧݶ10 #ifdef UV mats.push_back(scanParam.is_switchfrontback ? front : back); mats.push_back(scanParam.is_switchfrontback ? back : front); #else + if (scanParam.imageRotateDegree != 0.0 && scanParam.imageRotateDegree != 180.0) { cv::flip(front, front, 0); cv::flip(front, front, 1); } - mats.push_back(back); - mats.push_back(front); + mats.push_back(scanParam.is_switchfrontback ? front : back); + mats.push_back(scanParam.is_switchfrontback ? back : front); #endif front.release(); back.release(); @@ -558,7 +568,6 @@ void ImageMatQueue::proc() std::vector rects; std::vector angleResults; bool isDesaskew = false; - sw.reset(); for (int j = 0; j < m_iaList.size(); j++) { m_iaList[j]->apply(mats, scanParam.is_duplex); @@ -571,6 +580,7 @@ void ImageMatQueue::proc() else if (typeid(*ptr) == typeid(CImageApplyRotation)) angleResults = dynamic_cast(ptr)->angleResults(); } + #ifdef UV if (!uvmats.empty()) { diff --git a/huagao/Device/ImageMatQueue.h b/huagao/Device/ImageMatQueue.h index 62ca9173..369d6c57 100644 --- a/huagao/Device/ImageMatQueue.h +++ b/huagao/Device/ImageMatQueue.h @@ -49,17 +49,17 @@ public: } memcpy(m_data->data() + 54, colortable, 256 * 4); } - //cv::imencode(".bmp", mat, *(m_data.get())); + cv::imencode(".bmp", mat, *(m_data.get())); setBmpFileHeader(mat); setBmpInfoHeader(mat, res); - uchar* data = m_data->data() + headersize + bmpdatasize; - uchar* matdata = mat.data; - for (int i = 0; i < mat.rows; i++) { - data -= m_datalinesize; - memcpy(data, matdata, step); - matdata += step; - } + //uchar* data = m_data->data() + headersize + bmpdatasize; + //uchar* matdata = mat.data; + //for (int i = 0; i < mat.rows; i++) { + // data -= m_datalinesize; + // memcpy(data, matdata, step); + // matdata += step; + //} } private: void setBmpFileHeader(const cv::Mat& mat) @@ -90,8 +90,6 @@ private: class Mat2BmpBw :public IMat2Bmp { public: Mat2BmpBw(const cv::Mat& mat, float res) { - //static int indeximg = 0; - //cv::imwrite("D:\\" + to_string(++indeximg) + ".jpg", mat); m_data = std::shared_ptr>(new std::vector()); int headsize = 62; int width = mat.cols; diff --git a/huagao/Device/PaperSize.cpp b/huagao/Device/PaperSize.cpp index 9f80e75f..ebe609bc 100644 --- a/huagao/Device/PaperSize.cpp +++ b/huagao/Device/PaperSize.cpp @@ -24,7 +24,11 @@ namespace Device { papersize.insert({ B4,CSize(250,353) }); papersize.insert({ B5,CSize(176,250) }); papersize.insert({ B6,CSize(125,176) }); +#ifdef G400 + papersize.insert({ MaxSize,CSize(297,420 * 1.5) }); +#else papersize.insert({ MaxSize,CSize(297,420 * 2) }); +#endif papersize.insert({ USStatement,CSize(297,420 * 1.5) }); papersize.insert({ USLetter,CSize(216,279) }); papersize.insert({ USLegal,CSize(216,356) }); diff --git a/huagao/Device/PublicFunc.cpp b/huagao/Device/PublicFunc.cpp index a3fb52da..c15f7e6c 100644 --- a/huagao/Device/PublicFunc.cpp +++ b/huagao/Device/PublicFunc.cpp @@ -461,6 +461,8 @@ CString GetHidedlgPath() SHGetSpecialFolderPath(NULL, szIniFile, CSIDL_WINDOWS, TRUE); #ifdef MAKEHUAGAO _tcscat(szIniFile, _T("\\twain_32\\HuaGoScan\\hidedlg.exe")); +#elif defined AUGE + _tcscat(szIniFile, _T("\\twain_32\\AuGeScan\\hidedlg.exe")); #elif defined HANVON _tcscat(szIniFile, _T("\\twain_32\\HanvonScan\\hidedlg.exe")); #elif defined LANXUM diff --git a/huagao/Device/PublicFunc.h b/huagao/Device/PublicFunc.h index 5f24d597..f79c0bf1 100644 --- a/huagao/Device/PublicFunc.h +++ b/huagao/Device/PublicFunc.h @@ -75,6 +75,7 @@ const std::string DOCORIENTATION = "bOrientation"; const std::string AUTO_TEXT = "bAutoText"; const std::string BACKROTATE180 = "iBackRotate180"; const std::string DOGEAR_DETECTION = "dogeardetection"; +const std::string DOGEAR_DISTANCE = "idogeardistance"; const std::string SCREWDETECT = "bScrewDetect"; const std::string SCREWLEVEL = "iScrewLevel"; const std::string ITEMCAPTION = "Caption"; @@ -85,6 +86,10 @@ const std::string AUTOCROP_THRESHOLD = "AutoCrop_Threshold"; const std::string NOISE = "Noise"; const std::string LOWPOWERMODE = "ilowpowermode"; + +//twain õȲ +const std::string ROLLERMSGDATE = "RollerMsgDate"; +const std::string PRINTFCAPABILITY = "PrintfCapability"; #pragma pack(push) #pragma pack(4) /****************** @@ -257,6 +262,7 @@ struct GScanCap unsigned short scannum; /**< ɨ*/ uint8_t is_backrotate180; /**< ת180*/ uint8_t is_dogeardetection; /**<۽Ǽ*/ + uint32_t dogeardistance; /**<۽ǼⷶΧ*/ HardwareCaps hardwarecaps; /**< Ӳɨ*/ FillHole fillhole; DetachNoise detachnoise; /**< ڰ׽*/ @@ -335,6 +341,7 @@ struct GScanCap_3399 CropRect cropRect; /**< Զ>*/ MultiOutput multiOutput; /**< >*/ bool normalCrop; /**< Զɫ>*/ + uint32_t dogeardistabce; /**< ۽Ǽ۶㵽ʵ¾>*/ uint32_t reserve[1024]; /**< Ԥ4096ֽЭչ*/ }; diff --git a/huagao/Device/UsbScanEx.cpp b/huagao/Device/UsbScanEx.cpp index dc382834..9861c817 100644 --- a/huagao/Device/UsbScanEx.cpp +++ b/huagao/Device/UsbScanEx.cpp @@ -3,7 +3,320 @@ #include #include -#include "filetools.h" + +//#ifdef ANDROIDSERIAL +#if false + +UsbScanEx::UsbScanEx(int index) +{ + m_h_dev = INVALID_HANDLE_VALUE; + timeout = 100; + m_h_index = index; + CTRL_IN_OUT = 3; +} + +UsbScanEx::~UsbScanEx() +{ + if (m_h_dev != INVALID_HANDLE_VALUE) + close(); +} + +bool UsbScanEx::open() +{ + BOOL b_ret = FALSE; + TCHAR szDevPath[MAX_PATH] = { 0 }; + DWORD cbRet = 0; + + USBSCAN_TIMEOUT ut; + //ut.TimeoutEvent = 1; + //ut.TimeoutRead = 1; + //ut.TimeoutWrite = 1; + ut.TimeoutEvent = 0; + ut.TimeoutRead = 0; + ut.TimeoutWrite = 0; + + _stprintf(szDevPath, TEXT("\\\\.\\Usbscan%d"), m_h_index); + m_h_dev = CreateFile(szDevPath, + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + if (m_h_dev != INVALID_HANDLE_VALUE) { + m_b_is_connected = TRUE; + b_ret = DeviceIoControl(m_h_dev, (DWORD)IOCTL_GET_PIPE_CONFIGURATION, + NULL, 0, &m_usbscan_config, sizeof(USBSCAN_PIPE_CONFIGURATION), + &cbRet, NULL); + if (b_ret && m_usbscan_config.NumberOfPipes > 0) { + for (int by_i = 0x00; (ULONG)by_i < m_usbscan_config.NumberOfPipes; by_i++) { + + TCHAR szPipePath[MAX_PATH] = { 0 }; + _stprintf(szPipePath, TEXT("\\\\.\\Usbscan%d\\%d"), m_h_index, by_i); + m_usb_pipes[by_i].pipe_info = m_usbscan_config.PipeInfo[by_i]; + m_usb_pipes[by_i].h_pipe = CreateFile(szPipePath, + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + if (m_usbscan_config.PipeInfo[by_i].PipeType == USBSCAN_PIPE_INTERRUPT) { + INT_IN = by_i; + } + else { + if (m_usbscan_config.PipeInfo[by_i].EndpointAddress & 0x80) { + BULK_IN = by_i; + } + else { + BULK_OUT = by_i; + } + } + b_ret = DeviceIoControl(m_usb_pipes[by_i].h_pipe, IOCTL_SET_TIMEOUT, &ut, sizeof(ut), NULL, 0, &cbRet, NULL); + } + } + } + else { + CloseHandle(m_h_dev); + m_h_dev = INVALID_HANDLE_VALUE; + } + //FileTools::writelog(log_lv::log_INFO,"USB Open!"); + return m_h_dev; +} + +void UsbScanEx::set_usbhotplug_callback(usbhotplug_callback callback, void* userdata) +{ + hotplug_call = callback; + usrdata = userdata; +} + +bool UsbScanEx::close() +{ + BOOL b_ret = FALSE; + BYTE by_i = 0x00; + + if (m_h_dev != INVALID_HANDLE_VALUE) { + PIPE_TYPE pipeType = ALL_PIPE; + //b_ret = DeviceIoControl(m_h_dev, (DWORD)IOCTL_RESET_PIPE, + // &pipeType, sizeof(PIPE_TYPE), NULL, 0,NULL, NULL); + BOOL bState = FALSE; + DWORD cbRet = 0; + + for (by_i = 0x00; by_i < m_usbscan_config.NumberOfPipes; by_i++) { + //b_ret = DeviceIoControl(m_h_dev, (DWORD)IOCTL_RESET_PIPE, + // &pipeType, sizeof(PIPE_TYPE), NULL, 0, NULL, NULL); + CloseHandle(m_usb_pipes[by_i].h_pipe); + m_usb_pipes[by_i].h_pipe = INVALID_HANDLE_VALUE; + } + b_ret = CloseHandle(m_h_dev); + + if (b_ret) { + m_h_dev = INVALID_HANDLE_VALUE; + b_ret = TRUE; + } + } + m_b_is_connected = FALSE; + //FileTools::writelog(log_lv::log_INFO,"USB Close!"); + return b_ret; +} + +void UsbScanEx::set_timeout(int timeout) +{ + this->timeout = timeout; +} + +int UsbScanEx::read_bulk(void* data, int len) +{ + BOOL b_ret = FALSE; + HANDLE h_pipe = m_usb_pipes[BULK_IN].h_pipe; + unsigned long pdw_ret = len; + if (m_h_dev != NULL) { + b_ret = ReadFile(h_pipe, data, len, &pdw_ret, NULL); + if (b_ret) { + return pdw_ret; + } + else { + int error_code = GetLastError(); + switch (error_code) + { + case ERROR_FILE_NOT_FOUND: + case ERROR_ACCESS_DENIED: + m_b_is_connected = false; + if (hotplug_call) { + hotplug_call(true, usrdata); + } + break; + default: + break; + } + } + } + return 0; +} + +int UsbScanEx::write_bulk(void* data, int len) +{ + BOOL b_ret = FALSE; + HANDLE h_pipe = m_usb_pipes[BULK_OUT].h_pipe; + void* p_data = data; + unsigned long dw_size = len; + if (m_h_dev == INVALID_HANDLE_VALUE) + return TRUE; + b_ret = WriteFile(h_pipe, p_data, dw_size, &dw_size, NULL); + if (b_ret) { + return dw_size; + } + else { + int error_code = GetLastError(); + switch (error_code) + { + case ERROR_FILE_NOT_FOUND: + case ERROR_ACCESS_DENIED: + m_b_is_connected = false; + if (hotplug_call) { + hotplug_call(true, usrdata); + } + break; + default: + break; + } + } + return 0; +} + +int UsbScanEx::control_msg(int rtype, int req, int value, int index, int len, void* data) +{ + BOOL b_ret = FALSE; + _IO_BLOCK_EX irp; + DWORD dw_ret; + + if (m_h_dev == INVALID_HANDLE_VALUE) + return TRUE; + irp.uOffset = value; + irp.uLength = len; + irp.uIndex = index; + irp.pbyData = (LPBYTE)data; + irp.fTransferDirectionIn = (rtype >> 7); + irp.bRequest = req; + irp.bmRequestType = (rtype >> 5) & 0x03; + + LPOVERLAPPED lp_overlap = ov + CTRL_IN_OUT; + b_ret = DeviceIoControl(m_h_dev, IOCTL_SEND_USB_REQUEST, &irp, sizeof(irp), data, len, &dw_ret, NULL); + + //if (!b_ret) + // b_ret = WaitForSingleObject(lp_overlap->hEvent, timeout) == WAIT_OBJECT_0; + + return b_ret; +} + +bool UsbScanEx::is_open() +{ + return m_h_dev != INVALID_HANDLE_VALUE; +} + +bool UsbScanEx::is_connected() +{ + return is_open();//m_b_is_connected; +} + +int UsbScanEx::read_int(void* data, int len) +{ + BOOL b_ret = FALSE; + DWORD dw_ret = 0L; + HANDLE h_pipe = m_usb_pipes[INT_IN].h_pipe; + + if (m_h_dev == INVALID_HANDLE_VALUE) + return FALSE; + + b_ret = DeviceIoControl(h_pipe, (DWORD)IOCTL_WAIT_ON_DEVICE_EVENT, NULL, 0, + data, len, &dw_ret, NULL); + + if (b_ret) { + return dw_ret; + } + else { + switch (GetLastError()) + { + case ERROR_FILE_NOT_FOUND: + case ERROR_ACCESS_DENIED: + m_b_is_connected = false; + if (hotplug_call) { + hotplug_call(true, usrdata); + } + break; + default: + break; + } + } + + return 0; +} + +UsbScan_List::~UsbScan_List() +{ +} + +std::list> UsbScan_List::find_all() +{ + auto devs = find_all_usb(); + std::list> usbs; + for (auto inter = devs.begin(); inter != devs.end(); inter++) { + usbs.push_back(std::shared_ptr(new UsbScanEx(inter->index))); + } + return usbs; +} + +std::list> UsbScan_List::find_vid_pid(int vid, int pid) +{ + auto devs = find_all_usb(); + std::list> usbs; + for (auto inter = devs.begin(); inter != devs.end(); inter++) { + if (inter->vid == vid && inter->pid == pid) + usbs.push_back(std::shared_ptr(new UsbScanEx(inter->index))); + } + return usbs; +} + +std::list UsbScan_List::find_all_usb() +{ + BOOL b_ret = FALSE; + DWORD cbRet = 0; + TCHAR szDevPath[MAX_PATH] = { 0 }; + DEVICE_DESCRIPTOR dev_desc; + HANDLE h_dev; + std::list usbs; + usb_scan_dev_info dev_info; + + for (int i = 0; i < 1024; i++) { + + _stprintf(szDevPath, TEXT("\\\\.\\Usbscan%d"), i); + h_dev = CreateFile(szDevPath, + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + if (h_dev != INVALID_HANDLE_VALUE) { + b_ret = DeviceIoControl(h_dev, (DWORD)IOCTL_GET_DEVICE_DESCRIPTOR, + &dev_desc, sizeof(dev_desc), &dev_desc, sizeof(dev_desc), + &cbRet, NULL); + if (b_ret != 0) { + dev_info.index = i; + dev_info.vid = dev_desc.usVendorId; + dev_info.pid = dev_desc.usProductId; + usbs.push_back(dev_info); + } + CloseHandle(h_dev); + } + } + + return usbs; +} + +#else + + UsbScanEx::UsbScanEx(int index) { @@ -154,7 +467,6 @@ int UsbScanEx::read_bulk(void* data, int len) lp_overlap->Offset = 0; lp_overlap->OffsetHigh = 0; lp_overlap->Pointer = 0; - if (m_h_dev != NULL) { b_ret = ReadFile(h_pipe, data, len, &pdw_ret, lp_overlap); //b_ret = GetOverlappedResult(h_pipe, lp_overlap, &pdw_ret, TRUE); @@ -167,10 +479,12 @@ int UsbScanEx::read_bulk(void* data, int len) switch (error_code) { case ERROR_IO_PENDING: { - auto ret = WaitForSingleObject(lp_overlap->hEvent, 300); - //FileTools::writelog(log_FATAL, "WaitForSingleObject return " + std::to_string(ret));; +#ifdef ANDROIDSERIAL + GetOverlappedResult(h_pipe, lp_overlap, &pdw_ret, TRUE); +#else + WaitForSingleObject(lp_overlap->hEvent, 500); GetOverlappedResult(h_pipe, lp_overlap, &pdw_ret, FALSE); - //GetOverlappedResult(h_pipe, lp_overlap, &pdw_ret, TRUE); +#endif // ANDROIDSERIAL return pdw_ret; } case ERROR_FILE_NOT_FOUND: @@ -205,14 +519,15 @@ int UsbScanEx::write_bulk(void* data, int len) return dw_size; } else { - //int errorcode = GetLastError(); - //switch (errorcode) switch (GetLastError()) { case ERROR_IO_PENDING: +#ifdef ANDROIDSERIAL + GetOverlappedResult(h_pipe, lp_overlap, &dw_size, TRUE); +#else WaitForSingleObject(lp_overlap->hEvent, 500); GetOverlappedResult(h_pipe, lp_overlap, &dw_size, FALSE); - //GetOverlappedResult(h_pipe, lp_overlap, &dw_size, TRUE); +#endif // ANDROIDSERIAL return dw_size; case ERROR_FILE_NOT_FOUND: case ERROR_ACCESS_DENIED: @@ -362,3 +677,4 @@ std::list UsbScan_List::find_all_usb() return usbs; } +#endif // ANDROIDSERIAL \ No newline at end of file diff --git a/huagao/Device/UsbScanEx.h b/huagao/Device/UsbScanEx.h index 13a1b9d8..2b7e09d0 100644 --- a/huagao/Device/UsbScanEx.h +++ b/huagao/Device/UsbScanEx.h @@ -3,7 +3,7 @@ #include #include #endif // WINDOWS - +#include #include #include #include "IUsb.h" diff --git a/huagao/Device/filetools.h b/huagao/Device/filetools.h index c9a8d12f..0c5ab5f0 100644 --- a/huagao/Device/filetools.h +++ b/huagao/Device/filetools.h @@ -8,6 +8,7 @@ #include #include "PublicFunc.h" +#define enum2str(R) #R enum log_lv :int { log_TRACE = 0, diff --git a/huagao/GscanJsonConfig.cpp b/huagao/GscanJsonConfig.cpp index f8221c7c..58b63594 100644 --- a/huagao/GscanJsonConfig.cpp +++ b/huagao/GscanJsonConfig.cpp @@ -136,6 +136,7 @@ void GscanJsonConfig::SaveGscanCapConfig(const GScanCap & gcap, const std::strin outJson["Config"].Add(INDENT, (int)(gcap.indent)); outJson["Config"].Add(AUTOCROP_THRESHOLD, (int)(gcap.AutoCrop_threshold)); outJson["Config"].Add(DOGEAR_DETECTION, (bool)(gcap.is_dogeardetection), false); + outJson["Config"].Add(DOGEAR_DISTANCE, (uint32_t)(gcap.dogeardistance)); outJson["Config"].Add(SCREWDETECT, (bool)(gcap.hardwarecaps.en_skrewdetect), false); outJson["Config"].Add(SCREWLEVEL, (int)(gcap.hardwarecaps.skrewdetectlevel)); outJson["Config"].Add(ITEMCAPTION, (string)(gcap.Caption)); @@ -203,7 +204,7 @@ void GscanJsonConfig::WriteJsonArrayToFile(std::vector cfgArray, const root["Config"].AddEmptySubArray(INDENT); root["Config"].AddEmptySubArray(AUTOCROP_THRESHOLD); root["Config"].AddEmptySubArray(ISCONVEX); - + root["Config"].AddEmptySubArray(DOGEAR_DISTANCE); /*< other settings*/ root["Config"].AddEmptySubArray(ITEMCAPTION); @@ -257,6 +258,7 @@ void GscanJsonConfig::WriteJsonArrayToFile(std::vector cfgArray, const root["Config"][ISCONVEX].Add(i, (bool)cfgArray[i].is_convex); root["Config"][AUTOCROP_THRESHOLD].Add((int)cfgArray[i].AutoCrop_threshold); root["Config"][DOGEAR_DETECTION].Add(i, (bool)cfgArray[i].is_dogeardetection); + root["Config"][DOGEAR_DISTANCE].Add((int)cfgArray[i].dogeardistance); root["Config"][SCREWDETECT].Add(i, (bool)cfgArray[i].hardwarecaps.en_skrewdetect); root["Config"][SCREWLEVEL].Add((int)cfgArray[i].hardwarecaps.skrewdetectlevel); @@ -449,6 +451,8 @@ std::vector GscanJsonConfig::parseJsonFromString(const std::string str root["Config"].Get(AUTOCROP_THRESHOLD, itmAutoCrop_t); neb::CJsonObject itmdogeardetection; root["Config"].Get(DOGEAR_DETECTION, itmdogeardetection); + neb::CJsonObject itmdogdistance; + root["Config"].Get(DOGEAR_DISTANCE, itmdogdistance); neb::CJsonObject itmScrewDetct; root["Config"].Get(SCREWDETECT, itmScrewDetct); neb::CJsonObject itmScrewLevel; @@ -562,6 +566,8 @@ std::vector GscanJsonConfig::parseJsonFromString(const std::string str cfp.is_convex = b_value ? 1 : 0; itmdogeardetection.Get(i, b_value); cfp.is_dogeardetection = b_value ? 1 : 0; + itmdogdistance.Get(i, i_value); + cfp.dogeardistance = i_value; itmScrewDetct.Get(i, b_value); cfp.hardwarecaps.en_skrewdetect = b_value ? 1 : 0; itmScrewLevel.Get(i, i_value); @@ -675,6 +681,8 @@ std::vector GscanJsonConfig::parseJsonFromString(const std::string str cfp.is_convex = bvalue ? 1 : 0; root["Config"].Get(DOGEAR_DETECTION, bvalue); cfp.is_dogeardetection = bvalue ? 1 : 0; + root["Config"].Get(DOGEAR_DISTANCE, index); + cfp.dogeardistance = index; root["Config"].Get(SCREWDETECT, bvalue); cfp.hardwarecaps.en_skrewdetect = bvalue ? 1 : 0; root["Config"].Get(SCREWLEVEL, index); @@ -757,6 +765,7 @@ json GscanJsonConfig::GscancapToJson(GScanCap& cap) js[CONFIG][AUTO_TEXT] = cap.is_autotext; js[CONFIG][BACKROTATE180] = cap.is_backrotate180; js[CONFIG][DOGEAR_DETECTION] = cap.is_dogeardetection; + js[CONFIG][DOGEAR_DISTANCE] = cap.dogeardistance; js[CONFIG][SCREWDETECT] = cap.hardwarecaps.en_skrewdetect; js[CONFIG][SCREWLEVEL] = cap.hardwarecaps.skrewdetectlevel; js[CONFIG][NOISE] = cap.noise; @@ -815,6 +824,7 @@ GScanCap GscanJsonConfig::JsonToGscancap(json& js) cap.is_autotext = json_cast(js[CONFIG][AUTO_TEXT]).to_int(); cap.is_backrotate180 = json_cast(js[CONFIG][BACKROTATE180]).to_int(); cap.is_dogeardetection = json_cast(js[CONFIG][DOGEAR_DETECTION]).to_int(); + cap.dogeardistance = json_cast(js[CONFIG][DOGEAR_DISTANCE]).to_uint32(); cap.hardwarecaps.en_skrewdetect = json_cast(js[CONFIG][SCREWDETECT]).to_int(); cap.hardwarecaps.skrewdetectlevel = json_cast(js[CONFIG][SCREWLEVEL]).to_int(); cap.noise = json_cast(js[CONFIG][NOISE]).to_int(); @@ -869,6 +879,7 @@ json GscanJsonConfig::GetDefaultJson() "bAutoText": false , "iBackRotate180": false , "dogeardetection": false , + "idogeardistance": 50 , "bScrewDetect": true , "iScrewLevel": 3 , "Noise": 8 , @@ -920,6 +931,7 @@ json GscanJsonConfig::GetDefaultJson() "bAutoText": false , "iBackRotate180": false , "dogeardetection": false , + "idogeardistance": 50 , "bScrewDetect": true , "iScrewLevel": 3 , "Noise": 8 , @@ -955,3 +967,97 @@ json GscanJsonConfig::Readjson(std::string path) return GetDefaultJson(); } } + +Twain_config::Twain_config() +{ +} + +Twain_config::~Twain_config() +{ +} + +int Twain_config::getrollermsgdate() +{ + loadjson(GetTwainInIPath() + TCHAR2STRING(TWAIN_CONFIG_JSON)); + if (m_json[ROLLERMSGDATE].is_null()) + return 0; + int date = 0; + m_json[ROLLERMSGDATE].get_to(date); + return date; +} + +void Twain_config::GetOrSetPintfCapability(int& value,bool is_get) +{ + loadjson(GetTwainInIPath() + TCHAR2STRING(TWAIN_CONFIG_JSON)); + if (is_get) { + if (m_json[PRINTFCAPABILITY].is_null()) { + value = 0; + return; + } + m_json[PRINTFCAPABILITY].get_to(value); + } + else{ + m_json[PRINTFCAPABILITY] = value; + savejson(m_json, GetTwainInIPath() + TCHAR2STRING(TWAIN_CONFIG_JSON)); + } +} + +void Twain_config::setrollermsgdata(int value) +{ + loadjson(GetTwainInIPath() + TCHAR2STRING(TWAIN_CONFIG_JSON)); + m_json[ROLLERMSGDATE] = value; + savejson(m_json, GetTwainInIPath() + TCHAR2STRING(TWAIN_CONFIG_JSON)); +} + +std::string Twain_config::GetTwainInIPath() +{ + TCHAR szIniFile[MAX_PATH] = { 0 }; + SHGetSpecialFolderPath(NULL, szIniFile, CSIDL_LOCAL_APPDATA, TRUE); + _tcscat(szIniFile, HUAGAO_SCAN); + _tcscat(szIniFile, TWAIN_INIPATH); + _tcscat(szIniFile, TEXT("\\")); + return TCHAR2STRING(szIniFile); +} + +void Twain_config::savejson(json js, std::string path) +{ + std::ofstream of(path); + if(of.is_open()) + { + of.write(js.dump().data(), js.dump().size()); + of.close(); + } + else{ + FileTools::writelog(log_ERROR, "save json error "); + } +} +json Twain_config::loadjson(std::string path) +{ + std::ifstream f; + f.open(path, std::ios::in | std::ios::binary); + json js; + try { + if (f.is_open()) { + std::string text = (std::ostringstream() << f.rdbuf()).str(); + js = json::parse(text); + f.close(); + } + m_json = js; + return js.is_object() ? js : throw std::exception("js pares error"); + } + catch (...) + { + FileTools::writelog(log_ERROR, "read json error"); + f.is_open() ? f.close() : void(); + m_json = defaultjson(); + return m_json; + } +} + +json Twain_config::defaultjson() +{ + json tmp; + tmp[ROLLERMSGDATE] = 0; + tmp[PRINTFCAPABILITY] = 0; + return tmp; +} \ No newline at end of file diff --git a/huagao/GscanJsonConfig.h b/huagao/GscanJsonConfig.h index 41722a9d..daac2c24 100644 --- a/huagao/GscanJsonConfig.h +++ b/huagao/GscanJsonConfig.h @@ -97,5 +97,23 @@ public: json Readjson(std::string path); void SaveGscancapJson(GScanCap cap, std::string path); GScanCap JsonToGscancap(json& js); + +}; + +class Twain_config +{ +public: + Twain_config(); + ~Twain_config(); + int getrollermsgdate(); + void setrollermsgdata(int value); + void GetOrSetPintfCapability(int& value,bool is_get); + +private: + std::string GetTwainInIPath(); + json loadjson(std::string path); + void savejson(json js, std::string path); + json defaultjson(); + json m_json; }; diff --git a/huagao/ImageProcess/ImageApplyAutoCrop.cpp b/huagao/ImageProcess/ImageApplyAutoCrop.cpp index 45af1f28..430b4ab6 100644 --- a/huagao/ImageProcess/ImageApplyAutoCrop.cpp +++ b/huagao/ImageProcess/ImageApplyAutoCrop.cpp @@ -53,7 +53,6 @@ cv::Mat concatenateMatrix(const cv::Mat& first, const cv::Mat& second) return mul_r; } - std::vector comMat() { std::vector mats; @@ -61,14 +60,9 @@ std::vector comMat() srcTri[0] = cv::Point2f(1, 1); srcTri[1] = cv::Point2f(1, 0); srcTri[2] = cv::Point2f(0, 1); - const float fact = 0.1f; - - float pos[] = { 0, 2 * fact, fact }; + const float fact = 0.33f; + float pos[] = { 0, 2 * fact, fact }; cv::Point2f dstTri[3]; - dstTri[0] = cv::Point2f(1, 1); - dstTri[1] = cv::Point2f(1, 0.5); - dstTri[2] = cv::Point2f(0, 1); - for (int i = 0; i < 3; i++) { dstTri[0] = cv::Point2f(1, 1 + pos[i]); @@ -123,8 +117,15 @@ void CImageApplyAutoCrop::apply(cv::Mat& pDib, int side) if (m_noise > 0) { cv::Mat element = getStructuringElement(cv::MORPH_RECT, cv::Size(m_noise, 1)); - cv::morphologyEx(thre, thre, cv::MORPH_OPEN, element); + cv::morphologyEx(thre, thre, cv::MORPH_OPEN, element, cv::Point(-1, -1), 1, cv::BORDER_CONSTANT, cv::Scalar::all(0)); } + + if (m_indent > 0) + { + cv::Mat element = getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(m_indent, m_indent)); + cv::morphologyEx(thre, thre, cv::MORPH_ERODE, element, cv::Point(-1, -1), 1, cv::BORDER_CONSTANT, cv::Scalar::all(0)); + } + std::vector hierarchy; std::vector> contours; @@ -134,7 +135,7 @@ void CImageApplyAutoCrop::apply(cv::Mat& pDib, int side) if (m_maxContour.size() == 0) { thre.release(); - //����ǹ̶����棬�뷵�ز��к�ijߴ� + // if (!m_isCrop) pDib = pDib(cv::Rect((pDib.cols - m_fixedSize.width) / 2, (pDib.rows - m_fixedSize.height) / 2, m_fixedSize.width, m_fixedSize.height) & cv::Rect(0, 0, pDib.cols, pDib.rows)).clone(); #ifdef LOG @@ -142,6 +143,7 @@ void CImageApplyAutoCrop::apply(cv::Mat& pDib, int side) #endif // LOG return; } + thre.release(); dst.release(); @@ -178,18 +180,15 @@ void CImageApplyAutoCrop::apply(cv::Mat& pDib, int side) auto mats = comMat(); warp_mat = cv::getAffineTransform(srcTri, dstTri); warp_mat = concatenateMatrix(mats[0], warp_mat); - //warp_mat = mats[0]; cv::warpAffine(bgr[0], bgr[0], warp_mat, rect.size, cv::INTER_LINEAR); warp_mat = cv::getAffineTransform(srcTri, dstTri); warp_mat = concatenateMatrix(mats[1], warp_mat); - //warp_mat = mats[1]; cv::warpAffine(bgr[1], bgr[1], warp_mat, rect.size, cv::INTER_LINEAR); warp_mat = cv::getAffineTransform(srcTri, dstTri); warp_mat = concatenateMatrix(mats[2], warp_mat); - //warp_mat = mats[2]; cv::warpAffine(bgr[2], bgr[2], warp_mat, rect.size, cv::INTER_LINEAR); cv::merge(bgr, 3, dst); @@ -208,6 +207,13 @@ void CImageApplyAutoCrop::apply(cv::Mat& pDib, int side) p.x = static_cast(a * p.x + b * p.y + c); p.y = static_cast(d * p.x + e * p.y + f); } + + for (std::vector& sub : contours) + for (cv::Point& p : sub) + { + p.x = static_cast(a * p.x + b * p.y + c); + p.y = static_cast(d * p.x + e * p.y + f); + } } else { @@ -219,45 +225,31 @@ void CImageApplyAutoCrop::apply(cv::Mat& pDib, int side) cv::split(dst, bgr); auto mats = comMat(); for (int i = 0; i < 3; i++) - { cv::warpAffine(bgr[i], bgr[i], mats[i], t_rect.size(), cv::INTER_LINEAR); - } cv::merge(bgr, 3, dst); } - } + m_maxContour.clear(); + m_maxContour.push_back(cv::Point(0, t_rect.height - 1)); + m_maxContour.push_back(cv::Point(0, 0)); + m_maxContour.push_back(cv::Point(t_rect.width - 1, 0)); + m_maxContour.push_back(cv::Point(t_rect.width - 1, t_rect.height - 1)); + + contours.clear(); + contours.push_back(m_maxContour); + } cv::Scalar autoBGColor; if (m_isFillBlank) { - cv::Mat thre_dst; - hg::threshold_Mat(dst, thre_dst, m_threshold); - - if (m_indent > 0) - { - for (size_t i = 0, length = m_maxContour.size() - 1; i < length; i++) - cv::line(thre_dst, m_maxContour[i], m_maxContour[i + 1], cv::Scalar::all(0), m_indent * 2); - cv::line(thre_dst, *m_maxContour.begin(), *m_maxContour.rbegin(), cv::Scalar::all(0), m_indent * 2); - } - - //cv::imwrite("abc.jpg", thre_dst); - hierarchy.clear(); - contours.clear(); - m_maxContour.clear(); - hg::findContours(thre_dst, contours, hierarchy, cv::RETR_EXTERNAL); if (m_isConvexHull) { - m_maxContour = hg::getMaxContour(contours, hierarchy); - if (m_maxContour.size() == 0) { thre.release(); - //����ǹ̶����棬�뷵�ز��к�ijߴ� + if (!m_isCrop) pDib = pDib(cv::Rect((pDib.cols - m_fixedSize.width) / 2, (pDib.rows - m_fixedSize.height) / 2, m_fixedSize.width, m_fixedSize.height) & cv::Rect(0, 0, pDib.cols, pDib.rows)).clone(); -#ifdef LOG - FileTools::write_log("imgprc.txt", "exit CImageApplyAutoCrop apply"); -#endif // LOG return; } hg::convexHull(m_maxContour, m_maxContour); @@ -306,8 +298,6 @@ void CImageApplyAutoCrop::apply(cv::Mat& pDib, int side) #endif // LOG } - - void CImageApplyAutoCrop::apply(std::vector& mats, bool isTwoSide) { if (mats.empty()) return; diff --git a/huagao/ImageProcess/ImageApplyAutoCrop.h b/huagao/ImageProcess/ImageApplyAutoCrop.h index eaf84f89..e1f1f4ae 100644 --- a/huagao/ImageProcess/ImageApplyAutoCrop.h +++ b/huagao/ImageProcess/ImageApplyAutoCrop.h @@ -5,13 +5,24 @@ * 作者：刘丁维 * 生成时间：2020/4/21 * 最近修改时间：2020/4/21 v1.0 - 2020/7/22 v1.1 增加获取图像有效区域轮廓的接口maxContour（用于配合一体机的“跳过空白页”算法，PC端暂时无需使用） - 2020/10/16 v1.2 修复自动裁剪尺寸精度丢失的BUG；提高除黑底缩进精度。 - 2020/10/28 v1.2.1 修复凹凸多边形填充背景的逻辑BUG。 - 2020/10/28 v1.2.2 修复图像处理必定会缩小尺寸的BUG。 - 2020/10/29 v1.2.3 避免无谓的纠偏（0°纠偏） - 2020/11/30 v1.3.0 增加功能，可识别文稿颜色进行填充黑底。 - * 版本号：v1.3.0 + 2020/7/22 v1.1 增加获取图像有效区域轮廓的接口maxContour（用于配合一体机的“跳过空白页”算法，PC端暂时无需使用） + 2020/10/16 v1.2 修复自动裁剪尺寸精度丢失的BUG；提高除黑底缩进精度。 + 2020/10/28 v1.2.1 修复凹凸多边形填充背景的逻辑BUG。 + 2020/10/28 v1.2.2 修复图像处理必定会缩小尺寸的BUG。 + 2020/10/29 v1.2.3 避免无谓的纠偏（0°纠偏） + 2020/11/30 v1.3.0 增加功能，可识别文稿颜色进行填充黑底。 + 2021/06/18 v1.3.1 调整默认noise为8。 + 2021/07/01 v1.3.2 修复 无裁切情况下，自适应颜色除黑底不生效的BUG。 + 2021/07/08 v1.3.3 完善流程。当无法定位内容时，且为固定幅面裁切，则返回按照固定幅面进行裁切的结果。 + 2021/07/08 v1.3.4 调整参数，让消除背景噪声不对纵向像素造成影响。 + 2021/07/09 v1.3.5 增加normalCrop机制，当m_isCrop m_isDesaskew m_isFillBlank均为false时可选用，实现传统裁切。 + 2021/07/13 v1.3.6 调整normalCrop逻辑，当normalCrop为true时，m_isCrop m_isDesaskew m_isFillBlank失效。 + 2021/07/19 v1.3.7 调整仿射变换模式为INTER_LINEAR。 + 2021/07/22 v1.3.8 修复第二次寻边，找不到外界轮廓会导致崩溃的BUG。 + 2021/08/02 v1.3.9 精细化除黑底算法，可以应对只有条纹内容的黑色图像。 + 2021/10/08 v1.3.10 优化算法，用腐蚀代替绘制实现缩进，提高整体算法效率。 + 2021/10/19 v1.3.11 解决一些极端情况，例如纸张自然0角度，纸张定格在图像顶部的处理。 + * 版本号：v1.3.11 * ==================================================== */ @@ -58,7 +69,7 @@ public: double threshold() { return m_threshold; } - const cv::RotatedRect& rotatedROI() { return m_rect; } + cv::RotatedRect& rotatedROI() { return m_rect; } const std::vector& rotatedROIs() { return m_rects; } diff --git a/huagao/ImageProcess/ImageApplyBWBinaray.cpp b/huagao/ImageProcess/ImageApplyBWBinaray.cpp index 7995a25a..ff499094 100644 --- a/huagao/ImageProcess/ImageApplyBWBinaray.cpp +++ b/huagao/ImageProcess/ImageApplyBWBinaray.cpp @@ -37,6 +37,7 @@ void CImageApplyBWBinaray::apply(cv::Mat& pDib, int side) //20.12.29 ޸IJΪ51 10 30 235 //20.12.30 ޸IJΪ51 20 30 235 + // 꾢ڰ 51 41 30 245 // ޸IJΪ17 20 110 235 cv::Mat integ; int blockSize = 17;//ߴ diff --git a/huagao/ImageProcess/ImageApplyDogEarDetection.cpp b/huagao/ImageProcess/ImageApplyDogEarDetection.cpp index 40ef3a75..3957467d 100644 --- a/huagao/ImageProcess/ImageApplyDogEarDetection.cpp +++ b/huagao/ImageProcess/ImageApplyDogEarDetection.cpp @@ -2,19 +2,19 @@ #include "ImageProcess_Public.h" CImageApplyDogEarDetection::CImageApplyDogEarDetection() - : m_threshold(40) - , m_zoom(1.0) - , m_distance(50) - , m_result(false) + : m_threshold(40) + , m_zoom(1.0) + , m_distance(50) + , m_result(false) { } CImageApplyDogEarDetection::CImageApplyDogEarDetection(double threshlod, double zoom, double distance) - : m_threshold(threshlod) - , m_zoom(zoom) - , m_distance(distance) - , m_result(false) + : m_threshold(threshlod) + , m_zoom(zoom) + , m_distance(distance) + , m_result(false) { } @@ -24,44 +24,49 @@ CImageApplyDogEarDetection::~CImageApplyDogEarDetection() } -void CImageApplyDogEarDetection::apply(cv::Mat &pDib, int side) +void CImageApplyDogEarDetection::apply(cv::Mat& pDib, int side) { - m_result = false; - (void)side; - if (pDib.empty()) return; - cv::Mat src; - if (m_zoom != 1.0) - cv::resize(pDib, src, cv::Size(), m_zoom, m_zoom, cv::INTER_NEAREST); - else - src = pDib; + m_result = false; + (void)side; + if (pDib.empty()) return; + cv::Mat src; + if (m_zoom != 1.0) + cv::resize(pDib, src, cv::Size(), m_zoom, m_zoom, cv::INTER_NEAREST); + else + src = pDib; - cv::Mat thre; - hg::threshold_Mat(src, thre, m_threshold); - std::vector hierarchy; - std::vector> contours; - hg::findContours(thre, contours, hierarchy, cv::RETR_EXTERNAL); + cv::Mat thre; + hg::threshold_Mat(src, thre, m_threshold); - std::vector maxContour = hg::getMaxContour(contours, hierarchy); - if (maxContour.size() == 0) - { - m_result = true; - return; - } - hg::convexHull(maxContour, maxContour); - cv::RotatedRect rect = hg::getBoundingRect(maxContour); - cv::Point2f vertexes[4]; - rect.points(vertexes); + cv::Mat element = getStructuringElement(cv::MORPH_RECT, cv::Size(20, 1)); + cv::morphologyEx(thre, thre, cv::MORPH_OPEN, element, cv::Point(-1, -1), 1, cv::BORDER_CONSTANT, cv::Scalar::all(0)); - for (int i = 0; i < 4; i++) - if ((-cv::pointPolygonTest(maxContour, vertexes[i], true)) > (m_distance * m_zoom)) - { - m_result = true; - return; - } + std::vector hierarchy; + std::vector> contours; + hg::findContours(thre, contours, hierarchy, cv::RETR_EXTERNAL); + + std::vector maxContour = hg::getMaxContour(contours, hierarchy); + if (maxContour.size() == 0) + { + m_result = true; + return; + } + hg::convexHull(maxContour, maxContour); + cv::RotatedRect rect = hg::getBoundingRect(maxContour); + cv::Point2f vertexes[4]; + rect.points(vertexes); + + for (int i = 0; i < 4; i++) + if ((-cv::pointPolygonTest(maxContour, vertexes[i], true)) > (m_distance * m_zoom)) + { + m_result = true; + return; + } } -void CImageApplyDogEarDetection::apply(std::vector &mats, bool isTwoSide) +void CImageApplyDogEarDetection::apply(std::vector& mats, bool isTwoSide) { - (void)mats; - (void)isTwoSide; + (void)mats; + (void)isTwoSide; } + diff --git a/huagao/ImageProcess/ImageApplyDogEarDetection.h b/huagao/ImageProcess/ImageApplyDogEarDetection.h index a05f313c..a1516937 100644 --- a/huagao/ImageProcess/ImageApplyDogEarDetection.h +++ b/huagao/ImageProcess/ImageApplyDogEarDetection.h @@ -4,8 +4,9 @@ * 功能：折角检测。检测原理：计算纸张的理论四角顶点，到实际轮廓最小距离。当任意顶点到轮廓最小距离超过阈值，则判定为折角 * 作者：刘丁维 * 生成时间：2020/10/30 - * 最近修改时间：2020/10/30 - * 版本号：v1.0 + * 最近修改时间：2020/10/30 v1.0 + * 2021/11/04 v1.1 增加背景抗噪机制，能够抗5像素的背景噪声 + * 版本号：v1.1 * ==================================================== */ @@ -15,7 +16,7 @@ #include "ImageApply.h" -class CImageApplyDogEarDetection :public CImageApply +class CImageApplyDogEarDetection : public CImageApply { public: @@ -31,7 +32,7 @@ public: /// 原图缩放比例，对于大尺寸图像而言通过zoom缩小图像可减少计算量。默认值1.0（不缩放） /// 理论顶点到实际轮廓最小距离的阈值，大于该阈值则判定为折角，默认值50（像素） CImageApplyDogEarDetection(double threshlod, double zoom = 1.0, double distance = 50); - + void setdistance(double distance) { m_distance = distance; } virtual ~CImageApplyDogEarDetection(void); /// @@ -54,3 +55,4 @@ private: }; #endif // IMAGE_APPLY_DOGEAR_DETECTION_H + diff --git a/huagao/ImageProcess/ImageApplyOutHole.cpp b/huagao/ImageProcess/ImageApplyOutHole.cpp index 800e436d..e3e2a748 100644 --- a/huagao/ImageProcess/ImageApplyOutHole.cpp +++ b/huagao/ImageProcess/ImageApplyOutHole.cpp @@ -1,15 +1,19 @@ #include "ImageApplyOutHole.h" #include "ImageProcess_Public.h" -CImageOutHole::CImageOutHole(void) +#ifdef LOG +#include "Device/filetools.h" +#endif // LOG + +CImageApplyOutHole::CImageApplyOutHole(void) : CImageApply() - , m_borderSize(200) + , m_borderSize(600) , m_edgeScale(0.1f) - , m_threshold(50) + , m_threshold(100) { } -CImageOutHole::CImageOutHole(float borderSize, float edgeScale, double threshold) +CImageApplyOutHole::CImageApplyOutHole(float borderSize, float edgeScale, double threshold) : CImageApply() , m_borderSize(borderSize) , m_edgeScale(edgeScale) @@ -17,26 +21,35 @@ CImageOutHole::CImageOutHole(float borderSize, float edgeScale, double threshold { } -CImageOutHole::~CImageOutHole(void) +CImageApplyOutHole::~CImageApplyOutHole(void) { } -void CImageOutHole::apply(cv::Mat& pDib, int side) +void CImageApplyOutHole::apply(cv::Mat& pDib, int side) { - (void)pDib; - (void)side; + (void)pDib; + (void)side; } -void CImageOutHole::apply(std::vector& mats, bool isTwoSide) +void CImageApplyOutHole::apply(std::vector& mats, bool isTwoSide) { +#ifdef LOG + FileTools::write_log("imgprc.txt", "enter ImageOutHole apply"); +#endif // LOG if (mats.size() < 2) { +#ifdef LOG + FileTools::write_log("imgprc.txt", "exit ImageOutHole apply"); +#endif // LOG return; } if (mats[0].empty() || mats[1].empty()) { +#ifdef LOG + FileTools::write_log("imgprc.txt", "exit ImageOutHole apply"); +#endif // LOG return; } @@ -47,6 +60,10 @@ void CImageOutHole::apply(std::vector& mats, bool isTwoSide) hg::threshold_Mat(front, front_thre, m_threshold); hg::threshold_Mat(back, back_thre, m_threshold); + cv::Mat element = getStructuringElement(cv::MORPH_RECT, cv::Size(10, 1)); + cv::morphologyEx(front_thre, front_thre, cv::MORPH_OPEN, element, cv::Point(-1, -1), 1, cv::BORDER_CONSTANT, cv::Scalar::all(0)); + cv::morphologyEx(back_thre, back_thre, cv::MORPH_OPEN, element, cv::Point(-1, -1), 1, cv::BORDER_CONSTANT, cv::Scalar::all(0)); + //ֵͼˮƽת cv::flip(back_thre, back_thre, 1); //1:Horizontal @@ -63,6 +80,11 @@ void CImageOutHole::apply(std::vector& mats, bool isTwoSide) cv::RotatedRect rrect_front = hg::getBoundingRect(maxContour_front); //ȡСӾ cv::RotatedRect rrect_back = hg::getBoundingRect(maxContour_back); //ȡСӾ + //ͼߴ쳬20أֱӷ + if (cv::abs(rrect_front.size.width - rrect_back.size.width) > 20 || + cv::abs(rrect_front.size.height - rrect_back.size.height) > 20) + return; + //ȡͼص cv::Rect roi_front, roi_back; cv::RotatedRect mask_rotatedRect; @@ -73,56 +95,61 @@ void CImageOutHole::apply(std::vector& mats, bool isTwoSide) //ֵͼ㣬ο0طΪ255 cv::Mat mask; - bitwise_or(roiMat_front, roiMat_back, mask); //㣬ֵͼص + cv::bitwise_or(roiMat_front, roiMat_back, mask); //㣬ֵͼص + + cv::imwrite("roiMat_front.jpg", roiMat_front); + cv::imwrite("roiMat_back.jpg", roiMat_back); //ֵͼصͼɫȡͣȡ - std::vector> contours_mask; - std::vector b1_mask; - bitwise_not(mask, mask); //ɫ + cv::bitwise_not(mask, mask); //ɫ - cv::Mat element = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(15, 15)); - dilate(mask, mask, element, cv::Point(-1, -1), 1, cv::BORDER_CONSTANT, cv::Scalar(255)); //㷨׶ͨ + element = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(10, 10)); + cv::dilate(mask, mask, element, cv::Point(-1, -1), 1, cv::BORDER_CONSTANT, cv::Scalar(255)); //㷨׶ͨ //Ϊ˱׶׹ᴩֽߣΪֽȷп׶ΪͼΣ뱳ճ - polylines(mask, hg::getVertices(mask_rotatedRect), true, cv::Scalar(0), 15); //ֽžαԵ + cv::polylines(mask, hg::getVertices(mask_rotatedRect), true, cv::Scalar(0), 15); //ֽžαԵ - hg::findContours(mask.clone(), contours_mask, b1_mask, cv::RETR_TREE); //ȡصͼ + std::vector> contours_mask; + std::vector b1_mask; + hg::findContours(mask, contours_mask, b1_mask, cv::RETR_TREE); //ȡصͼ //˷ǿ׶ͨ std::vector> hole_contours = filterPoly(contours_mask, b1_mask, mask_rotatedRect, m_edgeScale, m_borderSize); - for (size_t i = 0; i < hole_contours.size(); i++) - cv::drawContours(mask, hole_contours, static_cast(i), cv::Scalar(127), 2); - + //for (size_t i = 0; i < hole_contours.size(); i++) + // cv::drawContours(mask, hole_contours, static_cast(i), cv::Scalar(127), 2); + //cv::imwrite("mask.jpg", mask); + cv::Scalar color = getBackGroudColor(front(roi_front), rrect_front.size.area()); for (size_t i = 0; i < hole_contours.size(); i++) { - cv::Scalar color = getBackGroudColor(front(roi_front), hole_contours[i]); - cv::Mat temp = front(roi_front); std::vector> contourss_temp; contourss_temp.push_back(hole_contours[i]); - hg::fillPolys(temp, contourss_temp, color); + cv::Mat front_temp = front(roi_front); + hg::fillPolys(front_temp, contourss_temp, color); } if (isTwoSide) { int width_ = roi_back.width; roi_back.x = back.cols - roi_back.width - roi_back.x; //Ϊ֮ǰͼתROIҲҪӦת + color = getBackGroudColor(back(roi_back), rrect_front.size.area()); for (size_t i = 0; i < hole_contours.size(); i++) { std::vector hole_contour; for (size_t j = 0; j < hole_contours[i].size(); j++) hole_contour.push_back(cv::Point(width_ - hole_contours[i][j].x - 1, hole_contours[i][j].y)); - cv::Scalar color = getBackGroudColor(back(roi_back), hole_contour); - cv::Mat temp = back(roi_back); - std::vector> contours_temp; contours_temp.push_back(hole_contour); - hg::fillPolys(temp, contours_temp, color); + cv::Mat back_temp = back(roi_back); + hg::fillPolys(back_temp, contours_temp, color); } } +#ifdef LOG + FileTools::write_log("imgprc.txt", "exit ImageOutHole apply"); +#endif // LOG } -void CImageOutHole::getRoi(cv::RotatedRect rrect_front, cv::RotatedRect rrect_back, cv::Size srcSize, +void CImageApplyOutHole::getRoi(cv::RotatedRect rrect_front, cv::RotatedRect rrect_back, cv::Size srcSize, cv::Rect& roi_front, cv::Rect& roi_back, cv::RotatedRect& mask_rotatedRect) { cv::Size size(static_cast(rrect_front.size.width + rrect_back.size.width) / 2, static_cast(rrect_front.size.height + rrect_back.size.height) / 2); @@ -180,7 +207,7 @@ void CImageOutHole::getRoi(cv::RotatedRect rrect_front, cv::RotatedRect rrect_ba mask_rotatedRect.angle = angle; } -std::vector> CImageOutHole::filterPoly(std::vector>& contours, const std::vector& m, +std::vector> CImageApplyOutHole::filterPoly(std::vector>& contours, const std::vector& m, cv::RotatedRect roi, float edgeScale, float areaThreshold) { edgeScale = std::min(0.49f, std::max(edgeScale, 0.0f)); @@ -196,7 +223,7 @@ std::vector> CImageOutHole::filterPoly(std::vector areaThreshold || rrect.size.height > areaThreshold) continue; + if (rrect.size.area() < areaThreshold) continue; bool enabled = true; for (size_t j = 0, count = contours[i].size(); j < count; j++) @@ -218,7 +245,7 @@ std::vector> CImageOutHole::filterPoly(std::vector pixelPoints) +cv::Scalar CImageApplyOutHole::getBackGroudColor(const cv::Mat& image, const std::vector pixelPoints) { if (pixelPoints.empty()) return cv::Scalar(255, 255, 255); @@ -235,7 +262,62 @@ cv::Scalar CImageOutHole::getBackGroudColor(const cv::Mat &image, const std::vec temp[j] += ptr[j]; } - return cv::Scalar(temp[0] / static_cast(pixelPoints.size()), - temp[1] / static_cast(pixelPoints.size()), - temp[2] / static_cast(pixelPoints.size())); + return cv::Scalar(temp[0] / static_cast(pixelPoints.size()), + temp[1] / static_cast(pixelPoints.size()), + temp[2] / static_cast(pixelPoints.size())); } + +cv::Scalar CImageApplyOutHole::getBackGroudColor(const cv::Mat& image, int total) +{ + if (image.channels() == 3) + { + cv::Mat image_bgr[3]; + cv::split(image, image_bgr); + + uchar bgr[3]; + for (size_t i = 0; i < 3; i++) + bgr[i] = getBackGroudChannelMean(image_bgr[i], total); + return cv::Scalar(bgr[0], bgr[1], bgr[2]); + } + else + return cv::Scalar::all(getBackGroudChannelMean(image, total)); +} + +uchar CImageApplyOutHole::getBackGroudChannelMean(const cv::Mat& gray, int total) +{ + cv::Mat image_clone; + cv::resize(gray, image_clone, cv::Size(), 0.25, 0.25); + + int threnshold = total / 32; + int channels[] = { 0 }; + int nHistSize[] = { 256 }; + float range[] = { 0, 256 }; + const float* fHistRanges[] = { range }; + cv::Mat hist; + cv::calcHist(&image_clone, 1, channels, cv::Mat(), hist, 1, nHistSize, fHistRanges, true, false); + + int hist_array[256]; + for (int i = 0; i < 256; i++) + hist_array[i] = hist.at(i, 0); + + int length = 1; + const int length_max = 255 - m_threshold; + while (length < length_max) + { + for (size_t i = m_threshold + 1; i < 256 - length; i++) + { + int count = 0; + uint pixSum = 0; + for (size_t j = 0; j < length; j++) + { + count += hist_array[j + i]; + pixSum += hist_array[j + i] * (i + j); + } + + if (count >= threnshold) + return pixSum / count; + } + length++; + } + return 255; +} \ No newline at end of file diff --git a/huagao/ImageProcess/ImageApplyOutHole.h b/huagao/ImageProcess/ImageApplyOutHole.h index 9ed49b3f..0b412861 100644 --- a/huagao/ImageProcess/ImageApplyOutHole.h +++ b/huagao/ImageProcess/ImageApplyOutHole.h @@ -1,18 +1,39 @@ +/* + * ==================================================== + + * ܣװ + * ߣά + * ʱ䣺2020/11/21 + * ޸ʱ䣺2020/05/12 v1.0 + * 2020/11/17 v1.1 + * 2021/09/06 v1.2 Ĭ϶ֵֵԭ50Ϊ100ɫӾֲɫȡΪȫɫȡ + * 2021/11/03 v1.3 ߼ͼߴ쳬10أֱӷأٽг״ + * 2021/11/04 v1.4 ӱƣܹ5صı + * 2021/11/17 v1.5 ʽһЩopencv汾µBUG + * 汾ţv1.5 + + * ==================================================== + */ + #ifndef IMAGE_APPLY_OUT_HOLE_H #define IMAGE_APPLY_OUT_HOLE_H #include "ImageApply.h" -class CImageOutHole : public CImageApply +class CImageApplyOutHole : public CImageApply { - public: - CImageOutHole(); + CImageApplyOutHole(); - CImageOutHole(float borderSize, float edgeScale, double threshold); + /* + * borderSize [in]:׶ֵ + * edgeScale [in]:ֽűԵȡֵΧ(0,0.5),Ĭֵ0.1 + * threshold [in]:ֵֵ + */ + CImageApplyOutHole(float borderSize, float edgeScale, double threshold); - ~CImageOutHole(void); + ~CImageApplyOutHole(void); virtual void apply(std::vector& mats, bool isTwoSide); @@ -26,7 +47,7 @@ public: void setEdgeScale(float scale) { m_edgeScale = scale; } - void setThreshold(double threshold) { m_threshold = (std::min)((std::max)(threshold, 1.0), 254.0); } + void setThreshold(double threshold) { m_threshold = (std::min)((std::max)(threshold, 1.0), 254.0); } private: @@ -35,15 +56,20 @@ private: void getRoi(cv::RotatedRect rrect_front, cv::RotatedRect rrect_back, cv::Size srcSize, cv::Rect& roi_front, cv::Rect& roi_back, cv::RotatedRect& mask_rotatedRect); - std::vector > filterPoly(std::vector>& contours, const std::vector &m, cv::RotatedRect roi, + std::vector > filterPoly(std::vector>& contours, const std::vector& m, cv::RotatedRect roi, float edgeScale, float areaThreshold); cv::Scalar getBackGroudColor(const cv::Mat& image, const std::vector pixelPoints); + cv::Scalar getBackGroudColor(const cv::Mat& image, int total); + + uchar getBackGroudChannelMean(const cv::Mat& gray, int total); + private: float m_borderSize; float m_edgeScale; double m_threshold; }; -#endif // !IMAGE_APPLY_OUT_HOLE_H \ No newline at end of file +#endif // !IMAGE_APPLY_OUT_HOLE_H + diff --git a/huagao/ImageProcess/ImageApplyUV.cpp b/huagao/ImageProcess/ImageApplyUV.cpp index 56808fe6..cd8214b6 100644 --- a/huagao/ImageProcess/ImageApplyUV.cpp +++ b/huagao/ImageProcess/ImageApplyUV.cpp @@ -97,7 +97,6 @@ cv::Mat ImageApplyUV::Apply(const cv::Mat& image, const cv::Mat& uv, const cv::R cv::Mat uv_temp; cv::warpAffine(uv, uv_temp, warp_mat, cv::Size(uvRoi_clone.size.width, uvRoi_clone.size.height)); - //cv::imwrite("uv_temp.jpg", uv_temp); if (pixtype == 0)//ֵͼ { cvtColor(uv_temp, uv_temp, cv::COLOR_BGR2GRAY); @@ -201,7 +200,6 @@ cv::Mat ImageApplyUV::Apply(const cv::Mat& image, const cv::Mat& uv, const cv::R } uv_roi.copyTo(dst_uv(cv::Rect((dst_uv.cols - uv_roi.cols + offset_left) / 2, (dst_uv.rows - uv_roi.rows + offset_top) / 2, uv_roi.cols, uv_roi.rows))); } - //imwrite("D:\\dst" + std::to_string(svindex) + ".jpg", dst); return dst; } diff --git a/huagao/auge_logo.bmp b/huagao/auge_logo.bmp new file mode 100644 index 00000000..bc4172fa Binary files /dev/null and b/huagao/auge_logo.bmp differ diff --git a/huagao/auge_logo1111.bmp b/huagao/auge_logo1111.bmp new file mode 100644 index 00000000..e797f836 Binary files /dev/null and b/huagao/auge_logo1111.bmp differ diff --git a/huagao/hanvon.bmp b/huagao/hanvon.bmp new file mode 100644 index 00000000..ae1a4c43 Binary files /dev/null and b/huagao/hanvon.bmp differ diff --git a/huagao/hanvon_log.bmp b/huagao/hanvon_log.bmp new file mode 100644 index 00000000..a7ce12c6 Binary files /dev/null and b/huagao/hanvon_log.bmp differ diff --git a/huagao/huagaods.cpp b/huagao/huagaods.cpp index f16ac2cc..9e8569b8 100644 --- a/huagao/huagaods.cpp +++ b/huagao/huagaods.cpp @@ -16,6 +16,7 @@ #include "Device/PublicFunc.h" #include "Device/GScanO200.h" #include "Device/GScanO400.h" +#include "Device/GScanO400Android.h" #include "Device/GScanO1003399.h" #include "Device/filetools.h" #include "Device/GScanVirtual.h" @@ -59,6 +60,7 @@ enum class CapTypeEx : unsigned short { TwEx_LowPowerMode = 0x8104, TwEx_ENCODE = 0x8105, TwEx_CropModel=0x8106, + TwEx_DogEarDistance = 0x8107, }; enum class PaperSizeEx : unsigned short { @@ -92,6 +94,8 @@ static constexpr const Identity srcIdent( "HUAGO", #elif defined HANVON "HANVON", +#elif defined AUGE + "AUGE", #elif defined LANXUM "LANXUM", #else // MAKEHUAGAO @@ -120,7 +124,7 @@ static constexpr const Identity srcIdent( #elif defined HANVON "HW-7000W Series", #else // ISG100 - "G300 Series", + "G200 Series",//ݾɼ pm changed G300 Series #endif #elif defined(G400) // G200 @@ -138,6 +142,8 @@ static constexpr const Identity srcIdent( #ifdef ISG100 #ifdef MAKEHUAGAO "HUAGOSCAN G100 TWAIN" + #elif defined AUGE + "AUGESCAN G100 TWAIN" #elif defined LANXUM //!LANXUM "LANXUMSCAN G62S TWAIN" #else // !MAKEHUAGAO @@ -159,7 +165,7 @@ static constexpr const Identity srcIdent( #ifdef UV "HUAGOSCAN G300UV TWAIN" #else - "HUAGOSCAN G300 TWAIN" + "HUAGOSCAN G200 TWAIN"// ݾɼ pm changed "HUAGOSCAN G300 TWAIN" #endif #elif defined HANVON @@ -264,11 +270,14 @@ struct Vid_pid #ifdef LANXUM static std::vector DeviceID{ + {0x3072,0x239}, {0x31c9,0x8200}, #ifdef G200 #ifdef ISG100 + {0x31c9,0x8629}, {0x31c9,0x8620}, #else + {0x31c9,0x8739}, {0x31c9,0x8730}, #endif // ISG100 #elif defined G300 @@ -278,11 +287,17 @@ static std::vector DeviceID{ #endif // ISG100 }; + +#elif defined AUGE +static std::vector DeviceID{ + {0x3072,0x0130}, +}; + #elif defined HANVON static std::vector DeviceID{ - {0x2903,0x7000}, }; + #else static std::vector DeviceID{ {0x64B,0x7823}, @@ -295,7 +310,7 @@ static std::vector DeviceID{ {0x3072,0x200}, #endif // ISG100 #elif defined G300 - {0x3072,0x300}, + {0x3072,0x0300} #elif defined G400 {0x3072,0x400}, #endif // ISG100 @@ -365,51 +380,39 @@ HuagaoDs::HuagaoDs() // //guiIndicator.reset(); // if (!m_memoryfalg) // return; - // MessageBox(NULL, L"ڴ治", L"", MB_OK| MB_SYSTEMMODAL); + // MessageBox(NULL, L"ڴ治", L"ʾ", MB_OK| MB_SYSTEMMODAL); //})); } void HuagaoDs::showmsg(std::string caption, std::string text, int retcode) { if (scanner.get()) { - int num = scanner->get_scannum() * (m_scanparam->is_duplex ? 2 : 1) * (m_scanparam->multi_output_red ? 2 : 1) / (m_scanparam->en_fold ? 2 : 1); -//#ifdef G1003399 - int readnum =scanner->get_scannum()* (m_scanparam->is_duplex ? 2 : 1) / (m_scanparam->en_fold ? 2 : 1); -//#else -// int readnum = scanner->get_scannum(); -//#endif // G1003399 - - + //int num = scanner->get_scannum() * (m_scanparam->is_duplex ? 2 : 1) * (m_scanparam->multi_output_red ? 2 : 1) / (m_scanparam->en_fold ? 2 : 1); + //int readnum =scanner->get_scannum()* (m_scanparam->is_duplex ? 2 : 1) / (m_scanparam->en_fold ? 2 : 1); + int num = scanner->get_imgnReaded() * (m_scanparam->is_duplex ? 2 : 1) * (m_scanparam->multi_output_red ? 2 : 1) / (m_scanparam->en_fold ? 2 : 1); + int imgread = scanner->get_imgnReaded(); + IScanner* ptr = scanner.get(); + if (typeid(*ptr) == typeid(GScanO1003399)) + { + //readnum = readnum / 2 * (m_scanparam->en_fold ? 2 : 1); + num = scanner->get_imgnReaded() * (m_scanparam->multi_output_red ? 2 : 1) / (m_scanparam->en_fold ? 2 : 1); + imgread /= 2; + } if (!(m_scanparam->is_autodiscradblank_normal || m_scanparam->is_autodiscradblank_vince)) { - if ((retcode == 64 || retcode == 8 || retcode == 16)) { - num = (scanner->get_scannum()-1) * (m_scanparam->is_duplex ? 2 : 1) * (m_scanparam->multi_output_red ? 2 : 1) / (m_scanparam->en_fold ? 2 : 1); -//#ifdef G1003399 - int readnum = (scanner->get_scannum() -1)* (m_scanparam->is_duplex ? 2 : 1) / (m_scanparam->en_fold ? 2 : 1); -//#else -// int readnum = scanner->get_scannum()-1; -//#endif // G1003399 - if (((num - scanner->get_imgTransfered()) > 0)||((readnum-scanner->get_imgnReaded())>0)) { - text += "ֽ" + to_string(scanner->get_scannum()-1) + - "ɨ" + to_string(scanner->get_imgnReaded()) + "ϴ" + to_string(scanner->get_imgTransfered()) + - "ɨ" + to_string(readnum - scanner->get_imgnReaded()) + "ļϴ" + to_string(num - scanner->get_imgTransfered()) + "ļ"; - scanner->set_lose_image_num(0); - } - } - else{ - if (((num - scanner->get_imgTransfered()) != 0) || ((readnum - scanner->get_imgnReaded()) != 0)) { - text += "ֽ" + to_string(scanner->get_scannum()) + - "ɨ" + to_string(scanner->get_imgnReaded()) + "ϴ" + to_string(scanner->get_imgTransfered()) + - "ɨ" + to_string(readnum - scanner->get_imgnReaded()) + "ļϴ" + to_string(num - scanner->get_imgTransfered()) + "ļ"; - scanner->set_lose_image_num(0); - } - } - + text += "\nɨͳϢ\nֽţ" + to_string(scanner->get_scannum()) + + "\nɨ裨ţ" + to_string(imgread) + "\nɨţ" + to_string(scanner->get_scannum() - imgread) + + "\nϴҳ" + to_string(scanner->get_imgTransfered()) + "\nϴҳ" + to_string(num - scanner->get_imgTransfered()); + scanner->set_lose_image_num(0); } } ShellExecute(NULL, TEXT("open"), GetHidedlgPath(), CString((text + " " + caption).c_str()), NULL, SW_HIDE); } +void HuagaoDs::hgmsg(CString str) +{ + ShellExecute(NULL, TEXT("open"), GetHidedlgPath(), str, NULL, SW_HIDE); +} HuagaoDs::~HuagaoDs() { if (memoryinfo.get()) { @@ -803,26 +806,24 @@ void HuagaoDs::dogear_callback(int indexpaper) CString text; text.Format(_T("74 %d"), indexpaper); //ShellExecute(NULL, TEXT("open"), GetHidedlgPath(), text, NULL, SW_HIDE); - showmsg("",""+to_string(indexpaper)+"⵽۽ǣ"); + showmsg("ʾ",""+to_string(indexpaper)+"⵽۽ǣ"); scanner->Stop_scan(); //scanner->reset(); scanner->ResetScanner(); onDeviceEvent(DOG_EAR); } - Result HuagaoDs::identityOpenDs(const Identity&) { + hMutex = CreateMutex(NULL, FALSE, _T("LookitApp")); if (GetLastError() == ERROR_ALREADY_EXISTS) { //ѾͬMutexõ. CloseHandle(hMutex); hMutex = NULL; //ShellExecute(NULL, TEXT("open"), GetHidedlgPath(), CString("202"), NULL, SW_HIDE); - showmsg("", msgs[(UsbSupported)202]); + showmsg("ʾ", msgs[(UsbSupported)202]); return { ReturnCode::Failure, ConditionCode::CapBadOperation }; } - - - + Twain_config().GetOrSetPintfCapability(is_printfcapability, true); auto usblist = UsbScan_List::find_all_usb(); if (!usblist.empty()) { @@ -836,12 +837,16 @@ Result HuagaoDs::identityOpenDs(const Identity&) { pid = usb.pid; if (!scanner.get()) { #ifdef G200 - if (pid == 0x139 || pid == 0x239) + if (pid == 0x139 || pid == 0x239 || pid == 0x8739 || pid == 0x8629) scanner.reset(new GScanO1003399()); else scanner.reset(new GScanO200()); +#else +#ifdef ANDROIDSERIAL + scanner.reset(new GScanO400Android()); #else scanner.reset(new GScanO400()); +#endif #endif // G400 break; } @@ -854,8 +859,8 @@ Result HuagaoDs::identityOpenDs(const Identity&) { if (vid == 0 || pid == 0) { //ShellExecute(NULL, TEXT("open"), GetHidedlgPath(), CString("201"), NULL, SW_HIDE); - //showmsg("", msgs[(UsbSupported)201]); - ShellExecute(NULL, TEXT("open"), GetHidedlgPath(), CString("δҵɨ!ԴUSBǷͨ! "), NULL, SW_HIDE); + //showmsg("ʾ", msgs[(UsbSupported)201]); + ShellExecute(NULL, TEXT("open"), GetHidedlgPath(), CString("δҵɨ!ԴUSBǷͨ! ʾ"), NULL, SW_HIDE); if (hMutex) { CloseHandle(hMutex); hMutex = NULL; @@ -869,12 +874,12 @@ Result HuagaoDs::identityOpenDs(const Identity&) { CloseHandle(hMutex); hMutex = NULL; } - showmsg("", msgs[(UsbSupported)81]); + showmsg("ʾ", msgs[(UsbSupported)81]); return seqError(); } if (!scanner->IsConnected()) { //ShellExecute(NULL, TEXT("open"), GetHidedlgPath(), CString("201"), NULL, SW_HIDE); - showmsg("", msgs[(UsbSupported)201]); + showmsg("ʾ", msgs[(UsbSupported)201]); if (hMutex) { CloseHandle(hMutex); hMutex = NULL; @@ -887,7 +892,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { auto dgcall = [&](int pagenum) { //ShellExecute(NULL, TEXT("open"), GetHidedlgPath(), text, NULL, SW_HIDE); - showmsg("", "" + to_string(pagenum) + "⵽۽ǣ"); + showmsg("ʾ", "" + to_string(pagenum) + "⵽۽ǣ"); scanner->Stop_scan(); //scanner->reset(); scanner->ResetScanner(); @@ -931,6 +936,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::DeviceOnline] = msgSupportGetAll; //m_caps[CapType::DeviceOnline] = std::bind(enmGet, _1, _2, Bool(scanner->IsConnected())); m_caps[CapType::DeviceOnline] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapType::DeviceOnline)); switch (msg) { case Msg::Get: case Msg::GetCurrent: @@ -945,6 +951,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::XferCount] = msgSupportGetAllSetReset; m_caps[CapType::XferCount] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapType::XferCount),msg==Msg::Set?to_string((int)data.currentItem()):""); if (msg == Msg::Set) { auto item = data.currentItem(); if (item > 65535 || item < -1 || item == 0) { @@ -964,8 +971,8 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::ICompression] = msgSupportGetAllSetReset; //m_caps[CapType::ICompression] = std::bind(enmGetSetConst, _1, _2, Compression::None); - m_caps[CapType::ICompression] = [this](Msg msg, Capability& data)->Result - { + m_caps[CapType::ICompression] = [this](Msg msg, Capability& data)->Result{ + CapabilityPrintf(msg, enum2str(CapType::ICompression), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (Compression::None == mech || mech == Compression::Group4) { @@ -980,6 +987,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IBitDepth] = msgSupportGetAllSetReset; m_caps[CapType::IBitDepth] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapType::IBitDepth), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (((mech == 1) && (m_scanparam->pixtype == 0)) || ((mech == 8) && (m_scanparam->pixtype == 1)) || ((mech == 24) && (m_scanparam->pixtype == 2))) { @@ -1008,15 +1016,16 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IPixelType] = msgSupportGetAllSetReset; m_caps[CapType::IPixelType] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapType::IPixelType), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if( Msg::Set==msg) { auto mech = data.currentItem(); if (mech == PixelType::Rgb || mech == PixelType::Gray || mech == PixelType::BlackWhite) { + m_scanparam->automaticcolor = FALSE; m_scanparam->pixtype = (int)mech; if (m_scanparam->pixtype == (int)PixelType::Rgb){ m_scanparam->filter = (BYTE)Filter::None; - m_scanparam->enhance_color = (BYTE)Enchace_Color::Enhance_None; - m_scanparam->automaticcolor = FALSE; + m_scanparam->enhance_color = (BYTE)Enchace_Color::Enhance_None; } else{ m_scanparam->multi_output_red = 0;//Dzɫģʽ¶ @@ -1043,6 +1052,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IAutomaticColorEnabled] = msgSupportGetAllSetReset; m_caps[CapType::IAutomaticColorEnabled] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IAutomaticColorEnabled), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (mech) { @@ -1061,6 +1071,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IAutomaticColorNonColorPixelType] = msgSupportGetAllSetReset; m_caps[CapType::IAutomaticColorNonColorPixelType] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IAutomaticColorNonColorPixelType), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (msg == Msg::Set) { auto mech = data.currentItem(); if (m_scanparam->automaticcolor == TRUE) { @@ -1076,9 +1087,10 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //add------------------jpegȼ--------------------- m_query[CapType::IJpegQuality] = msgSupportGetAllSetReset; m_caps[CapType::IJpegQuality] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IJpegQuality), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); - if ((int)mech < 0 || (int)mech > 100) + if ((int)mech <= 0 || (int)mech > 100) return badValue(); m_jpegQuality = (int)mech; return success(); @@ -1091,6 +1103,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IXferMech] = msgSupportGetAllSetReset; m_caps[CapType::IXferMech] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapType::IXferMech), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (mech == XferMech::Native || mech == XferMech::Memory || mech == XferMech::File) { @@ -1106,6 +1119,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IXResolution] = msgSupportGetAllSetReset; m_caps[CapType::IXResolution] = [this](Msg msg, Capability& data) { + CapabilityPrintf(msg, enum2str(CapType::IXResolution), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); switch (msg) { case Msg::Get: data = Capability::createRange(Fix32(100.0f), Fix32(600.0f), Fix32(1.0f), Fix32(m_scanparam->resolution_dst), Fix32(200.0)); @@ -1141,9 +1155,10 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::ISupportedSizes] = msgSupportGetAllSetReset; m_caps[CapType::ISupportedSizes] = [this](Msg msg, Capability& data) { + CapabilityPrintf(msg, enum2str(CapType::ISupportedSizes), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { - if (m_scanparam->is_autocrop) - return success(); + //if (m_scanparam->is_autocrop) + // return success(); auto paper = data.currentItem(); if (std::distance(paperSizeList.begin(), std::find(paperSizeList.begin(), paperSizeList.end(), paper)) == paperSizeList.size()) return badValue(); @@ -1188,7 +1203,11 @@ Result HuagaoDs::identityOpenDs(const Identity&) { #ifndef ISG100 m_query[(CapType)(CapTypeEx::TwEx_SizeDetect)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_SizeDetect)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_SizeDetect), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { + if (m_scanparam->papertype == (uint8_t)PaperSize::None || m_scanparam->papertype == (uint8_t)PaperSize::MaxSize || m_scanparam->papertype == (uint8_t)PaperSize::UsStatement || + m_scanparam->papertype == (uint8_t)PaperSizeEx::Trigeminy) + return badValue(); auto mech = data.currentItem(); m_scanparam->en_sizecheck = mech; return success(); @@ -1200,8 +1219,13 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IOrientation] = msgSupportGetAllSetReset; m_caps[CapType::IOrientation] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::IOrientation), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); + if ((mech == Orientation::Landscape) && (m_scanparam->papertype == (uint8_t)PaperSize::None || m_scanparam->papertype == (uint8_t)PaperSize::MaxSize || + m_scanparam->papertype == (uint8_t)PaperSize::UsStatement || m_scanparam->papertype == (uint8_t)PaperSizeEx::Trigeminy || m_scanparam->papertype == (uint8_t)PaperSize::A3 || + m_scanparam->papertype == (uint8_t)PaperSize::IsoB4 || m_scanparam->papertype == (uint8_t)PaperSizeEx::K8 || m_scanparam->papertype == (uint8_t)PaperSize::UsLedger)) + return badValue(); if (mech == Orientation::Landscape || mech == Orientation::Portrait) { m_scanparam->paperAlign = (PaperAlign)mech; return success(); @@ -1213,6 +1237,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IRotation] = msgSupportGetAllSetReset; m_caps[CapType::IRotation] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::IRotation), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); if (Msg::Set == msg) { auto res = data.currentItem(); if (std::distance(imageRotateList.begin(), std::find(imageRotateList.begin(), imageRotateList.end(), res)) == imageRotateList.size()) @@ -1260,11 +1285,13 @@ Result HuagaoDs::identityOpenDs(const Identity&) { #endif m_query[CapType::FeederLoaded] = msgSupportGetAll; m_caps[CapType::FeederLoaded] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapType::FeederLoaded)); return CapSupGetAll(msg, data, Bool(scanner->Get_Scanner_PaperOn()), Bool(scanner->Get_Scanner_PaperOn())); }; m_query[CapType::Indicators] = msgSupportGetAllSetReset; m_caps[CapType::Indicators] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapType::Indicators), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto show = data.currentItem(); m_bIndicator = show; @@ -1286,6 +1313,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::FeederEnabled] = msgSupportGetAllSetReset; m_caps[CapType::FeederEnabled] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapType::FeederEnabled), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); m_bFeederEnabled = mech; @@ -1299,13 +1327,15 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::DuplexEnabled] = msgSupportGetAllSetReset; m_caps[CapType::DuplexEnabled] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapType::DuplexEnabled), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { - auto mech = data.currentItem(); + bool mech = data.currentItem(); m_scanparam->is_duplex = mech; - if (!mech) + if (!mech){ m_scanparam->is_backrotate180 = 0;//汳ת180㲻 - else + m_scanparam->is_switchfrontback = 0; m_scanparam->is_autodiscradblank_normal = m_scanparam->is_autodiscradblank_vince = m_scanparam->en_fold = 0; + } return success(); } return CapSupGetAllReset(msg, data, m_scanparam->is_duplex, Bool(true)); @@ -1313,6 +1343,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::AutoFeed] = msgSupportGetAllSetReset; m_caps[CapType::AutoFeed] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapType::AutoFeed), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); m_bAutoFeed = mech; @@ -1322,6 +1353,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { }; m_query[CapType::IImageFileFormat] = msgSupportGetAllSetReset; m_caps[CapType::IImageFileFormat] = [this](Msg msg, Capability& data) -> Result { + CapabilityPrintf(msg, enum2str(CapType::IImageFileFormat), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (mech == ImageFileFormat::Bmp || @@ -1340,6 +1372,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //custom define m_query[CapType::IAutomaticDeskew] = msgSupportGetAllSetReset; m_caps[CapType::IAutomaticDeskew] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IAutomaticDeskew), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto atuodsw = data.currentItem(); m_scanparam->autodescrew = (bool)atuodsw; @@ -1350,10 +1383,13 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[(CapType)(CapTypeEx::TwEx_SwitchFrontBack)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_SwitchFrontBack)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_SwitchFrontBack), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); + if ((!m_scanparam->is_duplex) && mech == TRUE) + return badValue(); m_scanparam->is_switchfrontback = mech; - return success(); + return success(); } return CapSupGetAllResetEx(msg, data, m_scanparam->is_switchfrontback, false); //return CapSupGetAllResetEx(msg, data, { FALSE,TRUE }, m_scanparam->is_switchfrontback, (Bool)false, m_scanparam->is_switchfrontback ? 1 : 0, 0); @@ -1361,6 +1397,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IAutomaticRotate] = msgSupportGetAllSetReset; m_caps[CapType::IAutomaticRotate] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IAutomaticRotate), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); m_scanparam->is_autotext = (bool)mech; @@ -1378,6 +1415,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::AutoScan] = msgSupportGetAllSetReset; m_caps[CapType::AutoScan] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::AutoScan), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto autoscan = data.currentItem(); m_autoscan = autoscan; @@ -1389,6 +1427,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IAutoSize] = msgSupportGetAllSetReset; m_caps[CapType::IAutoSize] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IAutoSize), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto autosize = data.currentItem(); if (autosize == AutoSize::Auto) { @@ -1415,6 +1454,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IAutomaticBorderDetection] = msgSupportGetAllSetReset; m_caps[CapType::IAutomaticBorderDetection] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IAutomaticBorderDetection), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto autodetectborder = data.currentItem(); if (autodetectborder) { @@ -1451,6 +1491,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType(CapTypeEx::TwEx_EnFold)] = msgSupportGetAllSetReset; m_caps[CapType(CapTypeEx::TwEx_EnFold)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_EnFold), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto autocrop = data.currentItem(); m_scanparam->en_fold = (Int32)autocrop; @@ -1467,6 +1508,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IAutoDiscardBlankPages] = msgSupportGetAllSetReset; m_caps[CapType::IAutoDiscardBlankPages] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IAutoDiscardBlankPages), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if ((mech == DiscardBlankPages::Auto) || (mech == DiscardBlankPages::Disabled)||((int)mech == 65535)) @@ -1498,15 +1540,15 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //հҳƱ m_query[(CapType)(CapTypeEx::TwEx_IAutoDiscardBlankVince)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_IAutoDiscardBlankVince)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_IAutoDiscardBlankVince), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); m_scanparam->is_autodiscradblank_vince = mech; if (mech) { m_scanparam->is_duplex = 1; m_scanparam->en_fold = 0; - } - if (mech) m_scanparam->is_autodiscradblank_normal = 0; + } return success(); } return CapSupGetAllResetEx(msg, data, m_scanparam->is_autodiscradblank_vince, false); @@ -1516,11 +1558,13 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[(CapType)(CapTypeEx::TwEx_IBackRotate180)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_IBackRotate180)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_IBackRotate180), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); - m_scanparam->is_backrotate180 = mech; - if (mech) - m_scanparam->is_duplex = 1; + if (m_scanparam->is_duplex && mech) + m_scanparam->is_backrotate180 = mech; + else + return badValue(); return success(); } return CapSupGetAllResetEx(msg, data, m_scanparam->is_backrotate180, false); @@ -1530,6 +1574,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //ڿ m_query[(CapType)(CapTypeEx::TwEx_IFillBackground)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_IFillBackground)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_IFillBackground), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); m_scanparam->fillbackground = mech; @@ -1542,6 +1587,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //üƫ m_query[(CapType)(CapTypeEx::TwEx_CroporDesaskewIndent)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_CroporDesaskewIndent)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_CroporDesaskewIndent), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if ((mech > 30 || mech < 5) && ((bool)m_scanparam->is_autocrop == true)) @@ -1555,9 +1601,10 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //Զü m_query[(CapType)(CapTypeEx::TwEx_CropNoise)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_CropNoise)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_CropNoise), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); - if ((mech > 10 || mech < 0) && ((bool)m_scanparam->is_autocrop == true)) + if ((mech > 20 || mech < 0) && ((bool)m_scanparam->is_autocrop == true)) return badValue(); m_scanparam->noise = mech; return success(); @@ -1567,10 +1614,10 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //Զк;ƫĶֵֵ m_query[(CapType)(CapTypeEx::TwEx_CroporDesaskewThreshold)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_CroporDesaskewThreshold)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_CroporDesaskewThreshold), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); - - if ((mech > 50 || mech < 30) && ((bool)m_scanparam->is_autocrop == true)) + if (mech > 50 || mech < 30) return badValue(); m_scanparam->AutoCrop_threshold = mech; return success(); @@ -1580,6 +1627,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //ڿ䷽ʽ m_query[(CapType)(CapTypeEx::TwEx_FillBackgroundMode)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_FillBackgroundMode)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_FillBackgroundMode), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); m_scanparam->is_convex = mech; @@ -1590,6 +1638,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { // m_query[(CapType)(CapTypeEx::TwEx_IFillHole)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_IFillHole)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_IFillHole), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); m_scanparam->fillhole.is_fillhole = mech; @@ -1601,6 +1650,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[(CapType)(CapTypeEx::TwEx_IFillHoleRatio)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_IFillHoleRatio)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_IFillHoleRatio), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (mech > 0 && mech < 50) { @@ -1614,6 +1664,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //Ż m_query[(CapType)(CapTypeEx::TwEx_IDetachNoise)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_IDetachNoise)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_IDetachNoise), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { if (m_scanparam->pixtype != 0) return badValue(); @@ -1627,6 +1678,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[(CapType)(CapTypeEx::TwEx_IDetachNoiseValue)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_IDetachNoiseValue)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_IDetachNoiseValue), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (mech > 9 && mech < 51) { @@ -1640,12 +1692,14 @@ Result HuagaoDs::identityOpenDs(const Identity&) { // m_query[(CapType)(CapTypeEx::TwEx_IMultiOutputRed)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_IMultiOutputRed)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_IMultiOutputRed), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (m_scanparam->pixtype == (BYTE)PixelType::Rgb) m_scanparam->multi_output_red = mech; else - m_scanparam->multi_output_red = 0;//Dzɫ ʹö + return badValue(); + //m_scanparam->multi_output_red = 0;//Dzɫ ʹö return success(); } return CapSupGetAllResetEx(msg, data, m_scanparam->multi_output_red, false); @@ -1654,8 +1708,11 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //⿨ m_query[(CapType)(CapTypeEx::TwEx_HsvCorrect)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_HsvCorrect)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_HsvCorrect), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); + if (mech && m_scanparam->pixtype != (int)PixelType::Rgb) + return badValue(); m_scanparam->hsvcorrect = mech; return success(); } @@ -1665,9 +1722,12 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IFilter] = msgSupportGetAllSetReset; m_caps[CapType::IFilter] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IFilter), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (mech == Filter::None || mech == Filter::Red || mech == Filter::Green || mech == Filter::Blue) { + if (((Filter)mech != Filter::None) && (m_scanparam->pixtype == (int)PixelType::Rgb)) + return badValue(); m_scanparam->filter = (BYTE)mech; if (mech != Filter::None) { m_scanparam->enhance_color = (BYTE)Enchace_Color::Enhance_None; @@ -1682,6 +1742,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //ɫǿ m_query[(CapType)(CapTypeEx::TwEx_IEnhanceColor)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_IEnhanceColor)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_IEnhanceColor), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (m_scanparam->pixtype == (int)PixelType::Rgb) @@ -1697,14 +1758,6 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_scanparam->enhance_color = (BYTE)mech; if (mech != (BYTE)Enchace_Color::Enhance_None) m_scanparam->filter = (BYTE)Filter::None; - - //if (m_scanparam->pixtype == (int)PixelType::BlackWhite) - //{ - // if (m_scanparam->enhance_color == (BYTE)Enchace_Color::Enhance_None) - // { - // m_scanparam->enhance_color = (BYTE)Enchace_Color::Enhance_Red; - // } - //} return success(); } } @@ -1715,6 +1768,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[(CapType)(CapTypeEx::TwEx_Sharpen)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_Sharpen)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_Sharpen), msg == Msg::Set ? to_string((int)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (m_scanparam->pixtype == (int)PixelType::BlackWhite) @@ -1729,6 +1783,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { /* Աȶ gamma range Range */ m_query[CapType::IBrightness] = msgSupportGetAllSetReset; m_caps[CapType::IBrightness] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IBrightness), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); switch (msg) { case Msg::Get: data = Capability::createRange(Fix32(-1000.0f), Fix32(1000.0f), Fix32(333.3f), Fix32(m_scanparam->brightness), Fix32(0.0)); @@ -1755,6 +1810,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IContrast] = msgSupportGetAllSetReset; m_caps[CapType::IContrast] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IContrast), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); switch (msg) { case Msg::Get: data = Capability::createRange(Fix32(-1000.0f), Fix32(1000.0f), Fix32(333.3f), Fix32(m_scanparam->contrast), Fix32(0.0)); @@ -1781,6 +1837,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[CapType::IGamma] = msgSupportGetAllSetReset; m_caps[CapType::IGamma] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::IGamma), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); switch (msg) { case Msg::Get: data = Capability::createRange(Fix32(0.0f), Fix32(5.0f), Fix32(1.0f), Fix32(m_scanparam->gamma), Fix32(1.0)); @@ -1808,6 +1865,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { /*ΪӲЭ*/ m_query[(CapType)(CapTypeEx::TwEx_ScrewDetectEnable)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_ScrewDetectEnable)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_ScrewDetectEnable), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); m_scanparam->hardwarecaps.en_skrewdetect = mech; @@ -1820,6 +1878,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[(CapType)(CapTypeEx::TwEx_ScrewLevel)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_ScrewLevel)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_ScrewLevel), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (mech >= 1 && mech <= 5) { @@ -1834,6 +1893,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //װ m_query[(CapType)(CapTypeEx::TwEx_StableDetectEnable)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_StableDetectEnable)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_StableDetectEnable), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); m_scanparam->hardwarecaps.en_stapledetect = mech; @@ -1843,9 +1903,10 @@ Result HuagaoDs::identityOpenDs(const Identity&) { return CapSupGetAllResetEx(msg, data, m_scanparam->hardwarecaps.en_stapledetect, false); //return CapSupGetAllResetEx(msg, data, { FALSE,TRUE }, m_scanparam->hardwarecaps.en_stapledetect, FALSE, m_scanparam->hardwarecaps.en_stapledetect==0 ? 0 : 1, 0); }; - + //۽Ǽ m_query[(CapType)(CapTypeEx::TwEx_DogEarDelection)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_DogEarDelection)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_DogEarDelection), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); m_scanparam->is_dogeardetection = mech; @@ -1853,9 +1914,25 @@ Result HuagaoDs::identityOpenDs(const Identity&) { } return CapSupGetAllResetEx(msg, data, m_scanparam->is_dogeardetection, FALSE); }; + //۽Ǽ۶㵽ʵС + m_query[(CapType)(CapTypeEx::TwEx_DogEarDistance)] = msgSupportGetAllSetReset; + m_caps[(CapType)(CapTypeEx::TwEx_DogEarDistance)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_DogEarDistance), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); + if (Msg::Set == msg) { + auto mech = data.currentItem(); + if (mech >= 10 && mech <= 300) + m_scanparam->dogeardistance = mech; + else + return badValue(); + return success(); + } + return CapSupGetAllResetEx(msg, data, m_scanparam->dogeardistance, 50); + }; + //˫ż ٷ׼ Э޸Ϊbool Уʹboolͣʹñ׼twainЭ m_query[CapType::DoubleFeedDetection] = msgSupportGetAllSetReset; m_caps[CapType::DoubleFeedDetection] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapType::DoubleFeedDetection), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); switch (msg) { case Msg::Get: data = Capability::createEnumeration(CapType::DoubleFeedDetection, { 0 ,1}, m_scanparam->hardwarecaps.en_doublefeed ? 0 : 1, 0); @@ -1889,6 +1966,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { //͹ģʽ m_query[(CapType)(CapTypeEx::TwEx_LowPowerMode)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_LowPowerMode)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_LowPowerMode), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); m_scanparam->hardwarecaps.lowpowermode = (LowPowerMode)mech; @@ -1903,6 +1981,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { m_query[(CapType)(CapTypeEx::TwEx_CropModel)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_CropModel)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_CropModel), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); if (Msg::Set == msg) { auto mech = data.currentItem(); if (m_scanparam->fillbackground || @@ -1920,6 +1999,7 @@ Result HuagaoDs::identityOpenDs(const Identity&) { #ifdef UV m_query[(CapType)(CapTypeEx::TwEx_UVModel)] = msgSupportGetAllSetReset; m_caps[(CapType)(CapTypeEx::TwEx_UVModel)] = [this](Msg msg, Capability& data)->Result { + CapabilityPrintf(msg, enum2str(CapTypeEx::TwEx_UVModel), msg == Msg::Set ? to_string((float)data.currentItem()) : ""); switch (msg) { case Msg::Get:{ data = Capability::createOneValue((CapType)(CapTypeEx::TwEx_UVModel), Bool(m_scanparam->hardwarecaps.en_uv)); @@ -1991,11 +2071,11 @@ Result HuagaoDs::pendingXfersEnd(const Identity&, PendingXfers& data) { if (ret != -1) { int index = scanner->geterrorindex(); if (ret == 82) - showmsg("", "ڵ" + to_string(index) + "ҳ⵽۽ǣֹͣɨ裡", ret); + showmsg("ʾ", "ڵ" + to_string(index) + "ҳ⵽۽ǣֹͣɨ裡", ret); else if(ret==75) - showmsg("", "ڵ" + to_string(index) + "ҳ⵽ߴ粻ֹͣɨ裡", ret); + showmsg("ʾ", "ڵ" + to_string(index) + "ҳ⵽ߴ粻ֹͣɨ裡", ret); else - showmsg("", msgs[(UsbSupported)ret], ret); + showmsg("ʾ", msgs[(UsbSupported)ret], ret); FileTools::writelog(log_ERROR, msgs[(UsbSupported)ret]); #ifndef G200 scanner->clear_hwerror(); @@ -2008,7 +2088,7 @@ Result HuagaoDs::pendingXfersEnd(const Identity&, PendingXfers& data) { int num = scanner->get_scannum() * (m_scanparam->is_duplex ? 2 : 1) * (m_scanparam->multi_output_red ? 2 : 1) / (m_scanparam->en_fold ? 2 : 1); if ((num - scanner->get_imgTransfered()) != 0) { - showmsg("", msgs[LOSE_IMAGE]); + showmsg("ʾ", msgs[LOSE_IMAGE]); FileTools::writelog(log_ERROR, msgs[LOSE_IMAGE]); } @@ -2394,7 +2474,7 @@ Twpp::Result HuagaoDs::showTwainUI(Twpp::UserInterface& ui, bool bUiOnly) while (!scanner->Get_Scanner_PaperOn()) { if (scanner->get_ErrorCode() == SLEEPING) { - showmsg("", msgs[(UsbSupported)81]); + showmsg("ʾ", msgs[(UsbSupported)81]); scanner->Set_ErrorCode(0); return seqError(); } @@ -2461,6 +2541,32 @@ void HuagaoDs::DeviceEvent_callback(int eventID, void* usrdata) This->onDeviceEvent(eventID); } +void HuagaoDs::CapabilityPrintf(Twpp::Msg msg, std::string capability, std::string value) +{ + if (!is_printfcapability) + return; + switch (msg) + { + case Msg::Reset: + FileTools::writelog(log_INFO, (std::string)enum2str(Msg::Reset) + "\t" + capability); + break; + case Msg::Get: + FileTools::writelog(log_INFO, (std::string)enum2str(Msg::Get) + "\t" + capability); + break; + case Msg::GetCurrent: + FileTools::writelog(log_INFO, (std::string)enum2str(Msg::GetCurrent) + "\t" + capability); + break; + case Msg::GetDefault: + FileTools::writelog(log_INFO, (std::string)enum2str(Msg::GetDefault) + "\t" + capability); + break; + case Msg::Set: + FileTools::writelog(log_INFO, (std::string)enum2str(Msg::Set) + "\t" + capability+"\t value = "+value); + break; + default: + break; + } +} + void HuagaoDs::onDeviceEvent(int eventID) { //if (mapDeviceEvent.count(eventID)) @@ -2520,59 +2626,30 @@ Twpp::Result HuagaoDs::startScan() scanner->ResetScanner(); scanner->reset(); - //std::string info = "ʼɨ ===> ɨòΪ\n\t m_scanparam->is_autocrop :" + to_string(m_scanparam->is_autocrop); - //info += "\n\t m_scanparam->colorenable :" + to_string(m_scanparam->automaticcolor); - //info += "\n\t m_scanparam->colorenabletype :" + to_string(m_scanparam->automaticcolortype); - //info += "\n\t m_scanparam->papertype :" + to_string(m_scanparam->papertype); - //info += "\n\t m_scanparam->fillbackground :" + to_string(m_scanparam->fillbackground); - //info += "\n\t m_scanparam->autodescrew :" + to_string(m_scanparam->autodescrew); - //info += "\n\t m_scanparam->brightness :" + to_string(m_scanparam->brightness); - //info += "\n\t m_scanparam->Caption :" + m_scanparam->Caption; - //info += "\n\t m_scanparam->contrast :" + to_string(m_scanparam->contrast); - //info += "\n\t m_scanparam->discardblank_percent :" + to_string(m_scanparam->discardblank_percent); - //info += "\n\t m_scanparam->enhance_color :" + to_string(m_scanparam->enhance_color); - //info += "\n\t m_scanparam->en_fold :" + to_string(m_scanparam->en_fold); - //info += "\n\t m_scanparam->hardwarecaps.capturepixtype :" + to_string(m_scanparam->hardwarecaps.capturepixtype); - //info += "\n\t m_scanparam->hardwarecaps.en_doublefeed :" + to_string(m_scanparam->hardwarecaps.en_doublefeed); - //info += "\n\t m_scanparam->hardwarecaps.en_stapledetect :" + to_string(m_scanparam->hardwarecaps.en_stapledetect); - //info += "\n\t m_scanparam->hardwarecaps.en_skrewdetect :" + to_string(m_scanparam->hardwarecaps.en_skrewdetect); - //info += "\n\t m_scanparam->hardwarecaps.skrewdetectlevel :" + to_string(m_scanparam->hardwarecaps.skrewdetectlevel); - //info += "\n\t m_scanparam->imageRotateDegree :" + to_string(m_scanparam->imageRotateDegree); - //info += "\n\t m_scanparam->is_duplex :" + to_string(m_scanparam->is_duplex); - //info += "\n\t m_scanparam->pixtype :" + to_string(m_scanparam->pixtype); - //info += "\n\t m_scanparam->resolution_dst :" + to_string(m_scanparam->resolution_dst); - //info += "\n\t m_scanparam->resolution_native :" + to_string(m_scanparam->resolution_native); - //info += "\n\t m_scanparam->paperAlign :" + to_string((int)m_scanparam->paperAlign); - //info += "\n\t m_scanparam->gamma :" + to_string(m_scanparam->gamma); - //info += "\n\t m_scanparam->threshold :" + to_string(m_scanparam->threshold); - //info += "\n\t m_scanparam->is_autocontrast :" + to_string(m_scanparam->is_autocontrast); - //info += "\n\t m_scanparam->is_autocrop :" + to_string(m_scanparam->is_autocrop); - //info += "\n\t m_scanparam->fillhole.fillholeratio :" + to_string(m_scanparam->fillhole.fillholeratio); - //info += "\n\t m_scanparam->fillhole.is_fillhole :" + to_string(m_scanparam->fillhole.is_fillhole); - //info += "\n\t m_scanparam->is_autodiscradblank_normal :" + to_string(m_scanparam->is_autodiscradblank_normal); - //info += "\n\t m_scanparam->is_autodiscradblank_vince :" + to_string(m_scanparam->is_autodiscradblank_vince); - //info += "\n\t m_scanparam->is_switchfrontback :" + to_string(m_scanparam->is_switchfrontback); - //info += "\n\t m_scanparam->multi_output_red :" + to_string(m_scanparam->multi_output_red); - //info += "\n\t m_scanparam->hsvcorrect :" + to_string(m_scanparam->hsvcorrect); - //info += "\n\t m_scanparam->filter :" + to_string(m_scanparam->filter); - //info += "\n\t m_scanparam->sharpen :" + to_string(m_scanparam->sharpen); - //info += "\n\t m_scanparam->scannum :" + to_string(m_scanparam->scannum); - //info += "\n\t m_scanparam->is_backrotate180 :" + to_string(m_scanparam->is_backrotate180); - //info += "\n\t m_scanparam->is_autotext :" + to_string(m_scanparam->is_autotext); - //info += "\n\t m_scanparam->SavePath :" + m_scanparam->SavePath; - //info += "\n\t m_scanparam->noise :" + to_string(m_scanparam->noise); - //info += "\n\t m_scanparam->indent :" + to_string(m_scanparam->indent); - //info += "\n\t m_scanparam->AutoCrop_threshold :" + to_string(m_scanparam->AutoCrop_threshold); - //info += "\n\t m_scanparam->is_convex :" + to_string(m_scanparam->is_convex); - //FileTools::write_log("D:\\1.txt",info); FileTools::writelog(log_INFO, "start scan"); -#ifndef G200 - if(scanner->notifyscan()<1) +#ifdef G200 +#ifndef ANDROIDSERIAL + if (scanner->notifyscan() < 1) return seqError(); - +#endif // !ANDROIDSERIAL scanner->clear_hwerror(); +#endif // + +#ifdef G200 + if (scanner->Get_Roller_num() > 450000) +#elif defined G300 + if (scanner->Get_Roller_num() > 150000) +#else + if (scanner->Get_Roller_num() > 200000) +#endif // G200 + { + Twain_config config; + if (config.getrollermsgdate() < chrono::duration_cast>>(chrono::system_clock::now().time_since_epoch()).count()){ + hgmsg(_T("ִֽֽѳʹ÷Χɨдֽʧܡбŵ쳣Ƶοܻ࣬ע⼰ʱࡢϵ豸Ӧ̹滻ֽ֣")); + config.setrollermsgdata(chrono::duration_cast>>(chrono::system_clock::now().time_since_epoch()).count()); + } + } -#endif // scanner->config_params(*m_scanparam); @@ -2618,11 +2695,11 @@ Twpp::Result HuagaoDs::startScan() //ShellExecute(guiTwain ? guiTwain->m_hWnd : NULL, TEXT("open"), GetHidedlgPath(), str, NULL, SW_HIDE); int index = scanner->geterrorindex(); if (retCode == 82) - showmsg("", "ڵ" + to_string(index) + "ҳ⵽۽ǣֹͣɨ裡", retCode); + showmsg("ʾ", "ڵ" + to_string(index) + "ҳ⵽۽ǣֹͣɨ裡", retCode); else if (retCode == 75) - showmsg("", "ڵ" + to_string(index) + "ҳ⵽ߴ粻ֹͣɨ裡", retCode); + showmsg("ʾ", "ڵ" + to_string(index) + "ҳ⵽ߴ粻ֹͣɨ裡", retCode); else - showmsg("", msgs[(UsbSupported)retCode], retCode); + showmsg("ʾ", msgs[(UsbSupported)retCode], retCode); FileTools::writelog(log_ERROR, msgs[(UsbSupported)retCode]); #ifndef G200 scanner->clear_hwerror(); diff --git a/huagao/huagaods.hpp b/huagao/huagaods.hpp index 7696b307..40cc3925 100644 --- a/huagao/huagaods.hpp +++ b/huagao/huagaods.hpp @@ -94,7 +94,9 @@ private://method void dogear_callback(int indexpaper); void updataGscanCap(); Twpp::Result capCommon(const Twpp::Identity& origin, Twpp::Msg msg, Twpp::Capability& data); + void CapabilityPrintf(Twpp::Msg msg, std::string capability, std::string value = ""); void showmsg(std::string caption, std::string text, int retcode=0); + void hgmsg(CString str); private://field std::unordered_map> m_caps; @@ -127,7 +129,7 @@ private://field bool m_memoryfalg = true; HANDLE hMutex; int pid = 0, vid = 0; - + int is_printfcapability; }; #endif // SIMPLEDS_HPP diff --git a/huagao/huagaotwds.rc b/huagao/huagaotwds.rc index cd08bf99..f98e8019 100644 Binary files a/huagao/huagaotwds.rc and b/huagao/huagaotwds.rc differ diff --git a/huagao/resource.h b/huagao/resource.h index 5a3237ec..cc1de92e 100644 Binary files a/huagao/resource.h and b/huagao/resource.h differ diff --git a/huagao/stdafx.h b/huagao/stdafx.h index 2d9daad8..3394b55d 100644 Binary files a/huagao/stdafx.h and b/huagao/stdafx.h differ