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

Merge branch 'master' of http://192.168.100.140:8099/sane/code_device

This commit is contained in:
gb 2022-11-26 14:20:07 +08:00
parent 2f1fcafa4f aa36e31730
commit ff42cded69
15 changed files with 46 additions and 1797 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
hgdriver/hgdev/hg_scanner.cpp
View File

@ -2017,6 +2017,7 @@ int hg_scanner::on_scanner_closing(bool force)
{ {
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
void hg_scanner::thread_handle_usb_read(void) void hg_scanner::thread_handle_usb_read(void)
{ {
} }

8
hgdriver/hgdev/hg_scanner.h
View File

@ -95,7 +95,6 @@ class hg_scanner
void working_begin(void*); void working_begin(void*);
void working_done(void*); void working_done(void*);
void image_process(std::shared_ptr<tiny_buffer>& buff); void image_process(std::shared_ptr<tiny_buffer>& buff);
void reset_custom_area_range(int paper); void reset_custom_area_range(int paper);
float reset_custom_area_jsn_value(const char* name, double& var, float range_l, float range_u, float value_l, float value_u); // return cur value float reset_custom_area_jsn_value(const char* name, double& var, float range_l, float range_u, float value_l, float value_u); // return cur value
@ -274,8 +273,6 @@ protected:
double isremove_low_hole_threshold; //设置下边除穿孔阈值 double isremove_low_hole_threshold; //设置下边除穿孔阈值
int fold_type_; //对折类型 int fold_type_; //对折类型
int split3399_; //3399设备正面和反面图像是相对的，所以对折时反面需要进行特殊处理 int split3399_; //3399设备正面和反面图像是相对的，所以对折时反面需要进行特殊处理
int pid_; int pid_;
bool is_kernelsnap_220830_; //此版本支持待纸扫描，手动睡眠唤醒，分纸强度 bool is_kernelsnap_220830_; //此版本支持待纸扫描，手动睡眠唤醒，分纸强度
@ -356,8 +353,6 @@ public:
std::string name(void); std::string name(void);
int status(void); int status(void);
bool is_online(void); bool is_online(void);
public: public:
virtual int start(void); virtual int start(void);
virtual int get_image_info(SANE_Parameters* ii); virtual int get_image_info(SANE_Parameters* ii);
@ -365,16 +360,13 @@ public:
virtual int stop(void); virtual int stop(void);
virtual int reset(void); virtual int reset(void);
virtual int device_io_control(unsigned long code, void* data, unsigned* len); virtual int device_io_control(unsigned long code, void* data, unsigned* len);
public: public:
hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io); hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io);
virtual ~hg_scanner(); virtual ~hg_scanner();
static std::string temporary_file(char* tail = NULL, char* head = NULL); static std::string temporary_file(char* tail = NULL, char* head = NULL);
static int save_2_tempory_file(std::shared_ptr<std::vector<char>> data, std::string* path_file, unsigned int index = 0); static int save_2_tempory_file(std::shared_ptr<std::vector<char>> data, std::string* path_file, unsigned int index = 0);
public: public:
virtual std::string get_firmware_version(void); virtual std::string get_firmware_version(void);
virtual std::string get_serial_num(void); virtual std::string get_serial_num(void);
virtual std::string get_ip(void); virtual std::string get_ip(void);

262
hgdriver/hgdev/hg_scanner_200.cpp
View File

@ -72,7 +72,6 @@ namespace settingsdsp_200
return code; return code;
} }
} }
hg_scanner_200::hg_scanner_200(const char* dev_name,int pid, usb_io* io) : hg_scanner(G100Serial, dev_name, io) hg_scanner_200::hg_scanner_200(const char* dev_name,int pid, usb_io* io) : hg_scanner(G100Serial, dev_name, io)
{ {
pid_ = pid; pid_ = pid;
@ -86,12 +85,9 @@ hg_scanner_200::hg_scanner_200(const char* dev_name,int pid, usb_io* io) : hg_sc
#endif #endif
if (init_settings(0x200)) if (init_settings(0x200))
init_settings((jsontext1 + jsontext2).c_str()); init_settings((jsontext1 + jsontext2).c_str());
printf_devconfig();
} }
hg_scanner_200::~hg_scanner_200() hg_scanner_200::~hg_scanner_200()
{} {}
void hg_scanner_200::discard_prev(void) void hg_scanner_200::discard_prev(void)
{ {
USBCB usb = { 0 }; USBCB usb = { 0 };
@ -121,7 +117,6 @@ void hg_scanner_200::discard_prev(void)
if (imgs || packets) if (imgs || packets)
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "discard prev-scanning %d packets and %d images.\n", packets, imgs); VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "discard prev-scanning %d packets and %d images.\n", packets, imgs);
} }
int hg_scanner_200::on_scanner_closing(bool force) int hg_scanner_200::on_scanner_closing(bool force)
{ {
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
@ -210,7 +205,6 @@ void hg_scanner_200::thread_handle_usb_read(void)
this_thread::sleep_for(chrono::milliseconds(2)); this_thread::sleep_for(chrono::milliseconds(2));
} }
} }
int hg_scanner_200::start(void) int hg_scanner_200::start(void)
{ {
bool handled = false; bool handled = false;
@ -232,35 +226,22 @@ int hg_scanner_200::start(void)
return ret; return ret;
} }
printf_devconfig(); printf_devconfig();
//writedown_device_configuration(true);
// ret = get_scan_is_sleep();
// if (ret == SCANNER_ERR_DEVICE_SLEEPING)
// {
// status_ = ret;
// notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_SCAN_FINISHED, status_);
// VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING);
// return ret;
// }
ret = get_scanner_paperon(); ret = get_scanner_paperon();
if (ret == SCANNER_ERR_DEVICE_NO_PAPER) if (ret == SCANNER_ERR_DEVICE_NO_PAPER)
{ {
status_ = ret; status_ = ret;
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER); VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER);
return ret; return ret;
} }
USBCB usb = { setting3288dsp::START_COMMAND, img_conf_.scannum, 0 }; USBCB usb = { setting3288dsp::START_COMMAND, img_conf_.scannum, 0 };
ret = writeusb(usb); ret = writeusb(usb);
io_->set_timeout(500); io_->set_timeout(500);
VLOG_MINI_1(LOG_LEVEL_WARNING, "write start command = %s\n", hg_scanner_err_name(ret)); VLOG_MINI_1(LOG_LEVEL_WARNING, "write start command = %s\n", hg_scanner_err_name(ret));
if(ret == SCANNER_ERR_OK) if(ret == SCANNER_ERR_OK)
{ {
//status_ = SCANNER_ERR_DEVICE_BUSY;
wait_usb_.notify(); wait_usb_.notify();
std::this_thread::sleep_for(std::chrono::milliseconds(300)); std::this_thread::sleep_for(std::chrono::milliseconds(300));
ret = try_third_app_after_start(ret); ret = try_third_app_after_start(ret);
@ -288,8 +269,6 @@ int hg_scanner_200::stop(void)
{ {
status_ = SCANNER_ERR_DEVICE_STOPPED; status_ = SCANNER_ERR_DEVICE_STOPPED;
} }
//final_imgs_.clear();
return status_; return status_;
} }
int hg_scanner_200::writeusb(USBCB &usb) int hg_scanner_200::writeusb(USBCB &usb)
@ -405,8 +384,6 @@ int hg_scanner_200::get_img_data(unsigned int bytes, SANE_Image_Statu statu)
return ret; return ret;
} }
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)
{ {
if (!type) if (!type)
@ -436,7 +413,6 @@ int hg_scanner_200::writedown_device_configuration(bool type,setting_hardware::H
return ret; return ret;
} }
int hg_scanner_200::on_color_mode_changed(int& color_mode) int hg_scanner_200::on_color_mode_changed(int& color_mode)
{ {
dsp_config_.params_dsp.color = (color_mode == COLOR_MODE_BLACK_WHITE || color_mode == COLOR_MODE_256_GRAY) ? 0 : 1; dsp_config_.params_dsp.color = (color_mode == COLOR_MODE_BLACK_WHITE || color_mode == COLOR_MODE_256_GRAY) ? 0 : 1;
@ -486,7 +462,6 @@ int hg_scanner_200::on_paper_check_changed(bool& check)
} }
return ret; return ret;
} }
int hg_scanner_200::on_resolution_changed(int& dpi) int hg_scanner_200::on_resolution_changed(int& dpi)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -494,7 +469,6 @@ int hg_scanner_200::on_resolution_changed(int& dpi)
ret = writedown_device_configuration(); ret = writedown_device_configuration();
return ret; return ret;
} }
int hg_scanner_200::on_ultrasonic_check_changed(bool& check) int hg_scanner_200::on_ultrasonic_check_changed(bool& check)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -512,7 +486,6 @@ int hg_scanner_200::on_ultrasonic_check_changed(bool& check)
return ret; return ret;
} }
int hg_scanner_200::on_staple_check_changed(bool& check) int hg_scanner_200::on_staple_check_changed(bool& check)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -639,225 +612,7 @@ void hg_scanner_200::writedown_image_configuration(void)
ic.hardwarecaps.lowpowermode = LowPowerMode::Min_None; //暂无参数 设置休眠时间 两个参数3399未使用 ic.hardwarecaps.lowpowermode = LowPowerMode::Min_None; //暂无参数 设置休眠时间 两个参数3399未使用
image_configuration(ic); image_configuration(ic);
agreement(); //agreement();
// ic.papertype = paper_size_;
//
// if (is_lateral(image_prc_param_.bits.paper))
// ic.paperAlign = Rot270;
// else
// ic.paperAlign = Rot0;
//
// ic.en_sizecheck = dsp_config_.params_dsp.enable_sizecheck;
//
//if (image_prc_param_.bits.text_direction != TEXT_DIRECTION_AUTO)
// ic.imageRotateDegree = image_prc_param_.bits.text_direction;
//else
// ic.imageRotateDegree = 0;
//
// ic.is_duplex = (image_prc_param_.bits.page == PAGE_DOUBLE || image_prc_param_.bits.page == PAGE_OMIT_EMPTY ||
// image_prc_param_.bits.page == PAGE_OMIT_EMPTY_RECEIPT || image_prc_param_.bits.page ==PAGE_FOLIO);
//
// ic.en_fold = (image_prc_param_.bits.page == PAGE_FOLIO);
//
// ic.pixtype = image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH ? 2 : image_prc_param_.bits.color_mode;
//
// ic.automaticcolor = is_auto_matic_color;
// ic.automaticcolortype = 1;// ic.pixtype; //存疑
// ic.resolution_dst = resolution_;
// ic.resolution_native = 200;
//
// ic.gamma = (float)gamma_;
// ic.contrast = contrast_ ;
// ic.brightness = bright_ ;
// ic.threshold = threshold_;
// ic.is_autocontrast = 0; //无参数
// ic.is_autocrop = (ic.papertype == TwSS::None || ic.papertype ==TwSS::USStatement);
// ic.is_autodiscradblank_normal = image_prc_param_.bits.page == PAGE_OMIT_EMPTY;
// ic.discardblank_percent = omit_empty_level_; //默认20
// ic.is_autodiscradblank_vince = image_prc_param_.bits.page == PAGE_OMIT_EMPTY_RECEIPT;
// ic.is_switchfrontback = image_prc_param_.bits.exchange;
// ic.autodescrew = image_prc_param_.bits.automatic_skew;
// ic.multi_output_red = image_prc_param_.bits.rid_red;
// ic.hsvcorrect = image_prc_param_.bits.rid_answer_red;
//
// ic.sharpen = image_prc_param_.bits.sharpen;
// //ic.enhance_color = image_prc_param_.bits.rid_color;
// ic.fillbackground = image_prc_param_.bits.erase_black_frame;
// ic.is_convex = (image_prc_param_.bits.fill_background == FILL_BKG_CONVEX_POLYGON);
// ic.noise = image_prc_param_.bits.noise_optimize;
// ic.indent = margin_;
// ic.AutoCrop_threshold = threshold_;
//
// if (test_1_paper_)
// {
// LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n");
// ic.scannum = 1;
// }
// else
// {
// ic.scannum = scan_count_;
// }
//
//
// ic.is_backrotate180 = image_prc_param_.bits.rotate_back_180;
// ic.is_dogeardetection = image_prc_param_.bits.fractate_check;
//
// ic.hardwarecaps.en_skrewdetect = dsp_config_.params_dsp.screw_detect_enable;
// ic.hardwarecaps.en_doublefeed = dsp_config_.params_dsp.double_feed_enbale;
// ic.hardwarecaps.en_stapledetect = dsp_config_.params_dsp.stable_enbale;
// ic.hardwarecaps.skrewdetectlevel = dsp_config_.params_dsp.screw_detect_level;
// // ic.hardwarecaps.is_autopaper = dsp_config_.params_dsp.is_autopaper;
// ic.hardwarecaps.capturepixtype = 0; //暂无参数 获取图像类型
// ic.hardwarecaps.lowpowermode = LowPowerMode::Min_None; //暂无参数 设置休眠时间 两个参数3399未使用
//
// ic.fillhole.is_fillhole = image_prc_param_.bits.rid_hole;
// ic.fillhole.fillholeratio = rid_hole_range_;
// adjust_filling_hole(&ic);
//
// ic.detachnoise.is_detachnoise = image_prc_param_.bits.noise_optimize;
// ic.detachnoise.detachnoise = noise_range_;
//
//
// ic.is_autotext = image_prc_param_.bits.text_direction == TEXT_DIRECTION_AUTO ? 1 :0;
// ic.isfillcolor = is_color_fill;
// ic.refuseInflow = image_prc_param_.bits.is_permeate;
// ic.colorCorrection = 0;
// ic.removeMorr = image_prc_param_.bits.remove_morr;
// ic.errorExtention = image_prc_param_.bits.error_extention ;//暂无参数
// ic.textureRemove = image_prc_param_.bits.remove_txtture;//暂无参数
// ic.splitImage = image_prc_param_.bits.split;
//
// //custom_area_br_x_ *ic.resolution_dst /25.4;
// //custom_area_br_y_ *ic.resolution_dst /25.4;
//
// ic.cropRect.enable = custom_area_;
//
// int height = (custom_area_br_y_ *ic.resolution_dst) /25.4 - (custom_area_lt_y_ *ic.resolution_dst /25.4);
// int width = (custom_area_br_x_ *ic.resolution_dst) /25.4 - (custom_area_lt_x_ *ic.resolution_dst /25.4);
// ic.cropRect.height = height;
// ic.cropRect.width = width;
// ic.cropRect.x = custom_area_lt_x_ *ic.resolution_dst /25.4;
// ic.cropRect.y = custom_area_lt_y_ *ic.resolution_dst /25.4;
//
// ic.multiOutput = (MultiOutput)image_prc_param_.bits.multi_out;
// if (!is_multiout)
// {
// ic.multiOutput = MultiOutput::Unused;
// }
// ic.normalCrop = image_prc_param_.bits.dark_sample;
// ic.dogeardistabce = fractate_level_;
// ic.fadeback = image_prc_param_.bits.erase_bakground;
// ic.fadebackrange = erase_bkg_range_;
// ic.isuoloadexceptionimage = (double_paper_handle_ & DOUBLE_PAPER_SAVE_IMG) == DOUBLE_PAPER_SAVE_IMG;
// ic.fold_concatmode = fold_type_;
// int filter_clr[] = { 3, 0, 1, 2, 5, 6, 7 };
// if(image_prc_param_.bits.color_mode == COLOR_MODE_24_BITS || image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH)
// ic.filter = 3;
// else
// {
// ic.filter = filter_clr[image_prc_param_.bits.rid_color];
// // if(ic.filter != 3)
// // ic.pixtype = 2;
//
// ic.hsvcorrect = 0;
// ic.multi_output_red = 0;
// ic.multiOutput = MultiOutput::Unused;
// ic.fadeback = false;
// }
// //多留输出的处理
// if (image_prc_param_.bits.multi_out == MULTI_GRAY_AND_BW && is_multiout)
// {
// ic.pixtype = 1;
// }
// else if ((image_prc_param_.bits.multi_out == MULTI_OUT_ALL ||image_prc_param_.bits.multi_out == MULTI_COLOR_AND_GRAY||image_prc_param_.bits.multi_out == MULTI_COLOR_AND_BW) && is_multiout)
// {
// ic.pixtype = 2;
// }
// if (is_multiout)
// {
// ic.hsvcorrect = 0;
// ic.multi_output_red = 0;
// ic.fadeback = false;
// ic.sharpen = 0;
// ic.removeMorr = 0;
// ic.textureRemove = 0;
//
// ic.errorExtention = 0;
// ic.detachnoise.is_detachnoise = 0;
// }
// if (ic.pixtype == 0)
// {
// ic.hsvcorrect = 0;
// ic.multi_output_red = 0;
// ic.fadeback = false;
// ic.sharpen = 0;
// ic.removeMorr = 0;
// ic.textureRemove = 0;
// }
//
// //自定义裁切
// if (image_prc_param_.bits.paper == PAPER_AUTO_MATCH
// ||image_prc_param_.bits.paper == PAPER_MAX_SIZE
// ||image_prc_param_.bits.paper == PAPER_MAX_SIZE_CLIP
// ||image_prc_param_.bits.paper == PAPER_TRIGEMINY
// )
// {
// ic.cropRect.enable = false;
// }
// img_conf_ = ic;
//
// agreement();
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.multi_output_red=%d", ic.multi_output_red);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.refuseInflow=%d\r ", ic.refuseInflow);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.textureRemove);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%f\r\n ", ic.fillhole.fillholeratio);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r\n ",ic.cropRect.enable);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ",ic.cropRect.height);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ",ic.cropRect.width);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%d\r\n ",ic.cropRect.x);
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y);
} }
void hg_scanner_200::printf_devconfig(setting_hardware::HGSCANCONF_DSP *d) void hg_scanner_200::printf_devconfig(setting_hardware::HGSCANCONF_DSP *d)
{ {
@ -894,8 +649,7 @@ std::string hg_scanner_200::get_firmware_version()
return buf; return buf;
} }
std::string hg_scanner_200::get_serial_num()
std::string hg_scanner_200::get_serial_num()
{ {
char buf[20] = { 0 }; char buf[20] = { 0 };
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
@ -911,8 +665,6 @@ std::string hg_scanner_200::get_firmware_version()
return buf; return buf;
} }
int hg_scanner_200::agreement() int hg_scanner_200::agreement()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -928,14 +680,7 @@ int hg_scanner_200::agreement()
return ret; return ret;
} }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner_200::set_leaflet_scan(void) int hg_scanner_200::set_leaflet_scan(void)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -956,7 +701,6 @@ int hg_scanner_200::set_img_format(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_200::get_compression_format(void) int hg_scanner_200::get_compression_format(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -969,7 +713,6 @@ int hg_scanner_200::set_auto_color_type(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_200::get_device_code(void) int hg_scanner_200::get_device_code(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -1016,7 +759,6 @@ int hg_scanner_200::set_sleep_time(SANE_Power* setime)
return ret; return ret;
} }
int hg_scanner_200::get_dogear_distance(void) int hg_scanner_200::get_dogear_distance(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;

1
hgdriver/hgdev/hg_scanner_200.h
View File

@ -27,7 +27,6 @@ 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 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
virtual int on_paper_check_changed(bool& check); virtual int on_paper_check_changed(bool& check);

301
hgdriver/hgdev/hg_scanner_239.cpp
View File

File diff suppressed because one or more lines are too long

2
hgdriver/hgdev/hg_scanner_239.h
View File

@ -58,7 +58,7 @@ protected:
virtual int on_get_feedmode(int& feedmode) override;//获取分纸强度 virtual int on_get_feedmode(int& feedmode) override;//获取分纸强度
virtual int on_set_feedmode(int feedmode) override;//设置分纸强度 virtual int on_set_feedmode(int feedmode) override;//设置分纸强度
virtual int on_pic_type(bool& pic);//照片模式或者文本模式 virtual int on_pic_type(bool& pic);//照片模式或者文本模式
virtual int on_pick_paper(bool autostrength); virtual int on_pick_paper(bool autostrength); //自动分纸强度
virtual int on_pick_paper_threshold(double threshold); virtual int on_pick_paper_threshold(double threshold);
virtual int on_is_auto_paper(bool isautopaper);//待纸扫描 virtual int on_is_auto_paper(bool isautopaper);//待纸扫描
virtual void on_device_reconnected(void) override; virtual void on_device_reconnected(void) override;

256
hgdriver/hgdev/hg_scanner_300.cpp
View File

File diff suppressed because one or more lines are too long

13
hgdriver/hgdev/hg_scanner_300.h
View File

@ -25,27 +25,22 @@ 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 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
virtual int on_paper_check_changed(bool& check); virtual int on_paper_check_changed(bool& check);
virtual int on_resolution_changed(int& dpi); virtual int on_resolution_changed(int& dpi);
virtual int on_ultrasonic_check_changed(bool& check); virtual int on_ultrasonic_check_changed(bool& check);
virtual int on_staple_check_changed(bool& check); virtual int on_staple_check_changed(bool& check);
virtual int on_skew_check_changed(bool& check); virtual int on_skew_check_changed(bool& check);
virtual int on_skew_check_level_changed(int& check); virtual int on_skew_check_level_changed(int& check);
virtual int on_get_feedmode(int& feedmode);//获取分纸强度 virtual int on_get_feedmode(int& feedmode);//获取分纸强度
virtual int on_set_feedmode(int feedmode);//设置分纸强度 virtual int on_set_feedmode(int feedmode);//设置分纸强度
public: public:
hg_scanner_300(const char* dev_name,int pid, usb_io* io); hg_scanner_300(const char* dev_name,int pid, usb_io* io);
~hg_scanner_300(); ~hg_scanner_300();
public: public:
virtual int start(void)override; virtual int start(void)override;
virtual int stop(void)override; virtual int stop(void)override;
private: private:
int agreement(TwSS tw,int align); int agreement(TwSS tw,int align);
int initdevice(); int initdevice();
@ -59,27 +54,21 @@ private:
void printf_devconfig(setting_hardware::HGSCANCONF_3288 *d = NULL); void printf_devconfig(setting_hardware::HGSCANCONF_3288 *d = NULL);
virtual std::string get_firmware_version() override; virtual std::string get_firmware_version() override;
virtual std::string get_serial_num(void) override; virtual std::string get_serial_num(void) override;
private: private:
std::vector<int> savestatus_; std::vector<int> savestatus_;
setting_hardware::HGSCANCONF_3288 dsp_config; setting_hardware::HGSCANCONF_3288 dsp_config;
Device::PaperSize papersize; Device::PaperSize papersize;
public: public:
virtual int set_leaflet_scan(void);//单张扫描 virtual int set_leaflet_scan(void);//单张扫描
virtual int get_abuot_info(void);//获取软件关于信息 virtual int get_abuot_info(void);//获取软件关于信息
virtual int restore_default_setting(void);//恢复默认设置 virtual int restore_default_setting(void);//恢复默认设置
virtual int set_final_image_format(void); // 设置图像处理最终输出（final()）的图像数据格式 virtual int set_final_image_format(void); // 设置图像处理最终输出（final()）的图像数据格式
virtual int get_compression_format(void);//获取支持的压缩格式 virtual int get_compression_format(void);//获取支持的压缩格式
virtual int set_compression_format(void);//设置图像数据最终输出的压缩格式 virtual int set_compression_format(void);//设置图像数据最终输出的压缩格式
virtual int set_auto_color_type(void);// 设置自动匹配颜色模式 virtual int set_auto_color_type(void);// 设置自动匹配颜色模式
virtual int get_device_code(void);//获取设备编码 virtual int get_device_code(void);//获取设备编码
virtual int get_sleep_time(SANE_Power* setime = NULL);//获取功耗模式（休眠） virtual int get_sleep_time(SANE_Power* setime = NULL);//获取功耗模式（休眠）
virtual int set_sleep_time(SANE_Power* setime);//设置功耗模式（休眠） virtual int set_sleep_time(SANE_Power* setime);//设置功耗模式（休眠）
virtual int get_dogear_distance(void);//获取折角检测最小距离阈值 virtual int get_dogear_distance(void);//获取折角检测最小距离阈值
virtual int set_dogear_distance(void);// 设置折角检测最小距离阈值 virtual int set_dogear_distance(void);// 设置折角检测最小距离阈值
virtual int get_scanner_paperon(SANE_Bool* paperon=NULL);//获取设备有无纸张 virtual int get_scanner_paperon(SANE_Bool* paperon=NULL);//获取设备有无纸张
@ -87,9 +76,7 @@ public:
virtual int get_scan_when_paper_on(void);//设置是否为检测到进纸盘上有纸即开始扫描 virtual int get_scan_when_paper_on(void);//设置是否为检测到进纸盘上有纸即开始扫描
virtual int get_scan_with_hole(void);// 获取是否为带孔扫描 virtual int get_scan_with_hole(void);// 获取是否为带孔扫描
virtual int set_scan_with_hole(void);// 设置是否为带孔扫描 virtual int set_scan_with_hole(void);// 设置是否为带孔扫描
virtual int get_scan_is_sleep(void);//获取设备是否休眠当中 virtual int get_scan_is_sleep(void);//获取设备是否休眠当中
virtual int get_device_log(string &log);//获取设备日志 virtual int get_device_log(string &log);//获取设备日志
virtual int notify_sleep(void);//唤醒设备 virtual int notify_sleep(void);//唤醒设备
}; };

310
hgdriver/hgdev/hg_scanner_302.cpp
View File

File diff suppressed because one or more lines are too long

256
hgdriver/hgdev/hg_scanner_400.cpp
View File

@ -66,7 +66,6 @@ namespace settingsdsp_400
return code; return code;
} }
} }
hg_scanner_400::hg_scanner_400(const char* dev_name,int pid, usb_io* io) : hg_scanner(G100Serial, dev_name, io),papersize(pid) hg_scanner_400::hg_scanner_400(const char* dev_name,int pid, usb_io* io) : hg_scanner(G100Serial, dev_name, io),papersize(pid)
{ {
pid_ = pid; pid_ = pid;
@ -87,8 +86,6 @@ hg_scanner_400::hg_scanner_400(const char* dev_name,int pid, usb_io* io) : hg_sc
} }
hg_scanner_400::~hg_scanner_400() hg_scanner_400::~hg_scanner_400()
{} {}
int hg_scanner_400::on_scanner_closing(bool force) int hg_scanner_400::on_scanner_closing(bool force)
{ {
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
@ -178,7 +175,6 @@ void hg_scanner_400::thread_handle_usb_read(void)
this_thread::sleep_for(chrono::milliseconds(10)); this_thread::sleep_for(chrono::milliseconds(10));
} }
} }
int hg_scanner_400::start(void) int hg_scanner_400::start(void)
{ {
bool handled = false; bool handled = false;
@ -298,7 +294,6 @@ int hg_scanner_400::pop_image()
return ret; return ret;
} }
int hg_scanner_400::get_scanner_status(USBCB &usb) int hg_scanner_400::get_scanner_status(USBCB &usb)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -372,7 +367,6 @@ int hg_scanner_400::get_img_data(std::shared_ptr<tiny_buffer> &imagedata)
return ret; return ret;
} }
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)
@ -411,7 +405,6 @@ int hg_scanner_400::writedown_device_configuration(bool type,setting_hardware::H
return ret; return ret;
} }
int hg_scanner_400::on_color_mode_changed(int& color_mode) int hg_scanner_400::on_color_mode_changed(int& color_mode)
{ {
dsp_config.params_3288.isColor = (color_mode == COLOR_MODE_BLACK_WHITE || color_mode == COLOR_MODE_256_GRAY) ? 0 : 1; dsp_config.params_3288.isColor = (color_mode == COLOR_MODE_BLACK_WHITE || color_mode == COLOR_MODE_256_GRAY) ? 0 : 1;
@ -462,7 +455,6 @@ int hg_scanner_400::on_paper_check_changed(bool& check)
} }
return ret; return ret;
} }
int hg_scanner_400::on_resolution_changed(int& dpi) int hg_scanner_400::on_resolution_changed(int& dpi)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -470,7 +462,6 @@ int hg_scanner_400::on_resolution_changed(int& dpi)
ret = writedown_device_configuration(true); ret = writedown_device_configuration(true);
return ret; return ret;
} }
int hg_scanner_400::on_ultrasonic_check_changed(bool& check) int hg_scanner_400::on_ultrasonic_check_changed(bool& check)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -523,8 +514,6 @@ int hg_scanner_400::initdevice()
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
void hg_scanner_400::writedown_image_configuration(void) void hg_scanner_400::writedown_image_configuration(void)
{ {
SCANCONF ic; SCANCONF ic;
@ -552,247 +541,12 @@ void hg_scanner_400::writedown_image_configuration(void)
ic.hardwarecaps.en_doublefeed = dsp_config.params_3288.doubleFeeded; ic.hardwarecaps.en_doublefeed = dsp_config.params_3288.doubleFeeded;
ic.hardwarecaps.en_stapledetect = 0; ic.hardwarecaps.en_stapledetect = 0;
ic.hardwarecaps.skrewdetectlevel = 0; ic.hardwarecaps.skrewdetectlevel = 0;
// ic.hardwarecaps.is_autopaper = dsp_config_.params_dsp.is_autopaper; // ic.hardwarecaps.is_autopaper = dsp_config_.params_dsp.is_autopaper;
ic.hardwarecaps.capturepixtype = 0; //暂无参数 获取图像类型 ic.hardwarecaps.capturepixtype = 0; //暂无参数 获取图像类型
ic.hardwarecaps.lowpowermode = LowPowerMode::Min_None; //暂无参数 设置休眠时间 两个参数3399未使用 ic.hardwarecaps.lowpowermode = LowPowerMode::Min_None; //暂无参数 设置休眠时间 两个参数3399未使用
image_configuration(ic); image_configuration(ic);
int ret = agreement((TwSS)img_conf_.papertype, img_conf_.paperAlign); int ret = agreement((TwSS)img_conf_.papertype, img_conf_.paperAlign);
/*SCANCONF ic;
ic.papertype = paper_size_;
if (is_lateral(image_prc_param_.bits.paper))
ic.paperAlign = Rot270;
// else if (image_prc_param_.bits.text_direction == TEXT_DIRECTION_AUTO)
// ic.paperAlign = AutoTextOrientation;
else
ic.paperAlign = Rot0;
ic.en_sizecheck = dsp_config.params_3288.enableSizeDetect;
if (image_prc_param_.bits.text_direction != TEXT_DIRECTION_AUTO)
ic.imageRotateDegree = image_prc_param_.bits.text_direction;
else
ic.imageRotateDegree = 0;
ic.is_duplex = (image_prc_param_.bits.page == PAGE_DOUBLE || image_prc_param_.bits.page == PAGE_OMIT_EMPTY ||
image_prc_param_.bits.page == PAGE_OMIT_EMPTY_RECEIPT || image_prc_param_.bits.page ==PAGE_FOLIO);
ic.en_fold = (image_prc_param_.bits.page == PAGE_FOLIO);
ic.pixtype = image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH ? 2 : image_prc_param_.bits.color_mode;
ic.automaticcolor = is_auto_matic_color;
ic.automaticcolortype = 1;// ic.pixtype; //存疑
ic.resolution_dst = resolution_;
ic.resolution_native = 200;
ic.gamma = (float)gamma_;
ic.contrast = contrast_ ;
ic.brightness = bright_ ;
//printf("gamma_ :%f contrast_:%d bright_:%d\r\n",gamma_,contrast_,bright_);
ic.threshold = threshold_;
ic.is_autocontrast = 0; //无参数
ic.is_autocrop = (ic.papertype == TwSS::None || ic.papertype ==TwSS::USStatement);
ic.is_autodiscradblank_normal = image_prc_param_.bits.page == PAGE_OMIT_EMPTY;
ic.discardblank_percent = omit_empty_level_ > 70 ? 70 : omit_empty_level_; //默认20
ic.is_autodiscradblank_vince = image_prc_param_.bits.page == PAGE_OMIT_EMPTY_RECEIPT;
ic.is_switchfrontback = image_prc_param_.bits.exchange;
ic.autodescrew = image_prc_param_.bits.automatic_skew;
ic.multi_output_red = image_prc_param_.bits.rid_red;
ic.hsvcorrect = image_prc_param_.bits.rid_answer_red;
ic.sharpen = image_prc_param_.bits.sharpen;
//ic.enhance_color = image_prc_param_.bits.rid_color;
ic.fillbackground = image_prc_param_.bits.erase_black_frame;
ic.is_convex = (image_prc_param_.bits.fill_background == FILL_BKG_CONVEX_POLYGON);
ic.noise = image_prc_param_.bits.noise_optimize;
ic.indent = margin_;
ic.AutoCrop_threshold = threshold_;
if (test_1_paper_)
{
LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n");
ic.scannum = 1;
}
else
{
ic.scannum = scan_count_;
}
ic.is_backrotate180 = image_prc_param_.bits.rotate_back_180;
ic.is_dogeardetection = image_prc_param_.bits.fractate_check;
ic.hardwarecaps.en_skrewdetect = 0;
ic.hardwarecaps.en_doublefeed = dsp_config.params_3288.doubleFeeded;
ic.hardwarecaps.en_stapledetect = 0;
ic.hardwarecaps.skrewdetectlevel = 0;
// ic.hardwarecaps.is_autopaper = dsp_config.params_3288.is_autopaper;
ic.hardwarecaps.capturepixtype = 0; //暂无参数 获取图像类型
ic.hardwarecaps.lowpowermode = LowPowerMode::Min_None; //暂无参数 设置休眠时间 两个参数3399未使用
ic.fillhole.is_fillhole = image_prc_param_.bits.rid_hole;
ic.fillhole.fillholeratio = rid_hole_range_;
adjust_filling_hole(&ic);
ic.detachnoise.is_detachnoise = image_prc_param_.bits.noise_optimize;
ic.detachnoise.detachnoise = noise_range_;
ic.is_autotext = image_prc_param_.bits.text_direction == TEXT_DIRECTION_AUTO ? 1 :0;
ic.isfillcolor = is_color_fill;
ic.refuseInflow = image_prc_param_.bits.is_permeate;
ic.colorCorrection = 0;
ic.removeMorr = image_prc_param_.bits.remove_morr;
ic.errorExtention = image_prc_param_.bits.error_extention ;//暂无参数
ic.textureRemove = image_prc_param_.bits.remove_txtture;//暂无参数
ic.splitImage = image_prc_param_.bits.split;
ic.cropRect.enable = custom_area_;
int height = (custom_area_br_y_ *ic.resolution_dst) /25.4 - (custom_area_lt_y_ *ic.resolution_dst /25.4);
int width = (custom_area_br_x_ *ic.resolution_dst) /25.4 - (custom_area_lt_x_ *ic.resolution_dst /25.4);
ic.cropRect.height = height;
ic.cropRect.width = width;
ic.cropRect.x = custom_area_lt_x_ *ic.resolution_dst /25.4;
ic.cropRect.y = custom_area_lt_y_ *ic.resolution_dst /25.4;
ic.multiOutput = (MultiOutput)image_prc_param_.bits.multi_out;
if (!is_multiout)
{
ic.multiOutput = MultiOutput::Unused;
}
ic.normalCrop = image_prc_param_.bits.dark_sample;
ic.dogeardistabce = fractate_level_;
ic.fadeback = image_prc_param_.bits.erase_bakground;
ic.fadebackrange = erase_bkg_range_;
ic.isuoloadexceptionimage = (double_paper_handle_ & DOUBLE_PAPER_SAVE_IMG) == DOUBLE_PAPER_SAVE_IMG;
ic.fold_concatmode = fold_type_;
int filter_clr[] = { 3, 0, 1, 2, 5, 6, 7 };
if(image_prc_param_.bits.color_mode == COLOR_MODE_24_BITS || image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH)
ic.filter = 3;
else
{
ic.filter = filter_clr[image_prc_param_.bits.rid_color];
// if(ic.filter != 3)
// ic.pixtype = 2;
ic.hsvcorrect = 0;
ic.multi_output_red = 0;
ic.multiOutput = MultiOutput::Unused;
ic.fadeback = false;
}
//多留输出的处理
if (image_prc_param_.bits.multi_out == MULTI_GRAY_AND_BW && is_multiout)
{
ic.pixtype = 1;
}
else if ((image_prc_param_.bits.multi_out == MULTI_OUT_ALL ||image_prc_param_.bits.multi_out == MULTI_COLOR_AND_GRAY||image_prc_param_.bits.multi_out == MULTI_COLOR_AND_BW) && is_multiout)
{
ic.pixtype = 2;
}
if (is_multiout)
{
ic.hsvcorrect = 0;
ic.multi_output_red = 0;
ic.fadeback = false;
ic.sharpen = 0;
ic.removeMorr = 0;
ic.textureRemove = 0;
ic.errorExtention = 0;
ic.detachnoise.is_detachnoise = 0;
}
if (ic.pixtype == 0)
{
ic.hsvcorrect = 0;
ic.multi_output_red = 0;
ic.fadeback = false;
ic.sharpen = 0;
ic.removeMorr = 0;
ic.textureRemove = 0;
}
//自定义裁切
if (image_prc_param_.bits.paper == PAPER_AUTO_MATCH
||image_prc_param_.bits.paper == PAPER_MAX_SIZE
||image_prc_param_.bits.paper == PAPER_MAX_SIZE_CLIP
||image_prc_param_.bits.paper == PAPER_TRIGEMINY
)
{
ic.cropRect.enable = false;
}
img_conf_ = ic;
int ret = agreement((TwSS)img_conf_.papertype,img_conf_.paperAlign);
if (ret != SCANNER_ERR_OK)
{
status_ = ret;
return ;
}
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.isfillcolor=%d", ic.isfillcolor);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.multi_output_red=%d", ic.multi_output_red);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.refuseInflow=%d\r ", ic.refuseInflow);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.textureRemove);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%f\r\n ", ic.fillhole.fillholeratio);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r ", ic.cropRect.enable);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ", ic.cropRect.width);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ", ic.cropRect.height);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%f\r\n ", ic.cropRect.x);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y);
*/
} }
void hg_scanner_400::printf_devconfig(setting_hardware::HGSCANCONF_3288 *d) void hg_scanner_400::printf_devconfig(setting_hardware::HGSCANCONF_3288 *d)
{ {
if (!d) if (!d)
@ -811,7 +565,6 @@ void hg_scanner_400::printf_devconfig(setting_hardware::HGSCANCONF_3288 *d)
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.enableSizeDetect:%d\r\n",d->params_3288.enableSizeDetect); VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.enableSizeDetect:%d\r\n",d->params_3288.enableSizeDetect);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.value:%d\r\n",d->value); VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.value:%d\r\n",d->value);
} }
std::string hg_scanner_400::get_firmware_version() std::string hg_scanner_400::get_firmware_version()
{ {
char buf[20] = { 0 }; char buf[20] = { 0 };
@ -825,7 +578,6 @@ std::string hg_scanner_400::get_firmware_version()
return buf; return buf;
} }
std::string hg_scanner_400::get_serial_num() std::string hg_scanner_400::get_serial_num()
{ {
char buf[20] = { 0 }; char buf[20] = { 0 };
@ -843,9 +595,7 @@ std::string hg_scanner_400::get_firmware_version()
return buf; return buf;
} }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner_400::set_leaflet_scan(void) int hg_scanner_400::set_leaflet_scan(void)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -867,7 +617,6 @@ int hg_scanner_400::set_final_image_format(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_400::get_compression_format(void) int hg_scanner_400::get_compression_format(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -880,7 +629,6 @@ int hg_scanner_400::set_auto_color_type(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_400::get_device_code(void) int hg_scanner_400::get_device_code(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -915,7 +663,6 @@ int hg_scanner_400::set_sleep_time(int setsleepime)
return ret;; return ret;;
} }
int hg_scanner_400::get_dogear_distance(void) int hg_scanner_400::get_dogear_distance(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -996,9 +743,6 @@ int hg_scanner_400::get_scan_is_sleep()
return SCANNER_ERR_DEVICE_SLEEPING; return SCANNER_ERR_DEVICE_SLEEPING;
} }
} }
////////////////////////////////start///////////////////////////// ////////////////////////////////start/////////////////////////////
///此款设备无此功能暂时预留 ///此款设备无此功能暂时预留
int hg_scanner_400::on_staple_check_changed(bool& check) int hg_scanner_400::on_staple_check_changed(bool& check)

319
hgdriver/hgdev/hg_scanner_402.cpp
View File

@ -159,7 +159,6 @@ hg_scanner_402::~hg_scanner_402()
{ {
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "hg_scanner_402(%s) destroyed.\n", hg_log::format_ptr(this).c_str()); VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "hg_scanner_402(%s) destroyed.\n", hg_log::format_ptr(this).c_str());
} }
int hg_scanner_402::read_register(int addr, int* val) int hg_scanner_402::read_register(int addr, int* val)
{ {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
@ -220,7 +219,6 @@ std::string hg_scanner_402::control_fetch(int addr, int val, int size)
return data; return data;
} }
std::string hg_scanner_402::get_fpga(void) std::string hg_scanner_402::get_fpga(void)
{ {
int val = 0, int val = 0,
@ -398,23 +396,11 @@ 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);
return ret; return ret;
} }
int hg_scanner_402::get_device_paperon_stautus(void) int hg_scanner_402::get_device_paperon_stautus(void)
{ {
int ret =read_register(setting3399::SR_GET_PAPERON,0); int ret =read_register(setting3399::SR_GET_PAPERON,0);
return ret; return ret;
} }
// int hg_scanner_402::writedown_device_configuration()
// {
// int ret = SCANNER_ERR_OK;
// ret = write_register(SR_CONFIG_SCAN_PARAM, dev_conf_.value);
// VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf_.value, hg_scanner_err_name(ret));
// return ret;
// }
int hg_scanner_402::writedown_device_configuration(bool type, setting_hardware::HGSCANCONF_3399* dev_conf) int hg_scanner_402::writedown_device_configuration(bool type, setting_hardware::HGSCANCONF_3399* dev_conf)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -451,13 +437,8 @@ int hg_scanner_402::writedown_device_configuration(bool type, setting_hardware::
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf->value, hg_scanner_err_name(ret)); VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf->value, hg_scanner_err_name(ret));
return ret; return ret;
} }
int hg_scanner_402::writedown_image_configuration(void) int hg_scanner_402::writedown_image_configuration(void)
{ {
//int ret = write_register(SR_CONFIF_IMGPROCPARAM, sizeof(SCANCONF));
//if (ret != SCANNER_ERR_OK)
// return ret;
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
SCANCONF ic; SCANCONF ic;
int len = sizeof(ic); int len = sizeof(ic);
@ -497,258 +478,8 @@ int hg_scanner_402::writedown_image_configuration(void)
this_thread::sleep_for(chrono::milliseconds(500)); this_thread::sleep_for(chrono::milliseconds(500));
io_->set_timeout(2000);//必要延时 io_->set_timeout(2000);//必要延时
} }
/*int ret = SCANNER_ERR_OK;
SCANCONF ic;
int len = sizeof(ic);
bzero(&ic, len);
ic.papertype = paper_size_;
if (is_lateral(image_prc_param_.bits.paper))
ic.paperAlign = Rot270;
// else if (image_prc_param_.bits.text_direction == TEXT_DIRECTION_AUTO)
// ic.paperAlign = AutoTextOrientation;
else
ic.paperAlign = Rot0;
ic.en_sizecheck = dev_conf_.params_3399.enable_sizecheck;
if (image_prc_param_.bits.text_direction != TEXT_DIRECTION_AUTO)
ic.imageRotateDegree = (float)image_prc_param_.bits.text_direction;
else
ic.imageRotateDegree = 0;
ic.is_duplex = (image_prc_param_.bits.page == PAGE_DOUBLE
|| image_prc_param_.bits.page == PAGE_OMIT_EMPTY
|| image_prc_param_.bits.page == PAGE_OMIT_EMPTY_RECEIPT
|| image_prc_param_.bits.page ==PAGE_FOLIO);
ic.en_fold = (image_prc_param_.bits.page == PAGE_FOLIO);
ic.pixtype = image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH ? 2 : image_prc_param_.bits.color_mode;
ic.automaticcolor = is_auto_matic_color;
ic.automaticcolortype = 1;// ic.pixtype; //存疑
if (resolution_ >= 300)
{
if(is_quality_ == IMG_SPEED)
{
ic.resolution_dst = 200;
}
else if(is_quality_ ==IMG_QUALITY)
{
ic.resolution_dst = resolution_;
}
else
{
ic.resolution_dst = resolution_;
}
}
else
{
ic.resolution_dst = resolution_;
}
ic.resolution_native = 200.0f;
ic.gamma = (float)gamma_;
ic.contrast = (contrast_ - 4) * 333.0;
ic.brightness = (bright_ - 128) * (2000.0 / 254.0);
ic.threshold = threshold_;
ic.is_autocontrast = 0; //无参数
ic.is_autocrop = (ic.papertype == TwSS::None || ic.papertype ==TwSS::USStatement);
ic.is_autodiscradblank_normal = image_prc_param_.bits.page == PAGE_OMIT_EMPTY;
ic.discardblank_percent = omit_empty_level_ >= 70 ? 70 : omit_empty_level_;
ic.is_autodiscradblank_vince = image_prc_param_.bits.page == PAGE_OMIT_EMPTY_RECEIPT;
ic.is_switchfrontback = image_prc_param_.bits.exchange;
ic.autodescrew = image_prc_param_.bits.automatic_skew;
ic.multi_output_red = image_prc_param_.bits.rid_red;
ic.hsvcorrect = image_prc_param_.bits.rid_answer_red;
ic.sharpen = image_prc_param_.bits.sharpen;
ic.enhance_color = image_prc_param_.bits.rid_color;
ic.fillbackground = image_prc_param_.bits.erase_black_frame;
ic.is_convex = (image_prc_param_.bits.fill_background == FILL_BKG_CONVEX_POLYGON);
ic.noise = image_prc_param_.bits.noise_optimize;
ic.indent = margin_;
ic.AutoCrop_threshold = threshold_;
if (test_1_paper_)
{
LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n");
ic.scannum = //ic.is_duplex ? 2 :// 1;
}
else
{
if (scan_count_ == -1)
ic.scannum = -1;
else
ic.scannum = scan_count_; // (ic.is_duplex ? scan_count_ * 2 : scan_count_);
}
ic.is_backrotate180 = image_prc_param_.bits.rotate_back_180;
ic.is_dogeardetection = image_prc_param_.bits.fractate_check;
ic.hardwarecaps.en_skrewdetect = dev_conf_.params_3399.screw_detect_enable;
ic.hardwarecaps.en_doublefeed = dev_conf_.params_3399.ultrasonic_enable;
ic.hardwarecaps.en_stapledetect = dev_conf_.params_3399.staple_enbale;
ic.hardwarecaps.skrewdetectlevel = dev_conf_.params_3399.screw_detect_level;
// ic.hardwarecaps.is_autopaper = dev_conf_.params_3399.is_autopaper;
ic.hardwarecaps.capturepixtype = 0; //暂无参数 获取图像类型
ic.hardwarecaps.lowpowermode = LowPowerMode::Min_None; //暂无参数 设置休眠时间 两个参数3399未使用
ic.fillhole.is_fillhole = image_prc_param_.bits.rid_hole;
ic.fillhole.fillholeratio = rid_hole_range_;
adjust_filling_hole(&ic);
ic.detachnoise.is_detachnoise = image_prc_param_.bits.noise_optimize;
ic.detachnoise.detachnoise = noise_range_;
ic.is_autotext = image_prc_param_.bits.text_direction == TEXT_DIRECTION_AUTO ? 1 :0;
ic.isfillcolor = is_color_fill;
ic.refuseInflow = image_prc_param_.bits.is_permeate;
ic.colorCorrection = 0;
ic.removeMorr = image_prc_param_.bits.remove_morr;
ic.errorExtention = image_prc_param_.bits.error_extention ;//
ic.textureRemove = image_prc_param_.bits.remove_txtture;//
ic.splitImage = image_prc_param_.bits.split;
{
ic.cropRect.enable = custom_area_;
int height = (custom_area_br_y_ *ic.resolution_dst) /25.4 - (custom_area_lt_y_ *ic.resolution_dst /25.4);
int width = (custom_area_br_x_ *ic.resolution_dst) /25.4 - (custom_area_lt_x_ *ic.resolution_dst /25.4);
ic.cropRect.height = height;
ic.cropRect.width = width;
ic.cropRect.x = custom_area_lt_x_ *ic.resolution_dst /25.4;
ic.cropRect.y = custom_area_lt_y_ *ic.resolution_dst /25.4;
}
ic.multiOutput = (MultiOutput)image_prc_param_.bits.multi_out;
if (!is_multiout)
{
ic.multiOutput = MultiOutput::Unused;
}
ic.normalCrop = image_prc_param_.bits.dark_sample;
ic.dogeardistabce = fractate_level_;
ic.fadeback = image_prc_param_.bits.erase_bakground;
ic.fadebackrange = erase_bkg_range_;
ic.isuoloadexceptionimage = (double_paper_handle_ & DOUBLE_PAPER_SAVE_IMG) == DOUBLE_PAPER_SAVE_IMG;
ic.fold_concatmode = fold_type_;
int filter_clr[] = { 3, 0, 1, 2, 5, 6, 7 };
if(image_prc_param_.bits.color_mode == COLOR_MODE_24_BITS || image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH)
ic.filter = 3;
else
{
ic.filter = filter_clr[ic.enhance_color];
// if(ic.filter != 3)
// ic.pixtype = 2;
ic.hsvcorrect = 0;
ic.multi_output_red = 0;
ic.multiOutput = MultiOutput::Unused;
}
//多留输出的处理
if (ic.multiOutput == MULTI_GRAY_AND_BW && is_multiout)
{
ic.pixtype = 1;
}
else if ((ic.multiOutput == MULTI_OUT_ALL ||ic.multiOutput == MULTI_COLOR_AND_GRAY||ic.multiOutput == MULTI_COLOR_AND_BW) && is_multiout)
{
ic.pixtype = 2;
}
if (is_multiout)
{
ic.hsvcorrect = 0;
ic.multi_output_red = 0;
ic.fadeback = false;
ic.sharpen = 0;
ic.removeMorr = 0;
ic.textureRemove = 0;
ic.errorExtention = 0;
ic.detachnoise.is_detachnoise = 0;
}
if (ic.pixtype == 0)
{
ic.hsvcorrect = 0;
ic.multi_output_red = 0;
ic.fadeback = false;
ic.sharpen = 0;
ic.removeMorr = 0;
ic.textureRemove = 0;
}
//自定义裁切
if (image_prc_param_.bits.paper == PAPER_AUTO_MATCH
||image_prc_param_.bits.paper == PAPER_MAX_SIZE
||image_prc_param_.bits.paper == PAPER_MAX_SIZE_CLIP
||image_prc_param_.bits.paper == PAPER_TRIGEMINY
)
{
ic.cropRect.enable = false;
}
//{
// std::lock_guard<std::mutex> lock(io_lock_);
//
// ret = io_->write_bulk(&ic, &len);
//
// this_thread::sleep_for(chrono::milliseconds(500));
// io_->set_timeout(2000);//必要延时
//}
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Write-down 0x%x bytes image process parameters\n", len);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.multi_output_red=%d", ic.multi_output_red);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.refuseInflow);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%d\r\n ", ic.fillhole.fillholeratio);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r ", ic.cropRect.enable);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ", ic.cropRect.width);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ", ic.cropRect.height);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%f\r\n ", ic.cropRect.x);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y);
img_conf_ = ic;
*/
return ret; return ret;
} }
int hg_scanner_402::pop_first_image(void) int hg_scanner_402::pop_first_image(void)
{ {
int ret = write_register(setting3399::SR_IM_POP, 1); int ret = write_register(setting3399::SR_IM_POP, 1);
@ -757,7 +488,6 @@ int hg_scanner_402::pop_first_image(void)
return ret; return ret;
} }
int hg_scanner_402::read_one_image_from_usb(SANE_Image_Statu statu) int hg_scanner_402::read_one_image_from_usb(SANE_Image_Statu statu)
{ {
int r = 0, int r = 0,
@ -882,8 +612,6 @@ void hg_scanner_402::discard_all_images(void)
if (pre_int) if (pre_int)
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "prev-connection has left %d interrupt packet(s) && %d image(s).\n", pre_int, pre_img); VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "prev-connection has left %d interrupt packet(s) && %d image(s).\n", pre_int, pre_img);
} }
int hg_scanner_402::on_color_mode_changed(int& color_mode) int hg_scanner_402::on_color_mode_changed(int& color_mode)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -967,35 +695,10 @@ int hg_scanner_402::on_paper_check_changed(bool& check)
} }
int hg_scanner_402::on_resolution_changed(int& dpi) int hg_scanner_402::on_resolution_changed(int& dpi)
{ {
//bool exact = true;
//int ind = settings402::match_best_resolution(dpi, &exact),
// ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT;
//if (dev_conf_.params_3399.dpi != settings402::resolution_map[ind].dev_value)
//{
// int old = dev_conf_.params_3399.dpi;
// dev_conf_.params_3399.dpi = settings402::resolution_map[ind].dev_value;
// dev_conf_.params_3399.dpi = 1;
// ret = writedown_device_configuration();
// if (ret)
// {
// dev_conf_.params_3399.dpi = old;
// }
// else if (!exact)
// ret = SCANNER_ERR_NOT_EXACT;
//}
//
//if (ret == SCANNER_ERR_NOT_EXACT)
// dpi = settings402::resolution_map[ind].resolution;
//
//
//return ret;
dev_conf_.params_3399.dpi = 1; //dpi 华凌cis和敦南cis 默认发1无需改变 dev_conf_.params_3399.dpi = 1; //dpi 华凌cis和敦南cis 默认发1无需改变
int ret = writedown_device_configuration(); int ret = writedown_device_configuration();
return ret; return ret;
} }
int hg_scanner_402::on_ultrasonic_check_changed(bool& check) int hg_scanner_402::on_ultrasonic_check_changed(bool& check)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -1010,7 +713,6 @@ int hg_scanner_402::on_ultrasonic_check_changed(bool& check)
check = dev_conf_.params_3399.ultrasonic_enable; check = dev_conf_.params_3399.ultrasonic_enable;
} }
} }
return ret; return ret;
} }
int hg_scanner_402::on_staple_check_changed(bool& check) int hg_scanner_402::on_staple_check_changed(bool& check)
@ -1027,7 +729,6 @@ int hg_scanner_402::on_staple_check_changed(bool& check)
check = dev_conf_.params_3399.staple_enbale; check = dev_conf_.params_3399.staple_enbale;
} }
} }
return ret; return ret;
} }
int hg_scanner_402::on_skew_check_changed(bool& check) int hg_scanner_402::on_skew_check_changed(bool& check)
@ -1044,7 +745,6 @@ int hg_scanner_402::on_skew_check_changed(bool& check)
check = dev_conf_.params_3399.screw_detect_enable; check = dev_conf_.params_3399.screw_detect_enable;
} }
} }
return ret; return ret;
} }
int hg_scanner_402::on_skew_check_level_changed(int& check) int hg_scanner_402::on_skew_check_level_changed(int& check)
@ -1078,10 +778,8 @@ int hg_scanner_402::on_skew_check_level_changed(int& check)
check = val; check = val;
ret = SCANNER_ERR_NOT_EXACT; ret = SCANNER_ERR_NOT_EXACT;
} }
return ret; return ret;
} }
int hg_scanner_402:: on_get_feedmode(int &feedmode)//获取分纸强度 int hg_scanner_402:: on_get_feedmode(int &feedmode)//获取分纸强度
{ {
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
@ -1115,7 +813,6 @@ int hg_scanner_402::on_scanner_closing(bool force)
{ {
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
void hg_scanner_402::thread_handle_usb_read(void) void hg_scanner_402::thread_handle_usb_read(void)
{ {
char buf[32] = { 0 }; char buf[32] = { 0 };
@ -1146,13 +843,6 @@ void hg_scanner_402::thread_handle_usb_read(void)
if (to_cnt++ < 30) if (to_cnt++ < 30)
{ {
std::this_thread::sleep_for(std::chrono::milliseconds(500)); std::this_thread::sleep_for(std::chrono::milliseconds(500));
//int statu = get_status();
//if ((statu & 0x03) == 0)
//{
// VLOG_MINI_1(LOG_LEVEL_FATAL, "USB thread over with status: 0x%x\n", statu);
// status_ = SCANNER_ERR_OK;
// break;
//}
continue; continue;
} }
} }
@ -1246,10 +936,8 @@ void hg_scanner_402::thread_handle_usb_read(void)
} }
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_name(status_)); VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_name(status_));
} }
int hg_scanner_402::start(void) int hg_scanner_402::start(void)
{ {
bool handled = false; bool handled = false;
int ret = try_third_app_handle_start(handled), int ret = try_third_app_handle_start(handled),
val = 0; val = 0;
@ -1406,11 +1094,7 @@ int hg_scanner_402::clear_roller_num(void)
return ret; return ret;
} }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner_402::set_leaflet_scan(void) int hg_scanner_402::set_leaflet_scan(void)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -1432,7 +1116,6 @@ int hg_scanner_402::set_final_image_format(SANE_FinalImgFormat* fmt)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_402::get_compression_format(void) int hg_scanner_402::get_compression_format(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -1445,7 +1128,6 @@ int hg_scanner_402::set_auto_color_type(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_402::get_device_code(void) int hg_scanner_402::get_device_code(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -1463,7 +1145,6 @@ int hg_scanner_402::get_sleep_time(SANE_Power* getime)
return -1; return -1;
} }
} }
int hg_scanner_402::set_sleep_time(int setsleepime) int hg_scanner_402::set_sleep_time(int setsleepime)
{ {
int ret = write_register(setting3399::SR_SET_SLEEPTIME, setsleepime); int ret = write_register(setting3399::SR_SET_SLEEPTIME, setsleepime);

96
hgdriver/hgdev/image_process.cpp
View File

@ -229,7 +229,7 @@ namespace hg_imgproc
typedef unsigned int (__stdcall *SDKHGBase_FreeImage_)(void* image); typedef unsigned int (__stdcall *SDKHGBase_FreeImage_)(void* image);
class imgproc class imgproc
{ {
bool isx86_closeAdvan_ = true; bool isx86_Advan_ = true;
std::string my_path_; std::string my_path_;
IMGPRCPARAM param_; IMGPRCPARAM param_;
SCANCONF img_conf_; SCANCONF img_conf_;
@ -276,20 +276,20 @@ namespace hg_imgproc
} }
// construction // construction
public: public:
imgproc(int pid, bool isx86_Advan_) : pid_(pid),papersize_(pid_) imgproc(int pid, bool isx86_Advan) : 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())
,ocrinit_(NULL),ocrgetdirectimage_(NULL) ,ocrinit_(NULL),ocrgetdirectimage_(NULL)
,ocrexit_(NULL),HGBase_CreatImg(NULL) ,ocrexit_(NULL),HGBase_CreatImg(NULL)
,HGBase_FreeImg(NULL),Auto_Txt_pHanld(NULL) ,HGBase_FreeImg(NULL),Auto_Txt_pHanld(NULL)
,Dynamicopen_HGBase_pHandle_(NULL) ,Dynamicopen_HGBase_pHandle_(NULL)
,Dynamicopen_HGImageprc_pHandle_(NULL),isx86_closeAdvan_(isx86_Advan_) ,Dynamicopen_HGImageprc_pHandle_(NULL),isx86_Advan_(isx86_Advan)
{ {
cv::setUseOptimized(isx86_closeAdvan_); //开关cpu高级指令集 cv::setUseOptimized(isx86_Advan_); //开关cpu高级指令集
} }
~imgproc() ~imgproc()
{ {
//free_auto_txt_hanld(); free_auto_txt_hanld();
} }
// load data // load data
@ -443,7 +443,6 @@ namespace hg_imgproc
return ret; return ret;
} }
int free_auto_txt_hanld() int free_auto_txt_hanld()
{ {
int ret = 0; int ret = 0;
@ -486,7 +485,7 @@ namespace hg_imgproc
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)
buffs = G200Decode(buffer_,img_conf_.is_duplex,img_conf_.is_switchfrontback).getImageBuffs(); buffs = G200Decode(buffer_,img_conf_.is_duplex,img_conf_.is_switchfrontback).getImageBuffs();
else if(pid == 0x139 || pid == 0x239) else if(pid == 0x139 || pid == 0x239 ||pid == 0x439)
buffs = GRawDecode(buffer_).getImageBuffs(); buffs = GRawDecode(buffer_).getImageBuffs();
else if(pid == 0x300 || pid == 0x400 ||pid == 0x402) else if(pid == 0x300 || pid == 0x400 ||pid == 0x402)
buffs = G400Decode(buffer_,img_conf_.is_duplex).getImageBuffs(); buffs = G400Decode(buffer_,img_conf_.is_duplex).getImageBuffs();
@ -526,7 +525,7 @@ namespace hg_imgproc
LOG_INFO(LOG_LEVEL_FATAL, "decode image data error\n"); LOG_INFO(LOG_LEVEL_FATAL, "decode image data error\n");
continue; continue;
} }
if(pid == 0x100 || pid == 0x200 || pid == 0x139 || pid == 0x239) if (pid == 0x100 || pid == 0x200 || pid == 0x139 || pid == 0x239 || pid_ == 0x439)
{ {
mats_.push_back(mat); mats_.push_back(mat);
//cv::imwrite(std::to_string(i)+"_decode.jpg",mat); //cv::imwrite(std::to_string(i)+"_decode.jpg",mat);
@ -594,7 +593,7 @@ namespace hg_imgproc
std::string filename ; std::string filename ;
int rotation01_ = 1; int rotation01_ = 1;
int rotation02_ = 1; int rotation02_ = 1;
if((pid_ == 0x139 || pid_ == 0x239 || pid_ == 0x100 || pid_ == 0x200) && (split3399 % 2 ==0) && img_conf_.is_duplex) if((pid_ == 0x139 || pid_ == 0x239 || pid_ == 0x100 || pid_ == 0x200 || pid_ == 0x439) && (split3399 % 2 ==0) && img_conf_.is_duplex)
{ {
rotation01_ = 0; rotation01_ = 0;
rotation02_ = 1; rotation02_ = 1;
@ -614,7 +613,7 @@ namespace hg_imgproc
} }
CImageApplyRotation::RotationType rotatetype = CImageApplyRotation::RotationType::Invalid; CImageApplyRotation::RotationType rotatetype = CImageApplyRotation::RotationType::Invalid;
if (pid_ == 0x402 || pid_ == 0x400 || pid_ == 0x239) if (pid_ == 0x402 || pid_ == 0x400 || pid_ == 0x239 || pid_ == 0x439)
rotatetype = CImageApplyRotation::RotationType::Rotate_90_clockwise; rotatetype = CImageApplyRotation::RotationType::Rotate_90_clockwise;
else if(pid_ == 0x100) else if(pid_ == 0x100)
rotatetype = CImageApplyRotation::RotationType::Rotate_90_anti_clockwise; rotatetype = CImageApplyRotation::RotationType::Rotate_90_anti_clockwise;
@ -652,61 +651,6 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int multi_out(void)
{
std::vector<cv::Mat> mats(mats_);
mats_.clear();
for (size_t i = 0; i < mats.size(); ++i)
{
if (mats[i].empty())
continue;
vector<cv::Mat> retmats;
std::vector<std::shared_ptr<IMulti>> m_multiprc_list;
int multiout = 1,
colormode = 1;
//if (m_param.imageProcess.filter == ColorFilter::FILTER_NONE)
//{
// colormode = m_param.pixelType;
//}
if (param_.channels > 1)
m_multiprc_list.push_back(shared_ptr<IMulti>(new ImageMultiOutputRed(2)));
m_multiprc_list.push_back(shared_ptr<IMulti>(new IMageMulti(multiout)));
for (int j = 0; j < m_multiprc_list.size(); j++)
{
retmats = m_multiprc_list[j]->apply(mats[i]);
}
CImageApplySplit isp(multiout, false, 1, colormode);
if (!retmats.size())
{
std::vector<cv::Mat> matse;
matse.push_back(mats[i]);
auto matexs = isp.SplitMats(matse, img_conf_.is_duplex);
for (auto& matex : matexs)
{
mats_.push_back(matex.mat);
}
break;
}
else
{
auto matexs = isp.SplitMats(retmats, img_conf_.is_duplex);
for (auto& matex : matexs)
{
mats_.push_back(matex.mat);
}
}
}
if (mats_.empty())
{
return SCANNER_ERR_NO_DATA;
}
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_);
@ -1204,10 +1148,6 @@ namespace hg_imgproc
} }
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
#ifdef _WIN32
#endif
#define test
int ocr_auto_txtdirect() int ocr_auto_txtdirect()
{ {
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
@ -1471,7 +1411,6 @@ namespace hg_imgproc
//printf("pimh->channels = %d \r\n",pimh->channels); //printf("pimh->channels = %d \r\n",pimh->channels);
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int get_final_data(LPIMGHEAD pimh, std::vector<unsigned char>* buf, int index) int get_final_data(LPIMGHEAD pimh, std::vector<unsigned char>* buf, int index)
{ {
if ((index < 0 || index >= mats_.size())) if ((index < 0 || index >= mats_.size()))
@ -1511,7 +1450,6 @@ namespace hg_imgproc
//printf("pimh->channels_01 = %d \r\n",pimh->channels); //printf("pimh->channels_01 = %d \r\n",pimh->channels);
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int imgtypechange(std::string img_type_,void *buf,std::vector<unsigned char> &bmpdata) int imgtypechange(std::string img_type_,void *buf,std::vector<unsigned char> &bmpdata)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -1522,7 +1460,6 @@ namespace hg_imgproc
cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata); cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata);
return ret; return ret;
} }
void dump_2_file(const char* local_file) void dump_2_file(const char* local_file)
{ {
if (mats_.size()) if (mats_.size())
@ -1558,7 +1495,6 @@ namespace hg_imgproc
} }
} }
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// api ... // api ...
HIMGPRC init(int pid,bool isx86_Advan_) HIMGPRC init(int pid,bool isx86_Advan_)
@ -1575,7 +1511,6 @@ namespace hg_imgproc
{ {
return ((imgproc*)himg)->load_file(path_file); return ((imgproc*)himg)->load_file(path_file);
} }
int decode(HIMGPRC himg, int pid, LPSCANCONF img_param, LPIMGPRCPARAM param) int decode(HIMGPRC himg, int pid, LPSCANCONF img_param, LPIMGPRCPARAM param)
{ {
return ((imgproc*)himg)->decode(pid, img_param, param); return ((imgproc*)himg)->decode(pid, img_param, param);
@ -1600,16 +1535,10 @@ namespace hg_imgproc
{ {
return ((imgproc*)himg)->fadeback(); return ((imgproc*)himg)->fadeback();
} }
int multi_out(HIMGPRC himg)
{
return ((imgproc*)himg)->multi_out();
}
int multi_out(HIMGPRC himg,int out_type) int multi_out(HIMGPRC himg,int out_type)
{ {
return ((imgproc*)himg)->multi_out(out_type); return ((imgproc*)himg)->multi_out(out_type);
} }
int multi_out_red(HIMGPRC himg) int multi_out_red(HIMGPRC himg)
{ {
return ((imgproc*)himg)->multi_out_red(); return ((imgproc*)himg)->multi_out_red();
@ -1678,7 +1607,6 @@ namespace hg_imgproc
{ {
return ((imgproc*)himg)->answerSheetFilterRed(); return ((imgproc*)himg)->answerSheetFilterRed();
} }
//img_type_ = jpg png bmp //img_type_ = jpg png bmp
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)
{ {
@ -1704,17 +1632,14 @@ namespace hg_imgproc
{ {
return ((imgproc*)himg)->size_detection(); return ((imgproc*)himg)->size_detection();
} }
int final(HIMGPRC himg) int final(HIMGPRC himg)
{ {
return ((imgproc*)himg)->final(); return ((imgproc*)himg)->final();
} }
int get_final_data(HIMGPRC himg, LPIMGHEAD pimh, void** buf, int index) int get_final_data(HIMGPRC himg, LPIMGHEAD pimh, void** buf, int index)
{ {
return ((imgproc*)himg)->get_final_data(pimh, buf, index); return ((imgproc*)himg)->get_final_data(pimh, buf, index);
} }
int get_final_data(HIMGPRC himg, LPIMGHEAD pimh, std::vector<unsigned char>* buf, int index) int get_final_data(HIMGPRC himg, LPIMGHEAD pimh, std::vector<unsigned char>* buf, int index)
{ {
return ((imgproc*)himg)->get_final_data(pimh, buf, index); return ((imgproc*)himg)->get_final_data(pimh, buf, index);
@ -1723,14 +1648,12 @@ namespace hg_imgproc
{ {
((imgproc*)himg)->dump_2_file(local_file); ((imgproc*)himg)->dump_2_file(local_file);
} }
void release(HIMGPRC himg) void release(HIMGPRC himg)
{ {
imgproc* obj = (imgproc*)himg; imgproc* obj = (imgproc*)himg;
delete obj; delete obj;
} }
// seperate utilites ... // seperate utilites ...
static cv::Mat from_bmp_file_bits(const BITMAPINFOHEADER& bih, unsigned char* data, bool line_reverse, bool bw_reverse) static cv::Mat from_bmp_file_bits(const BITMAPINFOHEADER& bih, unsigned char* data, bool line_reverse, bool bw_reverse)
{ {
@ -2013,7 +1936,6 @@ namespace hg_imgproc
return 0; return 0;
} }
static unsigned char reverse_bit(unsigned char v) static unsigned char reverse_bit(unsigned char v)
{ {
unsigned char r = 0; unsigned char r = 0;

1
hgdriver/hgdev/image_process.h
View File

@ -174,7 +174,6 @@ namespace hg_imgproc
//拆分 //拆分
int split(HIMGPRC himg,int split3399); int split(HIMGPRC himg,int split3399);
int fadeback(HIMGPRC himg); int fadeback(HIMGPRC himg);
int multi_out(HIMGPRC himg);
int multi_out(HIMGPRC himg,int out_type); int multi_out(HIMGPRC himg,int out_type);
int multi_out_red(HIMGPRC himg); int multi_out_red(HIMGPRC himg);
int auto_matic_color(HIMGPRC himg,int color_type); int auto_matic_color(HIMGPRC himg,int color_type);

10
hgdriver/hgdev/scanner_manager.cpp
View File

@ -68,7 +68,7 @@ g_supporting_devices[] = {
, {0x3072, PID_AND_NAME(339, SCANNER_NAME_HG_G300), "G300", "", &hg_scanner_mgr::create_scanner_empty} , {0x3072, PID_AND_NAME(339, SCANNER_NAME_HG_G300), "G300", "", &hg_scanner_mgr::create_scanner_empty}
, {0x3072, PID_AND_NAME(400, SCANNER_NAME_HG_G400), "G400", "", &hg_scanner_mgr::create_scanner_g400} , {0x3072, PID_AND_NAME(400, SCANNER_NAME_HG_G400), "G400", "", &hg_scanner_mgr::create_scanner_g400}
, {0x3072, PID_AND_NAME(402, SCANNER_NAME_HG_G400), "G400", "", &hg_scanner_mgr::create_scanner_g402} , {0x3072, PID_AND_NAME(402, SCANNER_NAME_HG_G400), "G400", "", &hg_scanner_mgr::create_scanner_g402}
, {0x3072, PID_AND_NAME(439, SCANNER_NAME_HG_G400), "G400", "", &hg_scanner_mgr::create_scanner_g239} , {0x3072, PID_AND_NAME(439, SCANNER_NAME_HG_G400), "G400", "", &hg_scanner_mgr::create_scanner_g439}
, {0x064B, PID_AND_NAME(7823,SCANNER_NAME_HG_G200), "G200", "", &hg_scanner_mgr::create_scanner_g100} , {0x064B, PID_AND_NAME(7823,SCANNER_NAME_HG_G200), "G200", "", &hg_scanner_mgr::create_scanner_g100}
#endif #endif
}; };
@ -241,7 +241,15 @@ hg_scanner* hg_scanner_mgr::create_scanner_g402(const char* name, usb_io* io, sc
return dynamic_cast<hg_scanner*>(s); return dynamic_cast<hg_scanner*>(s);
} }
hg_scanner* hg_scanner_mgr::create_scanner_g439(const char* name, usb_io* io, scanner_handle* h)
{
hg_scanner_239* s = new hg_scanner_239(name, 0x439, io);
if (h)
*h = s;
return dynamic_cast<hg_scanner*>(s);
}
void hg_scanner_mgr::usb_event_handle(usb_event ev, libusb_device* device, int vid, int pid, int usb_ver_h, int usb_ver_l, bool* retry, void* user) // usb_ver_h.usb_ver_l void hg_scanner_mgr::usb_event_handle(usb_event ev, libusb_device* device, int vid, int pid, int usb_ver_h, int usb_ver_l, bool* retry, void* user) // usb_ver_h.usb_ver_l
{ {
hg_scanner_mgr* obj = (hg_scanner_mgr*)user; hg_scanner_mgr* obj = (hg_scanner_mgr*)user;

1
hgdriver/hgdev/scanner_manager.h
View File

@ -104,6 +104,7 @@ public:
static hg_scanner* create_scanner_g302(const char* name, usb_io* io, scanner_handle* h); static hg_scanner* create_scanner_g302(const char* name, usb_io* io, scanner_handle* h);
static hg_scanner* create_scanner_g400(const char* name, usb_io* io, scanner_handle* h); static hg_scanner* create_scanner_g400(const char* name, usb_io* io, scanner_handle* h);
static hg_scanner* create_scanner_g402(const char* name, usb_io* io, scanner_handle* h); static hg_scanner* create_scanner_g402(const char* name, usb_io* io, scanner_handle* h);
static hg_scanner* create_scanner_g439(const char* name, usb_io* io, scanner_handle* h);
public: public:
scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only); scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only);