lmh188
/
code_device
mirror of http://192.168.10.5:8099/sane/code_device.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

新增tesseract文字方向识别 调整整个图像处理流程

This commit is contained in:
13038267101 2022-11-01 17:20:57 +08:00
parent e5ccb09174
commit d5d27bd93c
18 changed files with 273 additions and 1273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
hgdriver/hgdev/hg_scanner.cpp
View File

@ -146,6 +146,7 @@ hg_scanner::hg_scanner(ScannerSerial serial
wait_usb_result_.set_debug_info("start"); wait_usb_result_.set_debug_info("start");
thread_usb_read_.reset(new std::thread(&hg_scanner::thread_handle_usb, this)); thread_usb_read_.reset(new std::thread(&hg_scanner::thread_handle_usb, this));
thread_img_handle_.reset(new std::thread(&hg_scanner::thread_image_handle, this)); thread_img_handle_.reset(new std::thread(&hg_scanner::thread_image_handle, this));
ImagePrc_pHandle_ = hg_imgproc::init(pid_);;
} }
hg_scanner::~hg_scanner() hg_scanner::~hg_scanner()
{ {
@ -156,6 +157,7 @@ hg_scanner::~hg_scanner()
if (thread_img_handle_.get() && thread_img_handle_->joinable()) if (thread_img_handle_.get() && thread_img_handle_->joinable())
thread_img_handle_->join(); thread_img_handle_->join();
delete custom_gamma_val_; delete custom_gamma_val_;
hg_imgproc::release(ImagePrc_pHandle_);
name_.insert(0, "\350\256\276\345\244\207\342\200\234"); name_.insert(0, "\350\256\276\345\244\207\342\200\234");
name_ += "\342\200\235\345\267\262\347\273\217\345\205\263\351\227\255\343\200\202"; name_ += "\342\200\235\345\267\262\347\273\217\345\205\263\351\227\255\343\200\202";
@ -769,7 +771,17 @@ void hg_scanner::thread_handle_image_process(void)
{ {
try try
{ {
image_process(tiny_buffer); if (ImagePrc_pHandle_)
{
image_process(tiny_buffer);
}
else
{
VLOG_MINI_1(LOG_LEVEL_FATAL, "Get Image Process is NULL pid is %d.\n",pid_);
status_ = SCANNER_ERR_INSUFFICIENT_MEMORY;
stop();
break;
}
} }
catch (...) catch (...)
{ {
@ -1892,9 +1904,17 @@ int hg_scanner::setting_text_direction(int sn, void* data)
VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change text direction from '%s' to '%s' = %s\n", text_direction_string(image_prc_param_.bits.text_direction).c_str() VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change text direction from '%s' to '%s' = %s\n", text_direction_string(image_prc_param_.bits.text_direction).c_str()
, (char*)data, hg_scanner_err_name(ret)); , (char*)data, hg_scanner_err_name(ret));
image_prc_param_.bits.text_direction = match_best_text_direction(str, NULL); image_prc_param_.bits.text_direction = match_best_text_direction(str, NULL);
if (!exact) if (!exact)
strcpy((char*)data, str.c_str()); strcpy((char*)data, str.c_str());
if (image_prc_param_.bits.text_direction == TEXT_DIRECTION_AUTO && ImagePrc_pHandle_)
{
hg_imgproc::init_auto_txt_hanld(ImagePrc_pHandle_);
}
else if (image_prc_param_.bits.text_direction != TEXT_DIRECTION_AUTO && ImagePrc_pHandle_)
{
hg_imgproc::free_auto_txt_hanld(ImagePrc_pHandle_);
}
return ret; return ret;
} }
int hg_scanner::setting_rotate_bkg_180(int sn, void* data) int hg_scanner::setting_rotate_bkg_180(int sn, void* data)
@ -2314,7 +2334,7 @@ void hg_scanner::adjust_color(hg_imgproc::HIMGPRC handle)
} }
hg_imgproc::adjust_color(handle, buffer1, tableLength); hg_imgproc::adjust_color(handle, buffer1, tableLength);
} }
hg_imgproc::HIMGPRC hg_scanner::get_image_process_object(int model) hg_imgproc::IMGPRCPARAM hg_scanner::get_image_process_object(int model)
{ {
hg_imgproc::IMGPRCPARAM param; hg_imgproc::IMGPRCPARAM param;
hg_imgproc::HIMGPRC handle = nullptr; hg_imgproc::HIMGPRC handle = nullptr;
@ -2331,11 +2351,10 @@ hg_imgproc::HIMGPRC hg_scanner::get_image_process_object(int model)
img_conf_.brightness = (float)bright_; img_conf_.brightness = (float)bright_;
img_conf_.contrast = (float)contrast_; img_conf_.contrast = (float)contrast_;
handle = hg_imgproc::init(&img_conf_, &param, model);
img_conf_.brightness = bright; img_conf_.brightness = bright;
img_conf_.contrast = contrast; img_conf_.contrast = contrast;
return handle; return param;
} }
SANE_Image_Statu hg_scanner::last_usb_image_statu(int err) SANE_Image_Statu hg_scanner::last_usb_image_statu(int err)
{ {
@ -3597,71 +3616,75 @@ int hg_scanner::get_scan_is_sleep(void)
void hg_scanner::image_process(std::shared_ptr<tiny_buffer>& buffer) void hg_scanner::image_process(std::shared_ptr<tiny_buffer>& buffer)
{ {
if (!buffer.get() || !ImagePrc_pHandle_)
{
return;
}
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
hg_imgproc::HIMGPRC handle = get_image_process_object(pid_); hg_imgproc::IMGPRCPARAM param = get_image_process_object(pid_);
hg_imgproc::IMGHEAD ih; hg_imgproc::IMGHEAD ih;
int err = SCANNER_ERR_OK, int err = SCANNER_ERR_OK,
index = 0; index = 0;
void* buf = NULL; void* buf = NULL;
hg_imgproc::load_buffer(handle, buffer); hg_imgproc::load_buffer(ImagePrc_pHandle_, buffer);
hg_imgproc::decode(handle, pid_); hg_imgproc::decode(ImagePrc_pHandle_, pid_, &img_conf_, &param);
(this->*dump_img_)(handle, "decode"); (this->*dump_img_)(ImagePrc_pHandle_, "decode");
if ((isremove_left_hole || isremove_right_hole || isremove_top_hole || isremove_low_hole) && (pid_ != 0x239 && pid_ != 0x439)) if ((isremove_left_hole || isremove_right_hole || isremove_top_hole || isremove_low_hole) && (pid_ != 0x239 && pid_ != 0x439))
{ {
ret = hg_imgproc::fillhole(handle, isremove_top_hole_threshold, isremove_low_hole_threshold, isremove_left_hole_threshold, isremove_right_hole_threshold); ret = hg_imgproc::fillhole(ImagePrc_pHandle_, isremove_top_hole_threshold, isremove_low_hole_threshold, isremove_left_hole_threshold, isremove_right_hole_threshold);
(this->*dump_img_)(handle, "fillhole"); (this->*dump_img_)(ImagePrc_pHandle_, "fillhole");
} }
if (pid_ != 0x239 && pid_ != 0x439) if (pid_ != 0x239 && pid_ != 0x439)
{ {
ret = hg_imgproc::auto_crop(handle); ret = hg_imgproc::auto_crop(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "auto_crop"); (this->*dump_img_)(ImagePrc_pHandle_, "auto_crop");
} }
if ((img_conf_.is_autodiscradblank_normal || img_conf_.is_autodiscradblank_vince) && (pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.is_autodiscradblank_normal || img_conf_.is_autodiscradblank_vince) && (pid_ != 0x239 && pid_ != 0x439))
{ {
ret = hg_imgproc::discardBlank(handle); ret = hg_imgproc::discardBlank(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "discardBlank"); (this->*dump_img_)(ImagePrc_pHandle_, "discardBlank");
} }
if (img_conf_.fadeback) //239 if (img_conf_.fadeback) //239
{ {
hg_imgproc::fadeback(handle); hg_imgproc::fadeback(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "fadeback"); (this->*dump_img_)(ImagePrc_pHandle_, "fadeback");
} }
if ((img_conf_.resolution_dst != img_conf_.resolution_native) && (pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.resolution_dst != img_conf_.resolution_native) && (pid_ != 0x239 && pid_ != 0x439))
{ {
hg_imgproc::resolution_change(handle); hg_imgproc::resolution_change(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "resolution_change"); (this->*dump_img_)(ImagePrc_pHandle_, "resolution_change");
} }
if ((img_conf_.cropRect.enable && !img_conf_.is_autocrop) && (pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.cropRect.enable && !img_conf_.is_autocrop) && (pid_ != 0x239 && pid_ != 0x439))
{ {
hg_imgproc::croprect(handle); hg_imgproc::croprect(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "resolution_change"); (this->*dump_img_)(ImagePrc_pHandle_, "resolution_change");
} }
if ((img_conf_.filter != ColorFilter::FILTER_NONE && (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE || img_conf_.pixtype == COLOR_MODE_256_GRAY)) && (pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.filter != ColorFilter::FILTER_NONE && (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE || img_conf_.pixtype == COLOR_MODE_256_GRAY)) && (pid_ != 0x239 && pid_ != 0x439))
{ {
hg_imgproc::channel(handle); hg_imgproc::channel(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "channel"); (this->*dump_img_)(ImagePrc_pHandle_, "channel");
} }
if (pid_ != 0x239 && pid_ != 0x439) if (pid_ != 0x239 && pid_ != 0x439)
{ {
adjust_color(handle); adjust_color(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "channel"); (this->*dump_img_)(ImagePrc_pHandle_, "channel");
} }
if ((img_conf_.pixtype == COLOR_MODE_24_BITS && img_conf_.hsvcorrect) && (pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.pixtype == COLOR_MODE_24_BITS && img_conf_.hsvcorrect) && (pid_ != 0x239 && pid_ != 0x439))
{ {
hg_imgproc::answerSheetFilterRed(handle); hg_imgproc::answerSheetFilterRed(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "answerSheetFilterRed"); (this->*dump_img_)(ImagePrc_pHandle_, "answerSheetFilterRed");
} }
if ((img_conf_.refuseInflow) && (pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.refuseInflow) && (pid_ != 0x239 && pid_ != 0x439))
@ -3679,95 +3702,96 @@ void hg_scanner::image_process(std::shared_ptr<tiny_buffer>& buffer)
else if (image_prc_param_.bits.is_permeate_lv_ == 4) else if (image_prc_param_.bits.is_permeate_lv_ == 4)
lv = 45; lv = 45;
hg_imgproc::antiInflow(handle, lv); hg_imgproc::antiInflow(ImagePrc_pHandle_, lv);
(this->*dump_img_)(handle, "antiInflow"); (this->*dump_img_)(ImagePrc_pHandle_, "antiInflow");
} }
if ((img_conf_.colorCorrection && img_conf_.pixtype != COLOR_MODE_BLACK_WHITE) && (pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.colorCorrection && img_conf_.pixtype != COLOR_MODE_BLACK_WHITE) && (pid_ != 0x239 && pid_ != 0x439))
{ {
hg_imgproc::colorCorrection(handle); hg_imgproc::colorCorrection(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "colorCorrection"); (this->*dump_img_)(ImagePrc_pHandle_, "colorCorrection");
} }
if (((img_conf_.imageRotateDegree != TEXT_DIRECTION_0 || img_conf_.is_backrotate180) && (!img_conf_.is_autotext)) && (pid_ != 0x239 && pid_ != 0x439)) if (((img_conf_.imageRotateDegree != TEXT_DIRECTION_0 || img_conf_.is_backrotate180) && (!img_conf_.is_autotext)) && (pid_ != 0x239 && pid_ != 0x439))
{ {
hg_imgproc::orentation(handle); hg_imgproc::orentation(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "orentation"); (this->*dump_img_)(ImagePrc_pHandle_, "orentation");
} }
if ((img_conf_.removeMorr) && (pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.removeMorr) && (pid_ != 0x239 && pid_ != 0x439))
{ {
hg_imgproc::textureRemove(handle); hg_imgproc::textureRemove(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "textureRemove"); (this->*dump_img_)(ImagePrc_pHandle_, "textureRemove");
} }
if ((img_conf_.detachnoise.is_detachnoise) && (pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.detachnoise.is_detachnoise) && (pid_ != 0x239 && pid_ != 0x439))
{ {
hg_imgproc::nosieDetach(handle); hg_imgproc::nosieDetach(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "nosieDetach"); (this->*dump_img_)(ImagePrc_pHandle_, "nosieDetach");
} }
if ((img_conf_.pixtype == COLOR_MODE_BLACK_WHITE) && (pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.pixtype == COLOR_MODE_BLACK_WHITE) && (pid_ != 0x239 && pid_ != 0x439))
{ {
hg_imgproc::errorextention(handle); hg_imgproc::errorextention(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "errorextention"); (this->*dump_img_)(ImagePrc_pHandle_, "errorextention");
} }
if ((img_conf_.en_fold && pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.en_fold && pid_ != 0x239 && pid_ != 0x439))
{ {
hg_imgproc::fold(handle); hg_imgproc::fold(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "fold"); (this->*dump_img_)(ImagePrc_pHandle_, "fold");
} }
if (img_conf_.multi_output_red && img_conf_.pixtype == COLOR_MODE_24_BITS)//239 if (img_conf_.multi_output_red && img_conf_.pixtype == COLOR_MODE_24_BITS)//239
{ {
err = hg_imgproc::multi_out_red(handle); err = hg_imgproc::multi_out_red(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "multi_out_red"); (this->*dump_img_)(ImagePrc_pHandle_, "multi_out_red");
} }
if ((img_conf_.sharpen) && (pid_ != 0x239 && pid_ != 0x439)) if ((img_conf_.sharpen) && (pid_ != 0x239 && pid_ != 0x439))
{ {
hg_imgproc::sharpenType(handle); hg_imgproc::sharpenType(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "sharpenType"); (this->*dump_img_)(ImagePrc_pHandle_, "sharpenType");
} }
if (image_prc_param_.bits.split) //239 if (image_prc_param_.bits.split) //239
{ {
split3399_++; split3399_++;
err = hg_imgproc::split(handle,split3399_); err = hg_imgproc::split(ImagePrc_pHandle_,split3399_);
(this->*dump_img_)(handle, "split"); (this->*dump_img_)(ImagePrc_pHandle_, "split");
} }
if (!img_conf_.splitImage || !img_conf_.multi_output_red || !is_multiout) //239 if (!img_conf_.splitImage || !img_conf_.multi_output_red || !is_multiout) //239
{ {
if (img_conf_.automaticcolor) if (img_conf_.automaticcolor)
{ {
hg_imgproc::auto_matic_color(handle, img_conf_.automaticcolortype); hg_imgproc::auto_matic_color(ImagePrc_pHandle_, img_conf_.automaticcolortype);
(this->*dump_img_)(handle, "auto_matic_color"); (this->*dump_img_)(ImagePrc_pHandle_, "auto_matic_color");
} }
} }
if (img_conf_.is_autotext)//239 if (img_conf_.is_autotext)//239
{ {
hg_imgproc::ocr_auto_txtdirect(handle); //hg_imgproc::ocr_auto_txtdirect(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "ocr_auto_txtdirect"); hg_imgproc::tesseract_auto_txtdirect(ImagePrc_pHandle_);
(this->*dump_img_)(ImagePrc_pHandle_, "ocr_auto_txtdirect");
} }
if ((is_quality_ == IMG_SPEED && (pid_ == 0x239 || pid_ == 0x439)) && resolution_ >= 300)//239 if ((is_quality_ == IMG_SPEED && (pid_ == 0x239 || pid_ == 0x439)) && resolution_ >= 300)//239
{ {
err = hg_imgproc::quality(handle, resolution_); err = hg_imgproc::quality(ImagePrc_pHandle_, resolution_);
(this->*dump_img_)(handle, "quality"); (this->*dump_img_)(ImagePrc_pHandle_, "quality");
} }
if (is_multiout)//239 if (is_multiout)//239
{ {
int multi_out = img_conf_.multiOutput; int multi_out = img_conf_.multiOutput;
err = hg_imgproc::multi_out(handle, multi_out); err = hg_imgproc::multi_out(ImagePrc_pHandle_, multi_out);
(this->*dump_img_)(handle, "multi_out"); (this->*dump_img_)(ImagePrc_pHandle_, "multi_out");
} }
hg_imgproc::final(handle); hg_imgproc::final(ImagePrc_pHandle_);
(this->*dump_img_)(handle, "final"); (this->*dump_img_)(ImagePrc_pHandle_, "final");
while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK) while (hg_imgproc::get_final_data(ImagePrc_pHandle_, &ih, &buf, index++) == SCANNER_ERR_OK)
{ {
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes); , ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
@ -3776,7 +3800,7 @@ void hg_scanner::image_process(std::shared_ptr<tiny_buffer>& buffer)
{ {
std::vector<unsigned char>bmpdata; std::vector<unsigned char>bmpdata;
//cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata); //cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata);
hg_imgproc::imgtypechange(handle, img_type_, buf, bmpdata); hg_imgproc::imgtypechange(ImagePrc_pHandle_, img_type_, buf, bmpdata);
if (bmpdata.empty()) if (bmpdata.empty())
{ {
status_ = SCANNER_ERR_NO_DATA; status_ = SCANNER_ERR_NO_DATA;
@ -3790,5 +3814,4 @@ void hg_scanner::image_process(std::shared_ptr<tiny_buffer>& buffer)
} }
save_final_image(&ih, buf); save_final_image(&ih, buf);
} }
hg_imgproc::release(handle);
} }

4
hgdriver/hgdev/hg_scanner.h
View File

@ -194,9 +194,9 @@ protected:
// adjust color or apply custom gamma // adjust color or apply custom gamma
void adjust_color(hg_imgproc::HIMGPRC handle); void adjust_color(hg_imgproc::HIMGPRC handle);
hg_imgproc::HIMGPRC get_image_process_object(int model); hg_imgproc::IMGPRCPARAM get_image_process_object(int model);
SANE_Image_Statu last_usb_image_statu(int err); SANE_Image_Statu last_usb_image_statu(int err);
hg_imgproc::HIMGPRC ImagePrc_pHandle_;
protected: protected:
ScannerSerial serial_; ScannerSerial serial_;
volatile bool run_; volatile bool run_;

178
hgdriver/hgdev/hg_scanner_200.cpp
View File

@ -413,184 +413,6 @@ int hg_scanner_200::get_img_data(unsigned int bytes, SANE_Image_Statu statu)
return ret; return ret;
} }
void hg_scanner_200::image_process(std::shared_ptr<tiny_buffer>& buffer)
{
int ret = SCANNER_ERR_OK;
hg_imgproc::HIMGPRC handle = get_image_process_object(pid_);
hg_imgproc::IMGHEAD ih;
int err = SCANNER_ERR_OK,
index = 0;
void* buf = NULL;
hg_imgproc::load_buffer(handle, buffer);
hg_imgproc::decode(handle,pid_);
if (isremove_left_hole || isremove_right_hole || isremove_top_hole || isremove_low_hole)
{
ret = hg_imgproc::fillhole(handle, isremove_top_hole_threshold, isremove_low_hole_threshold,isremove_left_hole_threshold,isremove_right_hole_threshold);
}
/////////////////////////////////////111111111111111111111111111//////////////////////////////////
ret = hg_imgproc::auto_crop(handle);
if (img_conf_.is_autodiscradblank_normal || img_conf_.is_autodiscradblank_vince)
{
ret = hg_imgproc::discardBlank(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"丢弃空白页开启\r\n");
}
if(img_conf_.fadeback)
{
hg_imgproc::fadeback(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"背景除色开启\r\n");
}
if (img_conf_.resolution_dst != img_conf_.resolution_native)
{
hg_imgproc::resolution_change(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"dpi改变开启\r\n");
}
if (img_conf_.cropRect.enable && !img_conf_.is_autocrop)
{
hg_imgproc::croprect(handle);
//printf("手动裁图开启\r\n");
}
if (img_conf_.filter != ColorFilter::FILTER_NONE && (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE || img_conf_.pixtype == COLOR_MODE_256_GRAY))
{
hg_imgproc::channel(handle);
//printf("除色开启\r\n");
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"除色开启\r\n");
}
/////////////////////////////////////2222222222222222222222222222222222222//////////////////////////////////
adjust_color(handle);
if (img_conf_.pixtype == COLOR_MODE_24_BITS && img_conf_.hsvcorrect)
{
hg_imgproc::answerSheetFilterRed(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"答题卡出红开启\r\n");
}
if (img_conf_.refuseInflow)
{
int lv = 5;
if (image_prc_param_.bits.is_permeate_lv_ == 0)
lv = 5;
else if (image_prc_param_.bits.is_permeate_lv_ == 1)
lv = 15;
else if (image_prc_param_.bits.is_permeate_lv_ == 2)
lv = 25;
else if (image_prc_param_.bits.is_permeate_lv_ == 3)
lv = 35;
else if (image_prc_param_.bits.is_permeate_lv_ == 4)
lv = 45;
hg_imgproc::antiInflow(handle,lv);
}
if (img_conf_.colorCorrection && img_conf_.pixtype != COLOR_MODE_BLACK_WHITE)
{
hg_imgproc::colorCorrection(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"颜色校正开启\r\n");
}
if ((img_conf_.imageRotateDegree != TEXT_DIRECTION_0 || img_conf_.is_backrotate180) && (!img_conf_.is_autotext))
{
hg_imgproc::orentation(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"自动旋转开启\r\n");
}
if (img_conf_.removeMorr)
{
hg_imgproc::textureRemove(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"除摩尔纹开启\r\n");
}
if (img_conf_.detachnoise.is_detachnoise)
{
hg_imgproc::nosieDetach(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"噪点优化开启\r\n");
}
if (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE)
{
hg_imgproc::errorextention(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"黑白图处理开启\r\n");
}
if (img_conf_.en_fold)
{
hg_imgproc::fold(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"对折开启\r\n");
}
///////////////////////////////////
if (img_conf_.multi_output_red && img_conf_.pixtype == COLOR_MODE_24_BITS)
{
err = hg_imgproc::multi_out_red(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"多流出红开启\r\n");
}
if (img_conf_.sharpen)
{
hg_imgproc::sharpenType(handle);
}
if (img_conf_.splitImage)
{
int colormode=1;
if(img_conf_.filter == RID_COLOR_NONE)
colormode=img_conf_.pixtype;
err = hg_imgproc::split(handle,-1);
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n"
,img_conf_.multiOutput
,img_conf_.splitImage
,img_conf_.multi_output_red
,img_conf_.pixtype
,img_conf_.is_duplex);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"图像拆分开启\r\n");
}
if (!img_conf_.splitImage || !img_conf_.multi_output_red || !is_multiout)
{
if(img_conf_.automaticcolor)
{
hg_imgproc::auto_matic_color(handle,img_conf_.automaticcolortype);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"颜色自动识别开启\r\n");
}
}
if (img_conf_.is_autotext)
{
printf("文本方向自动识别\r\n");
hg_imgproc::ocr_auto_txtdirect(handle);
}
//多流输出最后处理
if (is_multiout)
{
int multi_out = image_prc_param_.bits.multi_out;
err = hg_imgproc::multi_out(handle,multi_out);
}
hg_imgproc::final(handle);
while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK)
{
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
std::vector<unsigned char>bmpdata;
if(!img_type_.empty())
{
hg_imgproc::imgtypechange(handle, img_type_, buf, bmpdata);
//cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata);
if(bmpdata.empty())
{
status_ = SCANNER_ERR_NO_DATA;
return ;
}
buf = bmpdata.data();
ih.total_bytes = bmpdata.size();
VLOG_MINI_6(LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n",img_type_.c_str() ,index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
}
save_final_image(&ih, buf);
}
hg_imgproc::release(handle);
}
int hg_scanner_200::writedown_device_configuration(bool type,setting_hardware::HGSCANCONF_DSP *d) int hg_scanner_200::writedown_device_configuration(bool type,setting_hardware::HGSCANCONF_DSP *d)
{ {

1
hgdriver/hgdev/hg_scanner_200.h
View File

@ -26,7 +26,6 @@ class hg_scanner_200 : public hg_scanner
protected: protected:
virtual int on_scanner_closing(bool force) override; virtual int on_scanner_closing(bool force) override;
virtual void thread_handle_usb_read(void) override; virtual void thread_handle_usb_read(void) override;
virtual void image_process(std::shared_ptr<tiny_buffer>& buff) ;
virtual int on_color_mode_changed(int& color_mode); // COLOR_MODE_xxx virtual int on_color_mode_changed(int& color_mode); // COLOR_MODE_xxx

87
hgdriver/hgdev/hg_scanner_239.cpp
View File

File diff suppressed because one or more lines are too long

1
hgdriver/hgdev/hg_scanner_239.h
View File

@ -77,7 +77,6 @@ protected:
virtual void on_device_reconnected(void) override; virtual void on_device_reconnected(void) override;
virtual int on_scanner_closing(bool force) override; virtual int on_scanner_closing(bool force) override;
virtual void thread_handle_usb_read(void) override; virtual void thread_handle_usb_read(void) override;
virtual void image_process(std::shared_ptr<tiny_buffer>& buff) ;
public: public:
hg_scanner_239(const char* dev_name, int pid,usb_io* io); hg_scanner_239(const char* dev_name, int pid,usb_io* io);

180
hgdriver/hgdev/hg_scanner_300.cpp
View File

@ -379,186 +379,6 @@ int hg_scanner_300::get_img_data(std::shared_ptr<tiny_buffer> &imagedata)
return ret; return ret;
} }
void hg_scanner_300::image_process(std::shared_ptr<tiny_buffer>& buffer)
{
int ret = SCANNER_ERR_OK;
hg_imgproc::HIMGPRC handle = get_image_process_object(pid_);
hg_imgproc::IMGHEAD ih;
int err = SCANNER_ERR_OK,
index = 0;
void* buf = NULL;
hg_imgproc::load_buffer(handle, buffer);
hg_imgproc::decode(handle,pid_);
if (isremove_left_hole || isremove_right_hole || isremove_top_hole || isremove_low_hole)
{
ret = hg_imgproc::fillhole(handle, isremove_top_hole_threshold, isremove_low_hole_threshold, isremove_left_hole_threshold, isremove_right_hole_threshold);
}
/////////////////////////////////////111111111111111111111111111//////////////////////////////////
ret = hg_imgproc::auto_crop(handle); //首次必须先调用这个算法
if (img_conf_.is_autodiscradblank_normal || img_conf_.is_autodiscradblank_vince)
{
ret = hg_imgproc::discardBlank(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"丢弃空白页开启\r\n");
}
if(img_conf_.fadeback)
{
hg_imgproc::fadeback(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"背景除色开启\r\n");
}
if (img_conf_.resolution_dst != img_conf_.resolution_native)
{
hg_imgproc::resolution_change(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"dpi改变开启\r\n");
}
if (img_conf_.cropRect.enable && !img_conf_.is_autocrop)
{
hg_imgproc::croprect(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"手动裁图开启\r\n");
}
if (img_conf_.filter != ColorFilter::FILTER_NONE && (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE || img_conf_.pixtype == COLOR_MODE_256_GRAY))
{
hg_imgproc::channel(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"除色开启\r\n");
}
/////////////////////////////////////2222222222222222222222222222222222222//////////////////////////////////
adjust_color(handle);
if (img_conf_.pixtype == COLOR_MODE_24_BITS && img_conf_.hsvcorrect)
{
hg_imgproc::answerSheetFilterRed(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"答题卡出红开启\r\n");
}
if (img_conf_.refuseInflow)
{
int lv = 5;
if (image_prc_param_.bits.is_permeate_lv_ == 0)
lv = 5;
else if (image_prc_param_.bits.is_permeate_lv_ == 1)
lv = 15;
else if (image_prc_param_.bits.is_permeate_lv_ == 2)
lv = 25;
else if (image_prc_param_.bits.is_permeate_lv_ == 3)
lv = 35;
else if (image_prc_param_.bits.is_permeate_lv_ == 4)
lv = 45;
hg_imgproc::antiInflow(handle,lv);
}
if (img_conf_.colorCorrection && img_conf_.pixtype != COLOR_MODE_BLACK_WHITE)
{
hg_imgproc::colorCorrection(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"颜色校正开启\r\n");
}
if ((img_conf_.imageRotateDegree != TEXT_DIRECTION_0 || img_conf_.is_backrotate180) && (!img_conf_.is_autotext))
{
hg_imgproc::orentation(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"自动旋转开启\r\n");
}
if (img_conf_.removeMorr)
{
hg_imgproc::textureRemove(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"除摩尔纹开启\r\n");
}
if (img_conf_.detachnoise.is_detachnoise)
{
hg_imgproc::nosieDetach(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"噪点优化开启\r\n");
}
if (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE)
{
hg_imgproc::errorextention(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"黑白图处理开启\r\n");
}
if (img_conf_.en_fold)
{
hg_imgproc::fold(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"对折开启\r\n");
}
///////////////////////////////////
if (img_conf_.multi_output_red && img_conf_.pixtype == COLOR_MODE_24_BITS)
{
err = hg_imgproc::multi_out_red(handle);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"多流出红开启\r\n");
}
if (img_conf_.sharpen)
{
hg_imgproc::sharpenType(handle);
}
if (img_conf_.splitImage)
{
int colormode=1;
if(img_conf_.filter == RID_COLOR_NONE)
colormode=img_conf_.pixtype;
err = hg_imgproc::split(handle,-1);
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n"
,img_conf_.multiOutput
,img_conf_.splitImage
,img_conf_.multi_output_red
,img_conf_.pixtype
,img_conf_.is_duplex);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"图像拆分开启\r\n");
}
if (!img_conf_.splitImage || !img_conf_.multi_output_red || !is_multiout)
{
if(img_conf_.automaticcolor)
{
hg_imgproc::auto_matic_color(handle,img_conf_.automaticcolortype);
//HG_LOGHG_LOG_LEVEL_DEBUG_INFO,"颜色自动识别开启\r\n");
}
}
if (img_conf_.is_autotext)
{
printf("文本方向自动识别\r\n");
hg_imgproc::ocr_auto_txtdirect(handle);
}
//多流输出最后处理
if (is_multiout)
{
int multi_out = img_conf_.multiOutput;
err = hg_imgproc::multi_out(handle,multi_out);
}
hg_imgproc::final(handle);
while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK)
{
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
if(!img_type_.empty())
{
std::vector<unsigned char>bmpdata;
//cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata);
hg_imgproc::imgtypechange(handle,img_type_,buf,bmpdata);
if(bmpdata.empty())
{
status_ = SCANNER_ERR_NO_DATA;
return ;
}
buf = bmpdata.data();
ih.total_bytes = bmpdata.size();
VLOG_MINI_6(LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n",img_type_.c_str() ,index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
}
save_final_image(&ih, buf);
}
hg_imgproc::release(handle);
}
int hg_scanner_300::writedown_device_configuration(bool type,setting_hardware::HGSCANCONF_3288 *d) int hg_scanner_300::writedown_device_configuration(bool type,setting_hardware::HGSCANCONF_3288 *d)
{ {

2
hgdriver/hgdev/hg_scanner_300.h
View File

@ -25,8 +25,6 @@ class hg_scanner_300 : public hg_scanner
protected: protected:
virtual int on_scanner_closing(bool force) override; virtual int on_scanner_closing(bool force) override;
virtual void thread_handle_usb_read(void) override; virtual void thread_handle_usb_read(void) override;
virtual void image_process(std::shared_ptr<tiny_buffer>& buff) ;
virtual int on_color_mode_changed(int& color_mode); // COLOR_MODE_xxx virtual int on_color_mode_changed(int& color_mode); // COLOR_MODE_xxx
virtual int on_paper_changed(int& paper); // PAPER_xxx virtual int on_paper_changed(int& paper); // PAPER_xxx

204
hgdriver/hgdev/hg_scanner_302.cpp
View File

@ -616,210 +616,6 @@ void hg_scanner_302::init_version(void)
else else
is_kernelsnap_211209_ = false; is_kernelsnap_211209_ = false;
} }
void hg_scanner_302::image_process(std::shared_ptr<tiny_buffer>& buff)
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Process image with %u bytes content ...\n", buff->size());
hg_imgproc::HIMGPRC handle = get_image_process_object(pid_);
hg_imgproc::IMGHEAD ih;
int err = SCANNER_ERR_OK,
index = 0;
void* buf = NULL;
err = hg_imgproc::load_buffer(handle, buff);
err = hg_imgproc::decode(handle,pid_);
VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Image process parameter: 0x%x%08x, multi out: %s\n", ((unsigned int*)&image_prc_param_.value)[1], ((unsigned int*)&image_prc_param_.value)[0], is_multiout ? "true" : "false");
if (isremove_left_hole || isremove_right_hole || isremove_top_hole || isremove_low_hole)
{
err = hg_imgproc::fillhole(handle, isremove_top_hole_threshold, isremove_low_hole_threshold, isremove_left_hole_threshold, isremove_right_hole_threshold);
}
/////////////////////////////////////111111111111111111111111111//////////////////////////////////
err = hg_imgproc::auto_crop(handle);
if (img_conf_.is_autodiscradblank_normal || img_conf_.is_autodiscradblank_vince)
{
err = hg_imgproc::discardBlank(handle);
printf("丢弃空白页开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "丢弃空白页开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.fadeback)
{
hg_imgproc::fadeback(handle);
//printf("背景除色开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "背景除色开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.resolution_dst != img_conf_.resolution_native)
{
hg_imgproc::resolution_change(handle);
//printf("dpi改变开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "dpi改变开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.cropRect.enable && !img_conf_.is_autocrop)
{
hg_imgproc::croprect(handle);
//printf("手动裁图开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "手动裁图开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.filter != ColorFilter::FILTER_NONE && (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE || img_conf_.pixtype == COLOR_MODE_256_GRAY))
{
printf("除色开启\r\n");
hg_imgproc::channel(handle);
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "除色开启:%s\n",hg_scanner_err_name(ret));
}
/////////////////////////////////////2222222222222222222222222222222222222//////////////////////////////////
adjust_color(handle);
if (img_conf_.pixtype == COLOR_MODE_24_BITS && img_conf_.hsvcorrect)
{
hg_imgproc::answerSheetFilterRed(handle);
//printf("答题卡出红开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "答题卡出红开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.refuseInflow)
{
int lv = 5;
if (image_prc_param_.bits.is_permeate_lv_ == 0)
lv = 5;
else if (image_prc_param_.bits.is_permeate_lv_ == 1)
lv = 15;
else if (image_prc_param_.bits.is_permeate_lv_ == 2)
lv = 25;
else if (image_prc_param_.bits.is_permeate_lv_ == 3)
lv = 35;
else if (image_prc_param_.bits.is_permeate_lv_ == 4)
lv = 45;
hg_imgproc::antiInflow(handle, lv);
}
if (img_conf_.colorCorrection && img_conf_.pixtype != COLOR_MODE_BLACK_WHITE)
{
hg_imgproc::colorCorrection(handle);
//printf("颜色校正开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "颜色校正开启:%s\n",hg_scanner_err_name(ret));
}
if ((img_conf_.imageRotateDegree != TEXT_DIRECTION_0 || img_conf_.is_backrotate180) && (!img_conf_.is_autotext))
{
printf("手动旋转开启\r\n");
hg_imgproc::orentation(handle);
}
if (img_conf_.removeMorr)
{
hg_imgproc::textureRemove(handle);
//printf("除摩尔纹开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "除摩尔纹开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.detachnoise.is_detachnoise)
{
hg_imgproc::nosieDetach(handle);
//printf("噪点优化开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "噪点优化开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE)
{
hg_imgproc::errorextention(handle);
//printf("黑白图处理开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "黑白图处理开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.en_fold)
{
hg_imgproc::fold(handle);
//printf("对折开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "对折开启:%s\n",hg_scanner_err_name(ret));
}
///////////////////////////////////
if (img_conf_.multi_output_red && img_conf_.pixtype == COLOR_MODE_24_BITS)
{
err = hg_imgproc::multi_out_red(handle);
//printf("多流出红开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "多流出红开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.sharpen)
{
hg_imgproc::sharpenType(handle);
}
if(image_prc_param_.bits.erase_bakground)
{
err = hg_imgproc::fadeback(handle);
}
if (img_conf_.multi_output_red && img_conf_.pixtype == COLOR_MODE_24_BITS)
err = hg_imgproc::multi_out_red(handle);
if (img_conf_.splitImage)
{
//split3399_++;
int colormode=1;
if(img_conf_.filter == RID_COLOR_NONE)
colormode=img_conf_.pixtype;
err = hg_imgproc::split(handle,-1);
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n"
,img_conf_.multiOutput
,img_conf_.splitImage
,img_conf_.multi_output_red
,img_conf_.pixtype
,img_conf_.is_duplex);
}
if (!img_conf_.splitImage || !img_conf_.multi_output_red || !is_multiout)
{
if(img_conf_.automaticcolor)
{
hg_imgproc::auto_matic_color(handle,img_conf_.automaticcolortype);
}
}
if (img_conf_.is_autotext)
{
printf("文本方向自动识别\r\n");
hg_imgproc::ocr_auto_txtdirect(handle);
}
if (is_quality_ == IMG_SPEED && resolution_ >= 300)
{
err = hg_imgproc::quality(handle,resolution_);
}
//多流输出最后处理
if (is_multiout)
{
int multi_out = image_prc_param_.bits.multi_out;
err = hg_imgproc::multi_out(handle,multi_out);
}
hg_imgproc::final(handle);
while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK)
{
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
if(!img_type_.empty())
{
std::vector<unsigned char>bmpdata;
hg_imgproc::imgtypechange(handle,img_type_,buf,bmpdata);
//cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata);
if(bmpdata.empty())
{
status_ = SCANNER_ERR_NO_DATA;
return ;
}
buf = bmpdata.data();
ih.total_bytes = bmpdata.size();
VLOG_MINI_6(LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n",img_type_.c_str() ,index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
}
save_final_image(&ih, buf);
}
hg_imgproc::release(handle);
}
int hg_scanner_302::get_device_sleep_stautus(void) int hg_scanner_302::get_device_sleep_stautus(void)
{ {

1
hgdriver/hgdev/hg_scanner_302.h
View File

@ -71,7 +71,6 @@ protected:
virtual void on_device_reconnected(void) override; virtual void on_device_reconnected(void) override;
virtual int on_scanner_closing(bool force) override; virtual int on_scanner_closing(bool force) override;
virtual void thread_handle_usb_read(void) override; virtual void thread_handle_usb_read(void) override;
virtual void image_process(std::shared_ptr<tiny_buffer>& buff) ;
public: public:
hg_scanner_302(const char* dev_name, int pid,usb_io* io); hg_scanner_302(const char* dev_name, int pid,usb_io* io);

196
hgdriver/hgdev/hg_scanner_400.cpp
View File

@ -375,202 +375,6 @@ int hg_scanner_400::get_img_data(std::shared_ptr<tiny_buffer> &imagedata)
return ret; return ret;
} }
void hg_scanner_400::image_process(std::shared_ptr<tiny_buffer>& buffer)
{
int ret = SCANNER_ERR_OK;
hg_imgproc::HIMGPRC handle = get_image_process_object(pid_);
hg_imgproc::IMGHEAD ih;
int err = SCANNER_ERR_OK,
index = 0;
void* buf = NULL;
hg_imgproc::load_buffer(handle, buffer);
hg_imgproc::decode(handle,pid_);
if (isremove_left_hole || isremove_right_hole || isremove_top_hole || isremove_low_hole)
{
ret = hg_imgproc::fillhole(handle, isremove_top_hole_threshold, isremove_low_hole_threshold, isremove_left_hole_threshold, isremove_right_hole_threshold);
}
/////////////////////////////////////111111111111111111111111111//////////////////////////////////
ret = hg_imgproc::auto_crop(handle);
if (img_conf_.is_autodiscradblank_normal || img_conf_.is_autodiscradblank_vince)
{
ret = hg_imgproc::discardBlank(handle);
printf("丢弃空白页开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "丢弃空白页开启:%s\n",hg_scanner_err_name(ret));
}
if(img_conf_.fadeback)
{
hg_imgproc::fadeback(handle);
//printf("背景除色开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "背景除色开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.resolution_dst != img_conf_.resolution_native)
{
hg_imgproc::resolution_change(handle);
//printf("dpi改变开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "dpi改变开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.cropRect.enable && !img_conf_.is_autocrop)
{
hg_imgproc::croprect(handle);
//printf("手动裁图开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "手动裁图开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.filter != ColorFilter::FILTER_NONE && (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE || img_conf_.pixtype == COLOR_MODE_256_GRAY))
{
printf("除色开启\r\n");
hg_imgproc::channel(handle);
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "除色开启:%s\n",hg_scanner_err_name(ret));
}
/////////////////////////////////////2222222222222222222222222222222222222//////////////////////////////////
adjust_color(handle);
if (img_conf_.pixtype == COLOR_MODE_24_BITS && img_conf_.hsvcorrect)
{
hg_imgproc::answerSheetFilterRed(handle);
//printf("答题卡出红开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "答题卡出红开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.refuseInflow)
{
int lv = 5;
if (image_prc_param_.bits.is_permeate_lv_ == 0)
lv = 5;
else if (image_prc_param_.bits.is_permeate_lv_ == 1)
lv = 15;
else if (image_prc_param_.bits.is_permeate_lv_ == 2)
lv = 25;
else if (image_prc_param_.bits.is_permeate_lv_ == 3)
lv = 35;
else if (image_prc_param_.bits.is_permeate_lv_ == 4)
lv = 45;
hg_imgproc::antiInflow(handle,lv);
}
if (img_conf_.colorCorrection && img_conf_.pixtype != COLOR_MODE_BLACK_WHITE)
{
hg_imgproc::colorCorrection(handle);
//printf("颜色校正开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "颜色校正开启:%s\n",hg_scanner_err_name(ret));
}
if ((img_conf_.imageRotateDegree != TEXT_DIRECTION_0 || img_conf_.is_backrotate180) && (!img_conf_.is_autotext))
{
printf("手动旋转开启\r\n");
hg_imgproc::orentation(handle);
}
if (img_conf_.removeMorr)
{
hg_imgproc::textureRemove(handle);
//printf("除摩尔纹开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "除摩尔纹开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.detachnoise.is_detachnoise)
{
hg_imgproc::nosieDetach(handle);
//printf("噪点优化开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "噪点优化开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE)
{
hg_imgproc::errorextention(handle);
//printf("黑白图处理开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "黑白图处理开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.en_fold)
{
hg_imgproc::fold(handle);
//printf("对折开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "对折开启:%s\n",hg_scanner_err_name(ret));
}
///////////////////////////////////
if (img_conf_.multi_output_red && img_conf_.pixtype == COLOR_MODE_24_BITS)
{
err = hg_imgproc::multi_out_red(handle);
//printf("多流出红开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "多流出红开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.sharpen)
{
hg_imgproc::sharpenType(handle);
}
if (img_conf_.splitImage)
{
int colormode=1;
if(img_conf_.filter == RID_COLOR_NONE)
colormode=img_conf_.pixtype;
err = hg_imgproc::split(handle,-1);
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n"
,img_conf_.multiOutput
,img_conf_.splitImage
,img_conf_.multi_output_red
,img_conf_.pixtype
,img_conf_.is_duplex);
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "图像拆分开启:%s\n",hg_scanner_err_name(ret));
}
if (!img_conf_.splitImage || !img_conf_.multi_output_red || !is_multiout)
{
if(img_conf_.automaticcolor)
{
ret = hg_imgproc::auto_matic_color(handle,img_conf_.automaticcolortype);
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "颜色自动识别模式开启:%s\n",hg_scanner_err_name(ret));
}
}
if (img_conf_.is_autotext)
{
printf("文本方向自动识别开启\r\n");
hg_imgproc::ocr_auto_txtdirect(handle);
}
//多流输出最后处理
if (is_multiout)
{
int multi_out = image_prc_param_.bits.multi_out;
err = hg_imgproc::multi_out(handle,multi_out);
}
hg_imgproc::final(handle);
while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK)
{
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
if(!img_type_.empty())
{
std::vector<unsigned char>bmpdata;
hg_imgproc::imgtypechange(handle,img_type_,buf,bmpdata);
//cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata);
if(bmpdata.empty())
{
status_ = SCANNER_ERR_NO_DATA;
return ;
}
buf = bmpdata.data();
ih.total_bytes = bmpdata.size();
VLOG_MINI_6(LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n",img_type_.c_str() ,index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
}
save_final_image(&ih, buf);
}
hg_imgproc::release(handle);
}
int hg_scanner_400::writedown_device_configuration(bool type,setting_hardware::HGSCANCONF_3288 *d) int hg_scanner_400::writedown_device_configuration(bool type,setting_hardware::HGSCANCONF_3288 *d)
{ {
if (!type) if (!type)

2
hgdriver/hgdev/hg_scanner_400.h
View File

@ -25,8 +25,6 @@ class hg_scanner_400 : public hg_scanner
protected: protected:
virtual int on_scanner_closing(bool force) override; virtual int on_scanner_closing(bool force) override;
virtual void thread_handle_usb_read(void) override; virtual void thread_handle_usb_read(void) override;
virtual void image_process(std::shared_ptr<tiny_buffer>& buff) ;
virtual int on_color_mode_changed(int& color_mode); // COLOR_MODE_xxx virtual int on_color_mode_changed(int& color_mode); // COLOR_MODE_xxx
virtual int on_paper_changed(int& paper); // PAPER_xxx virtual int on_paper_changed(int& paper); // PAPER_xxx

215
hgdriver/hgdev/hg_scanner_402.cpp
View File

@ -494,211 +494,6 @@ void hg_scanner_402::init_version(void)
else else
is_kernelsnap_211209_ = false; is_kernelsnap_211209_ = false;
} }
void hg_scanner_402::image_process(std::shared_ptr<tiny_buffer>& buff)
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Process image with %u bytes content ...\n", buff->size());
hg_imgproc::HIMGPRC handle = get_image_process_object(pid_);
hg_imgproc::IMGHEAD ih;
int err = SCANNER_ERR_OK,
index = 0;
void* buf = NULL;
err = hg_imgproc::load_buffer(handle, buff);
err = hg_imgproc::decode(handle,pid_);
VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Image process parameter: 0x%x%08x, multi out: %s\n", ((unsigned int*)&image_prc_param_.value)[1], ((unsigned int*)&image_prc_param_.value)[0], is_multiout ? "true" : "false");
if (isremove_left_hole || isremove_right_hole || isremove_top_hole || isremove_low_hole)
{
err = hg_imgproc::fillhole(handle, isremove_top_hole_threshold, isremove_low_hole_threshold, isremove_left_hole_threshold, isremove_right_hole_threshold);
}
/////////////////////////////////////111111111111111111111111111//////////////////////////////////
err = hg_imgproc::auto_crop(handle);
if (img_conf_.is_autodiscradblank_normal || img_conf_.is_autodiscradblank_vince)
{
err = hg_imgproc::discardBlank(handle);
printf("丢弃空白页开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "丢弃空白页开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.fadeback)
{
hg_imgproc::fadeback(handle);
//printf("背景除色开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "背景除色开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.resolution_dst != img_conf_.resolution_native)
{
hg_imgproc::resolution_change(handle);
//printf("dpi改变开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "dpi改变开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.cropRect.enable && !img_conf_.is_autocrop)
{
hg_imgproc::croprect(handle);
//printf("手动裁图开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "手动裁图开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.filter != ColorFilter::FILTER_NONE && (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE || img_conf_.pixtype == COLOR_MODE_256_GRAY))
{
printf("除色开启\r\n");
hg_imgproc::channel(handle);
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "除色开启:%s\n",hg_scanner_err_name(ret));
}
/////////////////////////////////////2222222222222222222222222222222222222//////////////////////////////////
adjust_color(handle);
if (img_conf_.pixtype == COLOR_MODE_24_BITS && img_conf_.hsvcorrect)
{
hg_imgproc::answerSheetFilterRed(handle);
//printf("答题卡出红开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "答题卡出红开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.refuseInflow)
{
int lv = 5;
if (image_prc_param_.bits.is_permeate_lv_ == 0)
lv = 5;
else if (image_prc_param_.bits.is_permeate_lv_ == 1)
lv = 15;
else if (image_prc_param_.bits.is_permeate_lv_ == 2)
lv = 25;
else if (image_prc_param_.bits.is_permeate_lv_ == 3)
lv = 35;
else if (image_prc_param_.bits.is_permeate_lv_ == 4)
lv = 45;
hg_imgproc::antiInflow(handle, lv);
}
if (img_conf_.colorCorrection && img_conf_.pixtype != COLOR_MODE_BLACK_WHITE)
{
hg_imgproc::colorCorrection(handle);
//printf("颜色校正开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "颜色校正开启:%s\n",hg_scanner_err_name(ret));
}
if ((img_conf_.imageRotateDegree != TEXT_DIRECTION_0 || img_conf_.is_backrotate180) && (!img_conf_.is_autotext))
{
printf("手动旋转开启\r\n");
hg_imgproc::orentation(handle);
}
if (img_conf_.removeMorr)
{
hg_imgproc::textureRemove(handle);
//printf("除摩尔纹开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "除摩尔纹开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.detachnoise.is_detachnoise)
{
hg_imgproc::nosieDetach(handle);
//printf("噪点优化开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "噪点优化开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE)
{
hg_imgproc::errorextention(handle);
//printf("黑白图处理开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "黑白图处理开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.en_fold)
{
hg_imgproc::fold(handle);
//printf("对折开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "对折开启:%s\n",hg_scanner_err_name(ret));
}
///////////////////////////////////
if (img_conf_.multi_output_red && img_conf_.pixtype == COLOR_MODE_24_BITS)
{
err = hg_imgproc::multi_out_red(handle);
//printf("多流出红开启\r\n");
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "多流出红开启:%s\n",hg_scanner_err_name(ret));
}
if (img_conf_.sharpen)
{
hg_imgproc::sharpenType(handle);
}
if(img_conf_.fadeback)
{
err = hg_imgproc::fadeback(handle);
}
if (img_conf_.multi_output_red && img_conf_.pixtype == COLOR_MODE_24_BITS)
err = hg_imgproc::multi_out_red(handle);
if (img_conf_.splitImage)
{
//split3399_++;
int colormode=1;
if(img_conf_.filter == RID_COLOR_NONE)
colormode=img_conf_.pixtype;
err = hg_imgproc::split(handle,-1);
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n"
,img_conf_.multiOutput
,img_conf_.splitImage
,img_conf_.multi_output_red
,img_conf_.pixtype
,img_conf_.is_duplex);
}
if (!img_conf_.splitImage || !img_conf_.multi_output_red|| !is_multiout)
{
if(img_conf_.automaticcolor)
{
hg_imgproc::auto_matic_color(handle,img_conf_.automaticcolortype);
}
}
if (img_conf_.is_autotext)
{
printf("文本方向自动识别\r\n");
hg_imgproc::ocr_auto_txtdirect(handle);
}
if (is_quality_ == IMG_SPEED && resolution_ >= 300)
{
err = hg_imgproc::quality(handle,resolution_);
}
//多流输出最后处理
if (is_multiout)
{
int multi_out = img_conf_.multiOutput;
err = hg_imgproc::multi_out(handle,multi_out);
}
hg_imgproc::final(handle);
while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK)
{
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
if(!img_type_.empty())
{
std::vector<unsigned char>bmpdata;
hg_imgproc::imgtypechange(handle,img_type_,buf,bmpdata);
//cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata);
if(bmpdata.empty())
{
status_ = SCANNER_ERR_NO_DATA;
return ;
}
buf = bmpdata.data();
ih.total_bytes = bmpdata.size();
VLOG_MINI_6(LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n",img_type_.c_str() ,index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
}
save_final_image(&ih, buf);
}
hg_imgproc::release(handle);
}
int hg_scanner_402::get_device_sleep_stautus(void) int hg_scanner_402::get_device_sleep_stautus(void)
{ {
int ret =read_register(setting3399::SR_GET_SLEEP_STAUTUS,0); int ret =read_register(setting3399::SR_GET_SLEEP_STAUTUS,0);
@ -1785,15 +1580,7 @@ int hg_scanner_402::get_scan_is_sleep()
} }
int hg_scanner_402::get_device_log(string &log) int hg_scanner_402::get_device_log(string &log)
{ {
int ret = SCANNER_ERR_OK; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
int len = log.size();
ret = write_register(setting3399::SR_SET_JSON_PATH, len);
if (ret == SCANNER_ERR_OK)
ret = io_->write_bulk(&log[0],&len);
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s\n", log.c_str(),hg_scanner_err_name(ret));
return ret;
} }
int hg_scanner_402::notify_sleep() int hg_scanner_402::notify_sleep()
{ {

1
hgdriver/hgdev/hg_scanner_402.h
View File

@ -71,7 +71,6 @@ protected:
virtual void on_device_reconnected(void) override; virtual void on_device_reconnected(void) override;
virtual int on_scanner_closing(bool force) override; virtual int on_scanner_closing(bool force) override;
virtual void thread_handle_usb_read(void) override; virtual void thread_handle_usb_read(void) override;
virtual void image_process(std::shared_ptr<tiny_buffer>& buff);
public: public:
hg_scanner_402(const char* dev_name, int pid,usb_io* io); hg_scanner_402(const char* dev_name, int pid,usb_io* io);

107
hgdriver/hgdev/hg_scanner_439.cpp
View File

@ -478,113 +478,6 @@ void hg_scanner_439::init_version(void)
else else
is_kernelsnap_211209_ = false; is_kernelsnap_211209_ = false;
} }
void hg_scanner_439::image_process(std::shared_ptr<tiny_buffer>& buff)
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Process image with %u bytes content ...\n", buff->size());
hg_imgproc::HIMGPRC handle = get_image_process_object(pid_);
hg_imgproc::IMGHEAD ih;
int err = SCANNER_ERR_OK,
index = 0;
void* buf = NULL;
err = hg_imgproc::load_buffer(handle, buff);
err = hg_imgproc::decode(handle,pid_);
if (!isremove_left_hole)
{
isremove_top_hole_threshold = 0;
}
if (!isremove_right_hole)
{
isremove_right_hole_threshold = 0;
}
if (!isremove_top_hole)
{
isremove_top_hole_threshold = 0;
}
if (!isremove_low_hole)
{
isremove_low_hole_threshold = 0;
}
if (isremove_left_hole || isremove_right_hole || isremove_top_hole || isremove_low_hole)
{
err = hg_imgproc::fillhole(handle, isremove_top_hole_threshold, isremove_low_hole_threshold, isremove_left_hole_threshold, isremove_right_hole_threshold);
}
if(image_prc_param_.bits.erase_bakground)
{
err = hg_imgproc::fadeback(handle);
}
if (image_prc_param_.bits.rid_red && img_conf_.pixtype == COLOR_MODE_24_BITS)
err = hg_imgproc::multi_out_red(handle);
if (image_prc_param_.bits.split)
{
split3399_++;
int colormode=1;
if(img_conf_.filter == RID_COLOR_NONE)
colormode=img_conf_.pixtype;
err = hg_imgproc::split(handle,split3399_);
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n"
,img_conf_.multiOutput
,img_conf_.splitImage
,img_conf_.multi_output_red
,img_conf_.pixtype
,img_conf_.is_duplex);
}
if (!image_prc_param_.bits.split || !image_prc_param_.bits.rid_red || !is_multiout)
{
if(img_conf_.automaticcolor)
{
hg_imgproc::auto_matic_color(handle,img_conf_.automaticcolortype);
}
}
if (img_conf_.is_autotext)
{
printf("文本方向自动识别\r\n");
hg_imgproc::ocr_auto_txtdirect(handle);
}
if (is_quality_ == IMG_SPEED && resolution_ >= 300)
{
err = hg_imgproc::quality(handle,resolution_);
}
//多流输出最后处理
if (is_multiout)
{
int multi_out = image_prc_param_.bits.multi_out;
err = hg_imgproc::multi_out(handle,multi_out);
}
hg_imgproc::final(handle);
while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK)
{
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
if(!img_type_.empty())
{
std::vector<unsigned char>bmpdata;
hg_imgproc::imgtypechange(handle,img_type_,buf,bmpdata);
//cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata);
if(bmpdata.empty())
{
status_ = SCANNER_ERR_NO_DATA;
return ;
}
buf = bmpdata.data();
ih.total_bytes = bmpdata.size();
VLOG_MINI_6(LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n",img_type_.c_str() ,index
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
}
save_final_image(&ih, buf);
}
hg_imgproc::release(handle);
}
int hg_scanner_439::get_device_sleep_stautus(void) int hg_scanner_439::get_device_sleep_stautus(void)
{ {

1
hgdriver/hgdev/hg_scanner_439.h
View File

@ -68,7 +68,6 @@ protected:
virtual void on_device_reconnected(void) override; virtual void on_device_reconnected(void) override;
virtual int on_scanner_closing(bool force) override; virtual int on_scanner_closing(bool force) override;
virtual void thread_handle_usb_read(void) override; virtual void thread_handle_usb_read(void) override;
virtual void image_process(std::shared_ptr<tiny_buffer>& buff);
public: public:
hg_scanner_439(const char* dev_name, int pid,usb_io* io); hg_scanner_439(const char* dev_name, int pid,usb_io* io);

215
hgdriver/hgdev/image_process.cpp
View File

@ -46,7 +46,7 @@ typedef struct BITMAPINFOHEADER
#include "../ImageProcess/ImageApplyHeaders.h" #include "../ImageProcess/ImageApplyHeaders.h"
#include "ImageMultiOutput.h" #include "ImageMultiOutput.h"
#include "PaperSize.h" #include "PaperSize.h"
#include "imgproc/HGOCR.H"
#if defined(WIN32) || defined(_WIN64) #if defined(WIN32) || defined(_WIN64)
#include "scanner_manager.h" #include "scanner_manager.h"
#include "ocr/hanwangOCRdetect.h" #include "ocr/hanwangOCRdetect.h"
@ -59,7 +59,7 @@ extern "C"
#endif #endif
#include "hg_ipc.h" #include "hg_ipc.h"
#include "../ImageProcess/G4Tiff.h" #include "../ImageProcess/G4Tiff.h"
#include "base/HGImage.h"
#include <opencv2/imgcodecs.hpp> #include <opencv2/imgcodecs.hpp>
#define CV_MAT_DEPTH_SET(flags, depth) (((flags) & ~(CV_MAT_DEPTH_MASK)) | (depth & CV_MAT_DEPTH_MASK)) #define CV_MAT_DEPTH_SET(flags, depth) (((flags) & ~(CV_MAT_DEPTH_MASK)) | (depth & CV_MAT_DEPTH_MASK))
@ -68,13 +68,12 @@ using namespace std;
#define GET_BYTE(a) ((a) & 0x0ff) #define GET_BYTE(a) ((a) & 0x0ff)
#define MAKE_INT(a, b, c, d) (GET_BYTE(a) | (GET_BYTE(b) << 8) | (GET_BYTE(c) << 16) | (GET_BYTE(d) << 24)) #define MAKE_INT(a, b, c, d) (GET_BYTE(a) | (GET_BYTE(b) << 8) | (GET_BYTE(c) << 16) | (GET_BYTE(d) << 24))
#define IMAGE_DATA_BUF_CVMAT (void*)MAKE_INT('M', 'T', 'R', 'X') #define IMAGE_DATA_BUF_CVMAT (void*)MAKE_INT('M', 'T', 'R', 'X')
#define IMAGE_DATA_BUF_CHAR (void*)MAKE_INT('C', 'H', 'A', 'R') #define IMAGE_DATA_BUF_CHAR (void*)MAKE_INT('C', 'H', 'A', 'R')
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// functional ... // functional ...
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// NEW£¬flow ... //
static int num=0; static int num=0;
namespace hg_imgproc namespace hg_imgproc
{ {
@ -125,6 +124,10 @@ namespace hg_imgproc
return ret; return ret;
} }
}; };
typedef unsigned int (*SDKInitialize_)(unsigned int ocrtype, void** pstOcrHandle);
typedef unsigned int (*SDKExit_)(void* pstOcrHandle);
typedef unsigned int (*SDKGetFileDirectImage_)(void* pstOcrHandle, void* image, unsigned int* pDirect);
class imgproc class imgproc
{ {
std::string my_path_; std::string my_path_;
@ -137,6 +140,16 @@ namespace hg_imgproc
Device::PaperSize papersize_; Device::PaperSize papersize_;
SANE_Image_Statu img_statu_; SANE_Image_Statu img_statu_;
SDKInitialize_ ocrinit_ = NULL;
SDKGetFileDirectImage_ ocrgetdirectimage_ = NULL;
SDKExit_ ocrexit_ = NULL;
void* Auto_Txt_pHanld = NULL;
#ifndef WIN32
void Dynamicopen_pHandle_;
#else
HINSTANCE Dynamicopen_pHandle_;
#endif
void swap_rgb(cv::Mat& mat) void swap_rgb(cv::Mat& mat)
{ {
@ -156,10 +169,9 @@ namespace hg_imgproc
first += line_bytes; first += line_bytes;
} }
} }
// construction // construction
public: public:
imgproc(LPSCANCONF img_param,LPIMGPRCPARAM param,int pid) : img_conf_(*img_param),param_(*param),pid_(pid),papersize_(pid_) imgproc(int pid) : pid_(pid),papersize_(pid_)
, img_statu_(SANE_Image_Statu_OK) , img_statu_(SANE_Image_Statu_OK)
{ {
my_path_ = hg_log::pe_path(); my_path_ = hg_log::pe_path();
@ -224,14 +236,80 @@ namespace hg_imgproc
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
// image-processing // image-processing
public: public:
int decode(int pid) int init_auto_txt_hanld()
{
int ret = 0;
#ifndef WIN32
#ifdef OEM_HANWANG
string libname = "libHGImgProc.so";
#elif defined(OEM_LISICHENG)
string libname = "libLscImgProc.so";
#else
string libname = "libHwImgProc.so";
#endif
string scanner_path = hg_log::get_module_full_path(libname.c_str());
if (scanner_path.empty())
{
return SCANNER_ERR_OUT_OF_RANGE;
}
printf("auto txt libpath is:%s\r\n", scanner_path.c_str());
if (access(scanner_path.c_str(), F_OK) != 0)
{
return SCANNER_ERR_OUT_OF_RANGE;
}
#endif
#if (!defined WIN32)
Dynamicopen_pHandle_ = dlopen(scanner_path.c_str(), RTLD_LAZY);
if (!handle_)
{
return SCANNER_ERR_OUT_OF_RANGE;
}
ocrinit_ = (SDKInitialize)dlsym(Dynamicopen_pHandle_, "HGImgProc_CreateOCRMgr");
ocrgetdirectimage_ = (SDKGetFileDirectImage_)dlsym(Dynamicopen_pHandle_, "HGImgProc_ImageTextDirectOCR");
ocrexit_ = (SDKExit_)dlsym(Dynamicopen_pHandle_, "HGImgProc_DestroyOCRMgr");
#else
Dynamicopen_pHandle_ = LoadLibrary(L"HGImgProc.dll");
if (Dynamicopen_pHandle_)
{
ocrinit_ = (SDKInitialize_)GetProcAddress(Dynamicopen_pHandle_, "HGImgProc_CreateOCRMgr");
ocrgetdirectimage_ = (SDKGetFileDirectImage_)GetProcAddress(Dynamicopen_pHandle_, "HGImgProc_ImageTextDirectOCR");
ocrexit_ = (SDKExit_)GetProcAddress(Dynamicopen_pHandle_, "HGImgProc_DestroyOCRMgr");
}
#endif
ret = ocrinit_(HGIMGPROC_OCRALGO_TESSERACT, &Auto_Txt_pHanld);
return ret;
}
int free_auto_txt_hanld()
{
int ret = 0;
if (Dynamicopen_pHandle_ != NULL)
{
#if (!defined WIN32)
ret = dlclose(Dynamicopen_pHandle_);
#else
ret = FreeLibrary(Dynamicopen_pHandle_);
#endif
Dynamicopen_pHandle_ = NULL;
}
if (Auto_Txt_pHanld != NULL)
{
int ret = ocrexit_(Auto_Txt_pHanld);
Auto_Txt_pHanld = NULL;
}
return ret;
}
int decode(int pid, LPSCANCONF img_param, LPIMGPRCPARAM param)
{ {
if (!buffer_) if (!buffer_)
return SCANNER_ERR_NO_DATA; return SCANNER_ERR_NO_DATA;
img_conf_ = *img_param;
param_ = *param;
size_t origin = buffer_->size(); size_t origin = buffer_->size();
std::vector<std::shared_ptr<std::vector<char>>> buffs; std::vector<std::shared_ptr<std::vector<char>>> buffs;
if(pid == 0x100 || pid == 0x200) if(pid == 0x100 || pid == 0x200)
@ -326,8 +404,6 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int split(int split3399) int split(int split3399)
{ {
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
@ -456,7 +532,6 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int multi_out(int out_type) int multi_out(int out_type)
{ {
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
@ -701,8 +776,7 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int antiInflow(int permeate_lv)
int antiInflow(int permeate_lv)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
@ -721,7 +795,6 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int colorCorrection() int colorCorrection()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -738,8 +811,7 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int orentation()
int orentation()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
@ -783,8 +855,7 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int textureRemove()
int textureRemove()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
@ -801,7 +872,7 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int sharpenType() int sharpenType()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
@ -820,7 +891,7 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int nosieDetach() int nosieDetach()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
@ -839,7 +910,7 @@ namespace hg_imgproc
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int errorextention() int errorextention()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
@ -863,7 +934,6 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int discardBlank() int discardBlank()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -909,7 +979,6 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
//对折
int fold() int fold()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -926,8 +995,6 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
//画质
int quality(int dpi_dst) int quality(int dpi_dst)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -1007,7 +1074,7 @@ namespace hg_imgproc
} }
#endif #endif
#if ((!defined x86_64) && (!defined WIN32)) #if ((!defined x86_64) && (!defined WIN32))
//linux x86_64 暂时没有OCR三方 //linux x86_64
void *hanlde = dlopen(scanner_path.c_str(),RTLD_LAZY); void *hanlde = dlopen(scanner_path.c_str(),RTLD_LAZY);
if(!hanlde) if(!hanlde)
@ -1027,7 +1094,7 @@ namespace hg_imgproc
ocrgetdirectimage = (SDKGetFileDirectImage)GetProcAddress(handle, "HWOCR_GetFileDirectImage"); ocrgetdirectimage = (SDKGetFileDirectImage)GetProcAddress(handle, "HWOCR_GetFileDirectImage");
ocrexit = (SDKExit)GetProcAddress(handle, "HWOCR_SDKExit"); ocrexit = (SDKExit)GetProcAddress(handle, "HWOCR_SDKExit");
} }
#endif // WIN32 //暂时保留文本方向旋转 #endif // WIN32
#endif #endif
int r = ocrinit(&pHanld); int r = ocrinit(&pHanld);
for (size_t i = 0; i < mats.size(); i++) for (size_t i = 0; i < mats.size(); i++)
@ -1054,6 +1121,51 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int tesseract_auto_txtdirect()
{
std::vector<cv::Mat> mats(mats_);
mats_.clear();
unsigned int pDirect = 0,
ret = SCANNER_ERR_OK;
HGImage image;
if (ocrinit_ && ocrgetdirectimage_ && ocrexit_)
{
for (size_t i = 0; i < mats.size(); i++)
{
HGImage b = opencv_to_hgbase_image(mats[i]);
ret = ocrgetdirectimage_(Auto_Txt_pHanld, b, &pDirect);
HGBase_DestroyImage(b);
switch (pDirect)
{
case HGIMGPROC_OCRTEXTDIRECT_ORI:
pDirect = (int)CImageApplyRotation::RotationType::Invalid;
break;
case HGIMGPROC_OCRTEXTDIRECT_RIGHT:
pDirect = (int)CImageApplyRotation::RotationType::Rotate_90_anti_clockwise;
break;
case HGIMGPROC_OCRTEXTDIRECT_LEFT:
pDirect = (int)CImageApplyRotation::RotationType::Rotate_90_clockwise;
break;
case HGIMGPROC_OCRTEXTDIRECT_180:
pDirect = (int)CImageApplyRotation::RotationType::Rotate_180;
break;
default:
pDirect = (int)CImageApplyRotation::RotationType::Invalid;
break;
}
CImageApplyRotation(CImageApplyRotation::RotationType(pDirect)).apply(mats[i], false);
mats_.push_back(mats[i]);
}
}
if (mats_.empty())
{
return SCANNER_ERR_NO_DATA;
}
return SCANNER_ERR_OK;
}
int size_detection() int size_detection()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -1073,6 +1185,26 @@ namespace hg_imgproc
} }
HGImage opencv_to_hgbase_image(const cv::Mat& mats)
{
if (mats.empty())
{
//return SCANNER_ERR_NO_DATA;
}
HGImage image;
HGImageInfo info;
info.height = mats.rows;
info.width = mats.cols;
info.origin = 1L;
int bits = mats.channels() == 8 ? 8 : 24;
info.widthStep = mats.step; //opencv ԭʼֵ ÎÞÐè¼ÆËã¶ÔÆë
info.type = mats.channels() == 1 ? HGBASE_IMGTYPE_GRAY : HGBASE_IMGTYPE_BGR;
int ret = HGBase_CreateImageWithData(const_cast<uchar*>(mats.data), &info, &image);
return image;
//return ret;
}
/// <summary> /// <summary>
/// 8位图转1位图 /// 8位图转1位图
/// </summary> /// </summary>
@ -1081,6 +1213,8 @@ namespace hg_imgproc
/// <param name="reverse">true为反色，即黑0白1；反之亦然</param> /// <param name="reverse">true为反色，即黑0白1；反之亦然</param>
/// <param name="align">true为四字节对齐</param> /// <param name="align">true为四字节对齐</param>
/// <returns>1位图</returns> /// <returns>1位图</returns>
///
static cv::Mat convert_8bit_2_1bit(const cv::Mat& image, uchar threshold, bool reverse, bool align) static cv::Mat convert_8bit_2_1bit(const cv::Mat& image, uchar threshold, bool reverse, bool align)
{ {
if (image.channels() != 1) if (image.channels() != 1)
@ -1247,9 +1381,9 @@ namespace hg_imgproc
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// api ... // api ...
HIMGPRC init(LPSCANCONF parameter,LPIMGPRCPARAM param,int pid) HIMGPRC init(int pid)
{ {
imgproc* obj = new imgproc(parameter,param,pid); imgproc* obj = new imgproc(pid);
return (HIMGPRC)obj; return (HIMGPRC)obj;
} }
@ -1262,9 +1396,17 @@ namespace hg_imgproc
return ((imgproc*)himg)->load_file(path_file); return ((imgproc*)himg)->load_file(path_file);
} }
int decode(HIMGPRC himg,int pid) int decode(HIMGPRC himg, int pid, LPSCANCONF img_param, LPIMGPRCPARAM param)
{ {
return ((imgproc*)himg)->decode(pid); return ((imgproc*)himg)->decode(pid, img_param, param);
}
int init_auto_txt_hanld(HIMGPRC himg)
{
return ((imgproc*)himg)->init_auto_txt_hanld();
}
int free_auto_txt_hanld(HIMGPRC himg)
{
return ((imgproc*)himg)->free_auto_txt_hanld();
} }
int correct_text(HIMGPRC himg) int correct_text(HIMGPRC himg)
{ {
@ -1374,7 +1516,10 @@ namespace hg_imgproc
{ {
return ((imgproc*)himg)->ocr_auto_txtdirect(); return ((imgproc*)himg)->ocr_auto_txtdirect();
} }
int tesseract_auto_txtdirect(HIMGPRC himg)
{
return ((imgproc*)himg)->tesseract_auto_txtdirect();
}
int size_detection(HIMGPRC himg) int size_detection(HIMGPRC himg)
{ {
return ((imgproc*)himg)->size_detection(); return ((imgproc*)himg)->size_detection();

8
hgdriver/hgdev/image_process.h
View File

@ -161,14 +161,16 @@ namespace hg_imgproc
}IMGHEAD, *LPIMGHEAD; }IMGHEAD, *LPIMGHEAD;
HIMGPRC init(LPSCANCONF parameter,LPIMGPRCPARAM param,int pid); HIMGPRC init(int pid);
int load_buffer(HIMGPRC himg,std::shared_ptr<tiny_buffer> buff); int load_buffer(HIMGPRC himg,std::shared_ptr<tiny_buffer> buff);
int load_file(HIMGPRC himg, const char* path_file); int load_file(HIMGPRC himg, const char* path_file);
//图像数据转换 //图像数据转换
int decode(HIMGPRC himg,int pid); int decode(HIMGPRC himg,int pid, LPSCANCONF img_param, LPIMGPRCPARAM param);
int correct_text(HIMGPRC himg); int correct_text(HIMGPRC himg);
int init_auto_txt_hanld(HIMGPRC himg);
int free_auto_txt_hanld(HIMGPRC himg);
//拆分 //拆分
int split(HIMGPRC himg,int split3399); int split(HIMGPRC himg,int split3399);
int fadeback(HIMGPRC himg); int fadeback(HIMGPRC himg);
@ -191,11 +193,11 @@ namespace hg_imgproc
int errorextention(HIMGPRC himg); int errorextention(HIMGPRC himg);
int discardBlank(HIMGPRC himg); int discardBlank(HIMGPRC himg);
int answerSheetFilterRed(HIMGPRC himg); int answerSheetFilterRed(HIMGPRC himg);
int imgtypechange(HIMGPRC himg,std::string img_type_,void *buf,std::vector<unsigned char> &bmpdata); int imgtypechange(HIMGPRC himg,std::string img_type_,void *buf,std::vector<unsigned char> &bmpdata);
int fold(HIMGPRC himg); int fold(HIMGPRC himg);
int quality(HIMGPRC himg,int dpi); int quality(HIMGPRC himg,int dpi);
int ocr_auto_txtdirect(HIMGPRC himg); int ocr_auto_txtdirect(HIMGPRC himg);
int tesseract_auto_txtdirect(HIMGPRC himg);
int size_detection(HIMGPRC himg); int size_detection(HIMGPRC himg);
int final(HIMGPRC himg); int final(HIMGPRC himg);