mirror of http://192.168.1.51:8099/lmh188/twain3.0
653 lines
15 KiB
C++
653 lines
15 KiB
C++
|
#include "GScanO1003399.h"
|
|||
|
|
#include "ImageProcess/ImageApplyHeaders.h"
|
|||
|
|
#include "ImageMultiOutput.h"
|
|||
|
|
#include "scn_config.h"
|
|||
|
|
#include "PaperSize.h"
|
|||
|
|
#include "GScan.h"
|
|||
|
|
|
|||
|
|
static std::mutex mx_ctrl;
|
|||
|
|
|
|||
|
|
static int scanner_read_reg(std::shared_ptr<IUsb>& usb, int addr)
|
|||
|
|
{
|
|||
|
|
int val = 0;
|
|||
|
|
std::lock_guard<std::mutex> lck(mx_ctrl);
|
|||
|
|
usb->control_msg(0xc0, USB_REQ_GET_DEV_REGS, addr, 0, 4, &val);
|
|||
|
|
return val;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void scanner_write_reg(std::shared_ptr<IUsb>& usb, int addr, int val)
|
|||
|
|
{
|
|||
|
|
std::lock_guard<std::mutex> lck(mx_ctrl);
|
|||
|
|
usb->control_msg(0x40, USB_REQ_SET_DEV_REGS, addr, 0, 4, &val);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void scanner_cmd(std::shared_ptr<IUsb>& usb, int cmd)
|
|||
|
|
{
|
|||
|
|
scanner_write_reg(usb, 0, cmd);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
GScanO1003399::GScanO1003399():
|
|||
|
|
m_imgthread(1)
|
|||
|
|
{
|
|||
|
|
im_data.reset(new std::vector<char>());
|
|||
|
|
open(0, 0);
|
|||
|
|
|
|||
|
|
devState = DEV_STOP;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
GScanO1003399::~GScanO1003399()
|
|||
|
|
{
|
|||
|
|
if (m_usbthread.get() && m_usbthread->joinable())
|
|||
|
|
{
|
|||
|
|
b_usbthread = false;
|
|||
|
|
m_usbthread->join();
|
|||
|
|
m_usbthread.reset();
|
|||
|
|
}
|
|||
|
|
if (fu_rx.valid())
|
|||
|
|
fu_rx.wait();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::open(int vid, int pid)
|
|||
|
|
{
|
|||
|
|
//auto lsusb=CyUsbList::find_vid_pid(vid, pid);
|
|||
|
|
//if (!lsusb.empty())
|
|||
|
|
//{
|
|||
|
|
// m_usb = *lsusb.begin();
|
|||
|
|
// m_usb->open();
|
|||
|
|
//}
|
|||
|
|
if (m_usb.get()&&m_usb->is_connected())
|
|||
|
|
return;
|
|||
|
|
auto lsusb = CyUsbList::find_all();
|
|||
|
|
if (!lsusb.empty())
|
|||
|
|
{
|
|||
|
|
m_usb = *lsusb.begin();
|
|||
|
|
m_usb->open();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::regist_deviceevent_callback(deviceevent_callback callback, void* usrdata)
|
|||
|
|
{
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::DogEar_callback(std::function<void(int)> fun)
|
|||
|
|
{
|
|||
|
|
}
|
|||
|
|
static int aquirenum = 0;
|
|||
|
|
static int getimgnum = 0;
|
|||
|
|
int GScanO1003399::aquire_bmpdata(std::vector<unsigned char>& bmpdata)
|
|||
|
|
{
|
|||
|
|
StopWatch sw;
|
|||
|
|
while (true)
|
|||
|
|
{
|
|||
|
|
if ((m_imagedata.Size() < 1)&&(!is_runing()))
|
|||
|
|
{
|
|||
|
|
DoEvents();
|
|||
|
|
this_thread::sleep_for(chrono::milliseconds(1));
|
|||
|
|
if (!is_runing())
|
|||
|
|
{
|
|||
|
|
if (devState == DEV_WRONG)
|
|||
|
|
return get_ErrorCode();
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
if (sw.elapsed_s() > 30.0)
|
|||
|
|
{
|
|||
|
|
devState = DEV_STOP;
|
|||
|
|
if (fu_rx.valid())
|
|||
|
|
fu_rx.wait();
|
|||
|
|
Stop_scan();
|
|||
|
|
ResetScanner();
|
|||
|
|
return AQUIRE_IMAGE_TIMEOUT;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
if ((m_imagedata.Size() > 0))
|
|||
|
|
{
|
|||
|
|
FileTools::writelog(log_INFO, "aquire_bmpdata num =" + to_string(aquirenum++));
|
|||
|
|
bmpdata = *(m_imagedata.Take());
|
|||
|
|
UpdateScanInfo(get_imgnReaded(), countNTransfered());
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
DoEvents();
|
|||
|
|
this_thread::sleep_for(chrono::milliseconds(2));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
BOOL GScanO1003399::IsConnected()
|
|||
|
|
{
|
|||
|
|
return m_usb.get()&&m_usb->is_connected();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
std::string GScanO1003399::GetFWVersion()
|
|||
|
|
{
|
|||
|
|
std::string fw;
|
|||
|
|
if (m_usb.get() && m_usb->is_connected())
|
|||
|
|
{
|
|||
|
|
scanner_write_reg(m_usb, SR_GET_FWVERSION, 0);
|
|||
|
|
fw.resize(10);
|
|||
|
|
read_data(&fw[0], fw.length(), 200);
|
|||
|
|
}
|
|||
|
|
return fw;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
std::string GScanO1003399::GetSerialNum()
|
|||
|
|
{
|
|||
|
|
std::string sn;
|
|||
|
|
if (m_usb.get() && m_usb->is_connected())
|
|||
|
|
{
|
|||
|
|
scanner_write_reg(m_usb, SR_GET_SERIALNUM, 0);
|
|||
|
|
sn.resize(14);
|
|||
|
|
read_data(&sn[0], sn.length(), 200);
|
|||
|
|
}
|
|||
|
|
return sn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
std::uint32_t GScanO1003399::GetMotorFPGA()
|
|||
|
|
{
|
|||
|
|
return std::uint32_t();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
std::uint32_t GScanO1003399::GetScanFPGA()
|
|||
|
|
{
|
|||
|
|
return std::uint32_t();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool GScanO1003399::is_scan()
|
|||
|
|
{
|
|||
|
|
//return devState==DEV_ISRUNNING;
|
|||
|
|
return is_runing() || (m_imagedata.Size() > 0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
BOOL GScanO1003399::Get_Scanner_PaperOn()
|
|||
|
|
{
|
|||
|
|
return scanner_read_reg(m_usb, SR_PAPER_READY);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int GScanO1003399::Get_Roller_num()
|
|||
|
|
{
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::config_params(GScanCap& param)
|
|||
|
|
{
|
|||
|
|
m_param = param;
|
|||
|
|
HGScanConfig cfg;
|
|||
|
|
cfg = { 0 };
|
|||
|
|
#ifdef G200
|
|||
|
|
|
|||
|
|
PaperStatus ps = { param.papertype,param.paperAlign };
|
|||
|
|
cfg.g200params.paper = SupPaperTyps.count(ps)>0 ? SupPaperTyps[ps] : 0;
|
|||
|
|
if (param.filter != 3 || param.enhance_color != 0 || param.hsvcorrect)
|
|||
|
|
cfg.g200params.color = 1;//color
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
cfg.g200params.color = SupPixelTypes.count(param.pixtype) > 0 ? SupPixelTypes[param.pixtype] : 2;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
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 = (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;
|
|||
|
|
|
|||
|
|
cfg.g200params.enable_sizecheck = param.en_sizecheck == 1 ? 1 : 0;
|
|||
|
|
cfg.g200params.unused_one = cfg.g200params.sizeerror_errorratio = 0;
|
|||
|
|
param.resolution_dst >= 240.0f ? 1 : 0;
|
|||
|
|
|
|||
|
|
#else
|
|||
|
|
|
|||
|
|
cfg.g400params.doubleFeeded = param.hardwarecaps.en_doublefeed == 0 ? 0 : 1;
|
|||
|
|
cfg.g400params.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.g400params.enableLed = 1;
|
|||
|
|
if (param.filter != 3 || param.enhance_color)
|
|||
|
|
cfg.g400params.isColor = 1;
|
|||
|
|
else
|
|||
|
|
cfg.g400params.isColor = SupPixelTypes[param.pixtype];
|
|||
|
|
cfg.g400params.enableStable = 0;//gcap.hardwarecaps.en_stapledetect==0?0:1;
|
|||
|
|
cfg.g400params.isCorrect = 1;//1 <20><><EFBFBD><EFBFBD>У<EFBFBD><D0A3>
|
|||
|
|
PaperStatus ps = { param.papertype,param.paperAlign };
|
|||
|
|
cfg.g400params.pageSize = SupPaperTyps[ps];
|
|||
|
|
CSize size;
|
|||
|
|
#ifdef G300
|
|||
|
|
size = Device::PaperSize().GetPaperSize(TwSS::A4, 200.0f, gcap.paperAlign);//G300 <20><><EFBFBD><EFBFBD>֧<EFBFBD><D6A7>A4<41><34><EFBFBD><EFBFBD>
|
|||
|
|
#else
|
|||
|
|
size = Device::PaperSize().GetPaperSize(param.papertype, 200.0f, param.paperAlign);
|
|||
|
|
#endif// G300
|
|||
|
|
cfg.g400params.dstHeight = (int)((size.cy + 200) / 100);
|
|||
|
|
cfg.g400params.reversed1 = cfg.g400params.reversed2 = 0;
|
|||
|
|
#endif // G200
|
|||
|
|
config_scanparam(cfg);
|
|||
|
|
config_imgprocparam({0});
|
|||
|
|
GScanCap_3399 param39{ 0 };
|
|||
|
|
param39.AutoCrop_threshold = param.AutoCrop_threshold;
|
|||
|
|
param39.autodescrew = param.autodescrew;
|
|||
|
|
param39.automaticcolor = param.automaticcolor;
|
|||
|
|
param39.automaticcolortype = param39.automaticcolortype;
|
|||
|
|
param39.brightness = param.brightness;
|
|||
|
|
param39.contrast = param.contrast;
|
|||
|
|
param39.detachnoise = param.detachnoise;
|
|||
|
|
param39.discardblank_percent = param.discardblank_percent;
|
|||
|
|
param39.en_fold = param.en_fold;
|
|||
|
|
param39.en_sizecheck = param.en_sizecheck;
|
|||
|
|
param39.enhance_color = param.enhance_color;
|
|||
|
|
param39.fillbackground = param.fillbackground;
|
|||
|
|
param39.fillhole = param.fillhole;
|
|||
|
|
param39.filter = param.filter;
|
|||
|
|
param39.gamma = param.gamma;
|
|||
|
|
param39.hardwarecaps = param.hardwarecaps;
|
|||
|
|
param39.hsvcorrect = param.hsvcorrect;
|
|||
|
|
param39.imageRotateDegree = param.imageRotateDegree;
|
|||
|
|
param39.indent = param.indent;
|
|||
|
|
param39.is_autocontrast = param.is_autocontrast;
|
|||
|
|
param39.is_autocrop = param.is_autocrop;
|
|||
|
|
param39.is_autodiscradblank_normal = param.is_autodiscradblank_normal;
|
|||
|
|
param39.is_autodiscradblank_vince = param.is_autodiscradblank_vince;
|
|||
|
|
param39.is_autotext = param.is_autotext;
|
|||
|
|
param39.is_backrotate180 = param.is_backrotate180;
|
|||
|
|
param39.is_convex = param.is_convex;
|
|||
|
|
param39.is_dogeardetection = param.is_dogeardetection;
|
|||
|
|
param39.is_duplex = param.is_duplex;
|
|||
|
|
param39.is_switchfrontback = param.is_switchfrontback;
|
|||
|
|
param39.multi_output_red = param.multi_output_red;
|
|||
|
|
param39.noise = param.noise;
|
|||
|
|
param39.paperAlign = param.paperAlign;
|
|||
|
|
param39.papertype = param.papertype;
|
|||
|
|
param39.pixtype = param.pixtype;
|
|||
|
|
param39.resolution_dst = param.resolution_dst;
|
|||
|
|
param39.resolution_native = param.resolution_native;
|
|||
|
|
param39.scannum = param.scannum;
|
|||
|
|
param39.sharpen = param.sharpen;
|
|||
|
|
param39.threshold = param.threshold;
|
|||
|
|
m_usb->write_bulk(¶m39, sizeof(param39));
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::Scanner_StartScan(UINT16 count)
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
scanflag = true;
|
|||
|
|
Set_ErrorCode(0);
|
|||
|
|
getimgnum = 0;
|
|||
|
|
aquirenum = 0;
|
|||
|
|
|
|||
|
|
reset();
|
|||
|
|
devState = DEV_ISRUNNING;
|
|||
|
|
if (scan_mode())
|
|||
|
|
{
|
|||
|
|
devState = DEV_WRONG;
|
|||
|
|
Set_ErrorCode(COUNT_MODE);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
//if (!Get_Scanner_PaperOn())
|
|||
|
|
//{
|
|||
|
|
// devState = DEV_WRONG;
|
|||
|
|
// Set_ErrorCode(NO_FEED);
|
|||
|
|
// return;
|
|||
|
|
//}
|
|||
|
|
|
|||
|
|
start();
|
|||
|
|
if (!m_usbthread.get()) {
|
|||
|
|
b_usbthread = true;
|
|||
|
|
m_usbthread.reset(new thread(&GScanO1003399::usb_run, this));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::Stop_scan()
|
|||
|
|
{
|
|||
|
|
if (devState != DEV_ISRUNNING)
|
|||
|
|
return;
|
|||
|
|
stop();
|
|||
|
|
scanflag = false;
|
|||
|
|
if (fu_rx.valid())
|
|||
|
|
fu_rx.wait();
|
|||
|
|
devState == DEV_ISRUNNING ? devState = DEV_STOP : devState = DEV_WRONG;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int GScanO1003399::notifyscan()
|
|||
|
|
{
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::ResetScanner()
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool GScanO1003399::Get_IsImageQueueEmpty()
|
|||
|
|
{
|
|||
|
|
return m_imagedata.Size() < 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::reset()
|
|||
|
|
{
|
|||
|
|
devState = DEV_STOP;
|
|||
|
|
m_imagedata.Clear();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::clear_hwerror()
|
|||
|
|
{
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
UINT32 GScanO1003399::get_ErrorCode()
|
|||
|
|
{
|
|||
|
|
return Error_Code;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::Set_ErrorCode(UINT32 value)
|
|||
|
|
{
|
|||
|
|
Error_Code = value;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int GScanO1003399::get_scanned_num()
|
|||
|
|
{
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::set_sleep_time(int mode)
|
|||
|
|
{
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool GScanO1003399::set_scannercode(std::string str)
|
|||
|
|
{
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
std::string GScanO1003399::get_scannercode()
|
|||
|
|
{
|
|||
|
|
return std::string();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::usb_run()
|
|||
|
|
{
|
|||
|
|
unsigned char buff[64];
|
|||
|
|
while (b_usbthread)
|
|||
|
|
{
|
|||
|
|
if (!m_usb.get() || !m_usb->is_connected())
|
|||
|
|
{
|
|||
|
|
this_thread::sleep_for(chrono::milliseconds(20));
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
memset(buff, 0, sizeof(buff));
|
|||
|
|
auto length = m_usb->read_int(buff, sizeof(buff));
|
|||
|
|
if (((length) == sizeof(buff)) || im_dev_count())
|
|||
|
|
{
|
|||
|
|
HGEIntInfo info = *(HGEIntInfo*)&buff;
|
|||
|
|
switch (info.From)
|
|||
|
|
{
|
|||
|
|
case IMG:
|
|||
|
|
if (is_runing())
|
|||
|
|
im_rx();
|
|||
|
|
break;
|
|||
|
|
case MtBoard:
|
|||
|
|
FileTools::writelog(log_ERROR, "Got MotorBoard error code = " + to_string(info.Code));
|
|||
|
|
break;
|
|||
|
|
case FPGA:
|
|||
|
|
FileTools::writelog(log_ERROR, "Got FPGA Error code = " + to_string(info.Code));
|
|||
|
|
break;
|
|||
|
|
case V4L2:
|
|||
|
|
FileTools::writelog(log_ERROR, "Got V4L2 Error code = " + to_string(info.Code));
|
|||
|
|
break;
|
|||
|
|
default:
|
|||
|
|
FileTools::writelog(log_ERROR, "Got Unkown error code ! From =" + to_string(info.From) + " Code = " + to_string(info.Code));
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
if ((codeconvter(info) != 0))
|
|||
|
|
{
|
|||
|
|
scanflag = false;
|
|||
|
|
devState = codeconvter(info) == -1 ? DEV_STOP : DEV_WRONG;
|
|||
|
|
}
|
|||
|
|
if (codeconvter(info) > 0)
|
|||
|
|
{
|
|||
|
|
Set_ErrorCode(codeconvter(info));
|
|||
|
|
stop();
|
|||
|
|
}
|
|||
|
|
this_thread::sleep_for(chrono::microseconds(10));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::start()
|
|||
|
|
{
|
|||
|
|
scanner_cmd(m_usb, SC_START);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::stop()
|
|||
|
|
{
|
|||
|
|
scanner_cmd(m_usb, SC_STOP);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool GScanO1003399::is_runing()
|
|||
|
|
{
|
|||
|
|
return scanner_read_reg(m_usb, SR_STATUS) & 0x01;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int GScanO1003399::scan_mode()
|
|||
|
|
{
|
|||
|
|
return scanner_read_reg(m_usb, SR_OS) & 0x01;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int GScanO1003399::count()
|
|||
|
|
{
|
|||
|
|
return scanner_read_reg(m_usb, SR_SCAN_COUNT);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::abort_dev_tx()
|
|||
|
|
{
|
|||
|
|
scanner_write_reg(m_usb, SR_IM_ABORT, 1); //!< to-list
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::config_scanparam(const HG_ScanConfig& cfg)
|
|||
|
|
{
|
|||
|
|
scanner_write_reg(m_usb, SR_CONFIG_SCAN_PARAM, cfg.value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::config_imgprocparam(const HGImgProcParms& imgprocparams)
|
|||
|
|
{
|
|||
|
|
scanner_write_reg(m_usb, SR_CONFIF_IMGPROCPARAM,imgprocparams.value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool GScanO1003399::is_rx()
|
|||
|
|
{
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool GScanO1003399::rx_cmd()
|
|||
|
|
{
|
|||
|
|
scanner_write_reg(m_usb, 8, 1);
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool GScanO1003399::is_dev_tx()
|
|||
|
|
{
|
|||
|
|
return scanner_read_reg(m_usb, SR_IM_TXING);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::im_rx()
|
|||
|
|
{
|
|||
|
|
if (!is_rx() && !is_dev_tx())
|
|||
|
|
{
|
|||
|
|
fu_rx = m_imgthread.enqueue([this] {
|
|||
|
|
do
|
|||
|
|
{
|
|||
|
|
/* code */
|
|||
|
|
auto &buffi = im_data;
|
|||
|
|
int count = front_datasize();
|
|||
|
|
buffi->resize(count);
|
|||
|
|
rx_cmd();
|
|||
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|||
|
|
count = read_data(buffi->data(), count, count / (0.01 * 1024 * 1024));
|
|||
|
|
pop_dev_im();
|
|||
|
|
vector<cv::Mat> mats;
|
|||
|
|
auto& buffs = G400Decode(buffi).getImageBuffs();
|
|||
|
|
UpdateScanInfo(countNReaded(), get_imgTransfered());
|
|||
|
|
imgproce(buffs);
|
|||
|
|
} while (im_dev_count());
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int GScanO1003399::read_data(void* data, int length, int timeout)
|
|||
|
|
{
|
|||
|
|
int readed = 0;
|
|||
|
|
int reading = 0;
|
|||
|
|
const int buffer_size = 2 * 1024 * 1024;
|
|||
|
|
StopWatch sw;
|
|||
|
|
while (readed < length && sw.elapsed_ms() < timeout) {
|
|||
|
|
reading = std::max(0, std::min(length - readed, buffer_size));
|
|||
|
|
reading = m_usb->read_bulk((unsigned char*)data + readed, reading);
|
|||
|
|
if (reading > 0) {
|
|||
|
|
readed += reading;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return readed;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::pop_dev_im()
|
|||
|
|
{
|
|||
|
|
scanner_write_reg(m_usb, SR_IM_POP, 1); //!< to-list
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int GScanO1003399::front_datasize()
|
|||
|
|
{
|
|||
|
|
return scanner_read_reg(m_usb, SR_IM_FRONT_SIZE);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int GScanO1003399::im_dev_count()
|
|||
|
|
{
|
|||
|
|
return scanner_read_reg(m_usb, SR_IM_COUNT); //!< to-list ;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void GScanO1003399::imgproce(std::vector<std::shared_ptr<std::vector<char>>>& buffs)
|
|||
|
|
{
|
|||
|
|
vector<cv::Mat> mats;
|
|||
|
|
for (auto& buf : buffs) {
|
|||
|
|
cv::ImreadModes rmc;
|
|||
|
|
//int rm;
|
|||
|
|
if (m_param.filter != 3 || m_param.enhance_color || m_param.hsvcorrect) {
|
|||
|
|
rmc = cv::IMREAD_COLOR;
|
|||
|
|
//rm = 1;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
rmc = m_param.pixtype == 2 ? cv::IMREAD_COLOR : cv::IMREAD_GRAYSCALE;
|
|||
|
|
//rm = scanParam.pixtype == 2 ? 1 : 6;
|
|||
|
|
}
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
cv::Mat mat = cv::imdecode(*buf, rmc);
|
|||
|
|
if (mat.empty()) {
|
|||
|
|
FileTools::writelog(log_ERROR, "decode image data error");
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
buf.reset();
|
|||
|
|
mats.push_back(mat);
|
|||
|
|
FileTools::writelog(log_INFO, "push_back image num= " + to_string(getimgnum++));
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e)
|
|||
|
|
{
|
|||
|
|
//writelog(e.what());
|
|||
|
|
FileTools::writelog(log_ERROR, e.what());
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
buffs.clear();
|
|||
|
|
if (m_param.automaticcolor)
|
|||
|
|
{
|
|||
|
|
CImageApplyColorRecognition(m_param.automaticcolortype == 1 ? CImageApplyColorRecognition::ColorRecognitionMode::Color_Gray : CImageApplyColorRecognition::ColorRecognitionMode::Color_Mono).apply(mats,m_param.is_duplex);
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
for (int i = 0; i < mats.size(); i++) {
|
|||
|
|
//if (!m_param.is_duplex && i == 1) {
|
|||
|
|
// mats[i].release();
|
|||
|
|
// break;
|
|||
|
|
//}
|
|||
|
|
if (!mats[i].empty()) {
|
|||
|
|
IMat2Bmp idata;
|
|||
|
|
if (m_param.pixtype == 1 && m_param.hsvcorrect)
|
|||
|
|
if (mats[i].channels() == 3)
|
|||
|
|
cvtColor(mats[i], mats[i], cv::COLOR_BGR2GRAY);
|
|||
|
|
idata = (m_param.pixtype == 0 || (((m_param.automaticcolortype == 0) && (m_param.automaticcolor == true)) && (mats[i].channels() == 1))) ? (IMat2Bmp)Mat2BmpBw(mats[i], m_param.resolution_dst) : Mat2Bmp(mats[i], m_param.resolution_dst);
|
|||
|
|
//if (!m_param.multi_output_red)
|
|||
|
|
// mats[i].release();
|
|||
|
|
|
|||
|
|
m_imagedata.Put(idata.getBmpDataBuffer());
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_param.multi_output_red) {
|
|||
|
|
for (int i = 0; i < mats.size(); i++) {
|
|||
|
|
if (!mats[i].empty()) {
|
|||
|
|
ImageMultiOutput m_mlt;
|
|||
|
|
cv::Mat ret = m_mlt.GetMultiFilterMat(mats[i], 2);
|
|||
|
|
mats[i].release();
|
|||
|
|
if (!ret.empty()) {
|
|||
|
|
if (!m_param.is_duplex && i == 1) {
|
|||
|
|
ret.release();
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
Mat2Bmp mb(ret, m_param.resolution_dst);
|
|||
|
|
m_imagedata.Put(mb.getBmpDataBuffer());
|
|||
|
|
ret.release();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
mats.clear();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int GScanO1003399::codeconvter(HGEIntInfo code)
|
|||
|
|
{
|
|||
|
|
if (code.From == HGType::FPGA)
|
|||
|
|
{
|
|||
|
|
switch (code.Code)
|
|||
|
|
{
|
|||
|
|
default:
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (code.From == HGType::MtBoard)
|
|||
|
|
{
|
|||
|
|
switch (code.Code)
|
|||
|
|
{
|
|||
|
|
case 0x00002:
|
|||
|
|
return NO_FEED;
|
|||
|
|
case 0x00004:
|
|||
|
|
return OPEN_COVER;
|
|||
|
|
case 0x00008:
|
|||
|
|
return FEED_IN_ERROR;
|
|||
|
|
case 0x00010:
|
|||
|
|
return PAPER_JAM;
|
|||
|
|
case 0x00020:
|
|||
|
|
return DETECT_DOUBLE_FEED;
|
|||
|
|
case 0x00040:
|
|||
|
|
return DETECT_STAPLE;
|
|||
|
|
case 0x00080:
|
|||
|
|
return PAPER_SKEW;
|
|||
|
|
case 0x10000:
|
|||
|
|
return AQUIRE_IMAGE_TIMEOUT;
|
|||
|
|
case 0x20000:
|
|||
|
|
return SIZE_ERROR;
|
|||
|
|
default:
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (code.From == HGType::V4L2)
|
|||
|
|
{
|
|||
|
|
switch (code.Code)
|
|||
|
|
{
|
|||
|
|
case 0:
|
|||
|
|
return V4L2_AQULRE_ERROR;
|
|||
|
|
case 1:
|
|||
|
|
return V4L2_IMAGE_EMPTY;
|
|||
|
|
default:
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return 0;
|
|||
|
|
}
|