2023-04-08 00:56:20 +00:00
|
|
|
|
#include "imageusbhandler.h"
|
|
|
|
|
#include "opencv2/opencv.hpp"
|
|
|
|
|
#include "imgproc.h"
|
|
|
|
|
#include "stringex.hpp"
|
|
|
|
|
#include "memoryex.h"
|
|
|
|
|
#include "usbimageprocqueue.h"
|
|
|
|
|
#include "applog.h"
|
|
|
|
|
#include "StopWatch.h"
|
|
|
|
|
#include "jpeglib.h"
|
|
|
|
|
#include "imageencode.h"
|
|
|
|
|
#include <iostream>
|
|
|
|
|
#include "ImageApplyAutoCrop.h"
|
|
|
|
|
#include "hgutils.h"
|
2023-04-15 06:17:48 +00:00
|
|
|
|
#include "correct_ultis.h"
|
2023-04-08 00:56:20 +00:00
|
|
|
|
|
|
|
|
|
static const std::string loggername = "imageusbhandler";
|
|
|
|
|
|
|
|
|
|
ImageUsbHandler::ImageUsbHandler(std::shared_ptr<UsbImageProcQueue> images)
|
2023-04-15 06:17:48 +00:00
|
|
|
|
: pool(1), encodepools(6),pushpool(1), que_len_(0)
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
|
|
|
|
LOG_INIT();
|
|
|
|
|
this->images = images;
|
|
|
|
|
m_dog.reset(new CImageApplyDogEarDetection(40,1.0,50));
|
2023-04-15 06:17:48 +00:00
|
|
|
|
// m_colorcast.reset(new CImageApplyColorCastCorrect());
|
2023-04-08 00:56:20 +00:00
|
|
|
|
m_sizedetect.reset(new CSizedetect(1));
|
|
|
|
|
initLut();
|
|
|
|
|
auto info= jsonconfig().getscannerinfo();
|
|
|
|
|
H_ratio =*((float*)(&info.H_ratio));
|
|
|
|
|
V_ratio =*((float*)(&info.V_ratio));
|
2023-04-15 06:17:48 +00:00
|
|
|
|
}
|
|
|
|
|
ImageUsbHandler::~ImageUsbHandler()
|
|
|
|
|
{
|
|
|
|
|
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
|
|
|
|
static int num = 0;
|
2023-04-15 06:17:48 +00:00
|
|
|
|
void ImageUsbHandler::add_image(void *data, int width, int height, int type, int scannnum,std::uint32_t fpga_vs,CISVendor cistype)
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
printf("add_image(%u * %u)\n", width, height);
|
|
|
|
|
|
2023-04-08 00:56:20 +00:00
|
|
|
|
std::string ext = ".jpg";
|
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
if (m_imgstatus.status != NO_error)
|
|
|
|
|
return;
|
|
|
|
|
cv::Mat mat;
|
|
|
|
|
if(m_scanconfig.g200params.dpi == 3)
|
|
|
|
|
mat = cv::Mat(height, width, CV_8UC1, data);
|
2023-04-08 00:56:20 +00:00
|
|
|
|
else
|
2023-04-15 06:17:48 +00:00
|
|
|
|
mat = cv::Mat(height, width, CV_8UC1, data).clone();
|
|
|
|
|
capture_data.Put(mat);
|
2023-04-08 00:56:20 +00:00
|
|
|
|
StopWatch checktime;
|
2023-04-15 06:17:48 +00:00
|
|
|
|
if (m_hgimgconfig.is_dogeardetection || m_hgimgconfig.en_sizecheck)
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
cv::Mat tmp = cv::Mat(height, width, CV_8UC1, data);
|
|
|
|
|
if (tmp.empty())
|
|
|
|
|
return;
|
|
|
|
|
m_imgstatus.status = Img_Detecting;
|
|
|
|
|
#ifdef G300
|
|
|
|
|
auto mergemat = GetStitchMat(type == 16?1:0,width,height,tmp);
|
|
|
|
|
#else
|
|
|
|
|
auto mergemat = GetMergeMat(type == CV_8UC1 ? width : width / 3, height, type, tmp,0x90001);
|
|
|
|
|
#endif
|
|
|
|
|
if (m_scanconfig.g200params.dpi == 1)
|
|
|
|
|
cv::resize(mergemat, mergemat, cv::Size(0, 0), 200.0 / 300.0, 1.0);
|
|
|
|
|
else if (m_scanconfig.g200params.dpi == 2)
|
|
|
|
|
cv::resize(mergemat, mergemat, cv::Size(0, 0), 200.0 / 300.0, 200.0 / 300.0);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
#ifdef G200
|
|
|
|
|
cv::resize(mergemat,mergemat,cv::Size(0,0),200.0 / 600.0,1.43434/3); // 600 dpi <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʵ600<30>ɼ<EFBFBD>
|
|
|
|
|
#elif defined G300
|
|
|
|
|
cv::resize(mergemat,mergemat,cv::Size(0,0),200.0 / 600.0,1.432323/3);
|
|
|
|
|
#elif defined G400
|
|
|
|
|
cv::resize(mergemat,mergemat,cv::Size(0,0),200.0 / 600.0,1.5/3);
|
|
|
|
|
#else
|
|
|
|
|
cv::resize(mergemat,mergemat,cv::Size(0,0),200.0 / 600.0,1.432323/3);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (m_hgimgconfig.is_dogeardetection)
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
printf("\n is_dogeardetection");
|
2023-04-08 00:56:20 +00:00
|
|
|
|
if(!m_scanconfig.g200params.pc_correct)
|
|
|
|
|
correctColor(mergemat, false);
|
|
|
|
|
auto dogmat=mergemat(cv::Rect(mergemat.cols/2, 0, mergemat.cols/2, mergemat.rows));
|
|
|
|
|
m_dog->apply(dogmat,0);
|
|
|
|
|
if(m_dog->getResult())
|
|
|
|
|
{
|
|
|
|
|
m_imgstatus.status=Dog_error;
|
|
|
|
|
m_imgstatus.sannum=scannnum;
|
2023-04-15 06:17:48 +00:00
|
|
|
|
add_scanevent({.From=IMG,.Code=m_imgstatus.status,.Img_Index=m_imgstatus.sannum});
|
2023-04-08 00:56:20 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if(m_hgimgconfig.en_sizecheck)
|
|
|
|
|
{
|
|
|
|
|
auto sizemat=mergemat(cv::Rect(mergemat.cols/2, 0, mergemat.cols/2, mergemat.rows));
|
2023-04-15 06:17:48 +00:00
|
|
|
|
printf("\n en_sizecheck %d",m_scanconfig.g200params.paper);
|
2023-04-08 00:56:20 +00:00
|
|
|
|
m_sizedetect->SetPapertype(m_scanconfig.g200params.paper);
|
|
|
|
|
if(m_sizedetect->preprocess(sizemat,NULL))
|
|
|
|
|
{
|
|
|
|
|
m_imgstatus.status=Size_error;
|
|
|
|
|
m_imgstatus.sannum=scannnum;
|
2023-04-15 06:17:48 +00:00
|
|
|
|
add_scanevent({.From=IMG,.Code=m_imgstatus.status,.Img_Index=m_imgstatus.sannum});
|
2023-04-08 00:56:20 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-04-15 06:17:48 +00:00
|
|
|
|
m_imgstatus.status = NO_error;
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
2023-04-15 06:17:48 +00:00
|
|
|
|
//tmp.release();
|
|
|
|
|
|
|
|
|
|
//std::lock_guard<std::mutex> guard(mtx);
|
|
|
|
|
add_que_count();
|
2023-04-08 00:56:20 +00:00
|
|
|
|
results.emplace(
|
2023-04-15 06:17:48 +00:00
|
|
|
|
pool.enqueue([this, width, height, type, ext, scannnum, data,cistype]
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
printf("enqueue image index %d \n",scannnum);
|
2023-04-08 00:56:20 +00:00
|
|
|
|
StopWatch sw;
|
2023-04-15 06:17:48 +00:00
|
|
|
|
cv::Mat mat = capture_data.Take();
|
|
|
|
|
if(m_scanconfig.g200params.dpi == 3)
|
|
|
|
|
mat = cv::Mat(height, width, CV_8UC1, data);
|
|
|
|
|
else
|
|
|
|
|
mat = cv::Mat(height, width, CV_8UC1, data).clone();
|
|
|
|
|
capture_data.Put(mat);
|
|
|
|
|
#ifdef G300
|
|
|
|
|
cv::Mat saveMat = GetStitchMat(type == 16?1:0,width,height,mat);
|
|
|
|
|
#else
|
|
|
|
|
int dstwidth = type==CV_8UC1?width:width/3;
|
|
|
|
|
cv::Mat saveMat =GetMergeMat(dstwidth, height, type,mat,0x90001);
|
|
|
|
|
#endif
|
|
|
|
|
printf("\n GetMergeMat time %f \n",sw.elapsed_ms());
|
|
|
|
|
//cv::imwrite("/home/"+to_string(scannnum)+".png",saveMat);
|
|
|
|
|
int dpi = saveMat.cols==7344?2:3;
|
2023-04-08 00:56:20 +00:00
|
|
|
|
if(!m_scanconfig.g200params.pc_correct)
|
2023-04-15 06:17:48 +00:00
|
|
|
|
correctColor(saveMat,dpi,saveMat.channels()==3?1:0,!m_scanconfig.g200params.is_textcorrect);
|
|
|
|
|
printf("\n correctColor time %f \n",sw.elapsed_ms());
|
|
|
|
|
encode_data.Put(saveMat);
|
|
|
|
|
add_que_count();
|
|
|
|
|
encodeimgs.push(encodepools.enqueue([this,width,height,type,cistype]() -> std::vector<MemoryPtr>
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
auto saveMat = encode_data.Take();
|
|
|
|
|
if(H_ratio>1.2f ||H_ratio<0.8f)
|
|
|
|
|
H_ratio=1.0f;
|
|
|
|
|
if(V_ratio>1.2f || V_ratio <0.8f)
|
|
|
|
|
V_ratio=1.0f;
|
|
|
|
|
if(m_scanconfig.g200params.dpi==0x01)
|
|
|
|
|
{
|
|
|
|
|
cv::resize(saveMat,saveMat,cv::Size(0,0),200.0/300.0*H_ratio,1.0*V_ratio);
|
|
|
|
|
}
|
|
|
|
|
if(m_scanconfig.g200params.dpi == 2)
|
|
|
|
|
{
|
|
|
|
|
if((H_ratio != 1.0f) || (V_ratio != 1.0f))
|
|
|
|
|
cv::resize(saveMat,saveMat,cv::Size(),H_ratio,V_ratio);
|
|
|
|
|
}
|
|
|
|
|
if(m_scanconfig.g200params.dpi == 3)
|
|
|
|
|
#ifdef G200
|
|
|
|
|
cv::resize(saveMat,saveMat,cv::Size(0,0),1.0*H_ratio,1.43434*V_ratio); // 600 dpi <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʵ600<30>ɼ<EFBFBD>
|
|
|
|
|
#elif defined G300
|
|
|
|
|
cv::resize(saveMat,saveMat,cv::Size(0,0),1.0*H_ratio,1.432323*V_ratio);
|
|
|
|
|
#elif defined G400
|
|
|
|
|
cv::resize(saveMat,saveMat,cv::Size(0,0),1.0*H_ratio,1.5*V_ratio);
|
|
|
|
|
#else
|
|
|
|
|
cv::resize(saveMat,saveMat,cv::Size(0,0),1.0*H_ratio,1.432323*V_ratio);
|
|
|
|
|
#endif
|
|
|
|
|
cv::Mat imageMat;
|
|
|
|
|
std::vector<cv::Mat> imgs;
|
|
|
|
|
int actwidth = saveMat.cols / 2;
|
|
|
|
|
int actheight = saveMat.rows;
|
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
|
|
|
{
|
|
|
|
|
imageMat = saveMat(cv::Rect(i * actwidth, 0, actwidth, actheight));
|
|
|
|
|
if (!imageMat.empty())
|
|
|
|
|
{
|
|
|
|
|
imgs.push_back(imageMat);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// cv::imwrite("/home/proc.jpg",saveMat);
|
|
|
|
|
imgs.push_back(saveMat);
|
2023-04-08 00:56:20 +00:00
|
|
|
|
std::shared_ptr<IImageEncode> imageencode; //(new BmpImageEncode());
|
|
|
|
|
std::vector<MemoryPtr> encodedata;
|
2023-04-15 06:17:48 +00:00
|
|
|
|
bool iscorrect_mode =true;
|
|
|
|
|
if(!iscorrect_mode)
|
|
|
|
|
//if (!m_scanconfig.g200params.iscorrect_mode)
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
if (!m_hgimgconfig.is_switchfrontback && (imgs.size() > 1))
|
2023-04-08 00:56:20 +00:00
|
|
|
|
std::swap(imgs[0], imgs[1]);
|
2023-04-15 06:17:48 +00:00
|
|
|
|
CImageApply* ptr = m_ials[0].get();
|
|
|
|
|
if (typeid(*ptr) != typeid(CImageApplyOutHole)){
|
|
|
|
|
if(m_hgimgconfig.imageRotateDegree != 0.0 && m_hgimgconfig.imageRotateDegree != 180.0 && (imgs.size() > 1))
|
|
|
|
|
{
|
|
|
|
|
cv::flip(imgs[1], imgs[1], 0);
|
|
|
|
|
cv::flip(imgs[1], imgs[1], 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
for (auto &ialsnode : m_ials)
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
ialsnode->apply(imgs, bool(m_hgimgconfig.is_duplex));
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-15 06:17:48 +00:00
|
|
|
|
if ((!m_hgimgconfig.is_duplex) && (imgs.size() > 1))
|
2023-04-08 00:56:20 +00:00
|
|
|
|
imgs.pop_back();
|
2023-04-15 06:17:48 +00:00
|
|
|
|
else if((imgs.size() > 1) && (cistype == CISVendor::HUALIN_CIS_V0))
|
|
|
|
|
cv::flip(imgs[1], imgs[1], 0);
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (auto &img : imgs)
|
|
|
|
|
{
|
|
|
|
|
cv::Mat enMat = img;
|
2023-04-15 06:17:48 +00:00
|
|
|
|
if (!(enMat.empty() && (m_hgimgconfig.is_autodiscradblank_normal || m_hgimgconfig.is_autodiscradblank_vince)))
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
if(m_hgimgconfig.fadeback!=0)
|
|
|
|
|
{
|
|
|
|
|
if(enMat.channels()==3&&m_hgimgconfig.pixtype==1)
|
|
|
|
|
cv::cvtColor(enMat,enMat,cv::COLOR_BGR2GRAY);
|
|
|
|
|
}
|
2023-04-08 00:56:20 +00:00
|
|
|
|
if(m_scanconfig.g200params.iscorrect_mode)
|
|
|
|
|
imageencode.reset(new JpegImageEncode(false));
|
|
|
|
|
else
|
2023-04-15 06:17:48 +00:00
|
|
|
|
imageencode.reset(new JpegImageEncode(false));
|
2023-04-08 00:56:20 +00:00
|
|
|
|
encodedata.push_back(imageencode->encode(enMat));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return encodedata;
|
2023-04-15 06:17:48 +00:00
|
|
|
|
}));
|
|
|
|
|
pushpool.enqueue([this]{
|
|
|
|
|
auto mem = encodeimgs.front().get();
|
|
|
|
|
encodeimgs.pop();
|
|
|
|
|
if (!mem.empty())
|
|
|
|
|
{
|
|
|
|
|
for (auto &data : mem)
|
|
|
|
|
{
|
|
|
|
|
if (data.get())
|
|
|
|
|
images->push(data, true);
|
|
|
|
|
else
|
|
|
|
|
add_scanevent({.From = V4L2, .Code = 1});
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
add_que_count(-1);
|
|
|
|
|
});
|
|
|
|
|
printf("imgproce time = %f \n", sw.elapsed_ms());
|
|
|
|
|
LOG_TRACE(string_format("imgproce time = %f\n", sw.elapsed_ms())); }));
|
|
|
|
|
add_que_count(-1);
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
2023-04-15 06:17:48 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool ImageUsbHandler::is_limit(){
|
|
|
|
|
if (m_hgimgconfig.resolution_dst > 200.0 || m_hgimgconfig.papertype == 52 || m_hgimgconfig.papertype == 54 ||
|
|
|
|
|
m_hgimgconfig.papertype == 131)
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
while (results.size() >= (m_scanconfig.g200params.dpi == 3 ? 1 : 2))
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
|
|
|
|
results.front().get();
|
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
//std::lock_guard<std::mutex> guard(mtx);
|
2023-04-08 00:56:20 +00:00
|
|
|
|
results.pop();
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-04-15 06:17:48 +00:00
|
|
|
|
if (encodeimgs.size() >= (m_scanconfig.g200params.dpi == 3 ? 1 : 2))
|
|
|
|
|
{
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
2023-04-15 06:17:48 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
while (results.size() >= 20)
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
|
|
|
|
results.front().get();
|
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
//std::lock_guard<std::mutex> guard(mtx);
|
2023-04-08 00:56:20 +00:00
|
|
|
|
results.pop();
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-04-15 06:17:48 +00:00
|
|
|
|
if (encodeimgs.size() >= 20)
|
|
|
|
|
{
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
2023-04-15 06:17:48 +00:00
|
|
|
|
return false;
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-15 06:17:48 +00:00
|
|
|
|
|
|
|
|
|
void ImageUsbHandler::thread_push_stop_event(HGIntInfo ev)
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
printf("Received STOPSCAN event, but image-process is busying, wait real stop in thread ...\n");
|
|
|
|
|
while(!done())
|
|
|
|
|
{
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(3));
|
|
|
|
|
}
|
|
|
|
|
push_event(ev);
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
2023-04-15 06:17:48 +00:00
|
|
|
|
void ImageUsbHandler::push_event(HGIntInfo ev)
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
|
|
|
|
VectorMemroyPtr mem = VectorMemroyPtr(new VectorMemroy());
|
2023-04-15 06:17:48 +00:00
|
|
|
|
HGIntInfo info = ev;
|
2023-04-08 00:56:20 +00:00
|
|
|
|
mem->resize(sizeof(info));
|
|
|
|
|
memcpy(&mem->buf()[0], &info, sizeof(info));
|
|
|
|
|
images->push(mem, false);
|
|
|
|
|
}
|
2023-04-15 06:17:48 +00:00
|
|
|
|
int32_t ImageUsbHandler::add_que_count(int adden)
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(proc_que_);
|
|
|
|
|
|
|
|
|
|
que_len_ += adden;
|
|
|
|
|
|
|
|
|
|
return que_len_;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ImageUsbHandler::add_scanevent(HGIntInfo status)
|
|
|
|
|
{
|
|
|
|
|
printf("add_scanevent(%d)\n", status.From);
|
|
|
|
|
if(status.From == STOPSCAN && !done())
|
|
|
|
|
{
|
|
|
|
|
if(stop_event_thread_.get() && stop_event_thread_->joinable())
|
|
|
|
|
stop_event_thread_->join();
|
|
|
|
|
stop_event_thread_.reset(new std::thread(&ImageUsbHandler::thread_push_stop_event, this, status));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
push_event(status);
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-04-08 00:56:20 +00:00
|
|
|
|
|
|
|
|
|
void ImageUsbHandler::clear()
|
|
|
|
|
{
|
|
|
|
|
if (images.get())
|
2023-04-15 06:17:48 +00:00
|
|
|
|
images->clear();
|
|
|
|
|
while (results.size() > 0)
|
2023-04-08 00:56:20 +00:00
|
|
|
|
results.pop();
|
2023-04-15 06:17:48 +00:00
|
|
|
|
while (encodeimgs.size() > 0)
|
|
|
|
|
encodeimgs.pop();
|
|
|
|
|
capture_data.Clear();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ImageUsbHandler::Set_ratio(u32 h_ratio,u32 v_ratio)
|
|
|
|
|
{
|
|
|
|
|
H_ratio =*((float*)(&h_ratio));
|
|
|
|
|
//V_ratio =*((float*)(&v_ratio));
|
|
|
|
|
V_ratio = 1.0f;
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool ImageUsbHandler::done()
|
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
return add_que_count(0) == 0;
|
|
|
|
|
|
|
|
|
|
bool over = true;
|
2023-04-08 00:56:20 +00:00
|
|
|
|
{
|
2023-04-15 06:17:48 +00:00
|
|
|
|
std::lock_guard<std::mutex> guard(mtx);
|
|
|
|
|
if(results.size() >= 1){
|
|
|
|
|
auto &fu_run = results.back();
|
|
|
|
|
if((fu_run.valid() && (fu_run.wait_for(std::chrono::seconds(0)) != std::future_status::ready)))
|
|
|
|
|
over = false;
|
|
|
|
|
}
|
|
|
|
|
if(over && encodeimgs.size()>=1)
|
|
|
|
|
{
|
|
|
|
|
auto &fu_encode = encodeimgs.back();
|
|
|
|
|
over = !fu_encode.valid() || encodeimgs.size() == 0;
|
|
|
|
|
// if((!fu_encode.valid()) && encodeimgs.size() == 1)
|
|
|
|
|
// over = true;
|
|
|
|
|
// else
|
|
|
|
|
// over = false;
|
|
|
|
|
// return !(fu_encode.wait_for(std::chrono::seconds(0)) != std::future_status::ready);
|
|
|
|
|
//return (!(fu_run.wait_for(std::chrono::seconds(0)) != std::future_status::ready))&&(!(fu_encode.wait_for(std::chrono::seconds(0)) != std::future_status::ready));
|
|
|
|
|
}
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
2023-04-15 06:17:48 +00:00
|
|
|
|
|
|
|
|
|
return over;
|
2023-04-08 00:56:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ImageUsbHandler::config_procparams(HGImgProcParms params)
|
|
|
|
|
{
|
|
|
|
|
LOG_TRACE("****ImageUsbHandler config_procparams****\n");
|
|
|
|
|
LOG_TRACE(string_format("HGImgProcParms.value = %d \n", params.value));
|
|
|
|
|
LOG_TRACE(string_format("HGImgProcParms.papertype = %d HGImgProcParms.scanside = %d \n", params.imgprocparams.papertype, params.imgprocparams.scanside));
|
|
|
|
|
LOG_TRACE(string_format("HGImgProcParms.res = %d HGImgProcParms.rotate = %d \n", params.imgprocparams.res, params.imgprocparams.rotate));
|
|
|
|
|
LOG_TRACE(string_format("HGImgProcParms.autodescrew = %d HGImgProcParms.fillbackground = %d \n", params.imgprocparams.autodescrew, params.imgprocparams.fillbackground));
|
|
|
|
|
LOG_TRACE(string_format("HGImgProcParms.filter = %d HGImgProcParms.enhancecolor = %d \n", params.imgprocparams.filter, params.imgprocparams.enhancecolor));
|
|
|
|
|
LOG_TRACE(string_format("HGImgProcParms.fillhole = %d \n", params.imgprocparams.fillhole));
|
|
|
|
|
m_procparams = params;
|
2023-04-15 06:17:48 +00:00
|
|
|
|
}
|