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

新增畸变修正流程，算法

This commit is contained in:
13038267101 2022-12-28 09:56:54 +08:00
parent 2055b83f9f
commit 38b8014d29
20 changed files with 997 additions and 314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
hgdriver/ImageProcess/CISTestImageProcess.cpp Normal file
View File

@ -0,0 +1,142 @@
#include "CISTestImageProcess.h"
int CISTestImageProcess::test(const cv::Mat& image, CISTestResult& result)
{
std::vector<cv::RotatedRect> marks;
findMarks(image, marks);
return 0;
}
CISTestImageProcess::CISTestImageProcess()
{
}
void CISTestImageProcess::findContours(const cv::Mat& src, std::vector<std::vector<cv::Point>>& contours,
std::vector<cv::Vec4i>& hierarchy, int retr, int method, cv::Point offset)
{
#if CV_VERSION_REVISION <= 6
CvMat c_image = src;
#else
CvMat c_image;
c_image = cvMat(src.rows, src.cols, src.type(), src.data);
c_image.step = src.step[0];
c_image.type = (c_image.type & ~cv::Mat::CONTINUOUS_FLAG) | (src.flags & cv::Mat::CONTINUOUS_FLAG);
#endif
cv::MemStorage storage(cvCreateMemStorage());
CvSeq* _ccontours = nullptr;
#if CV_VERSION_REVISION <= 6
cvFindContours(&c_image, storage, &_ccontours, sizeof(CvContour), retr, method, CvPoint(offset));
#else
cvFindContours(&c_image, storage, &_ccontours, sizeof(CvContour), retr, method, CvPoint{ offset.x, offset.y });
#endif
if (!_ccontours)
{
contours.clear();
return;
}
cv::Seq<CvSeq*> all_contours(cvTreeToNodeSeq(_ccontours, sizeof(CvSeq), storage));
size_t total = all_contours.size();
contours.resize(total);
cv::SeqIterator<CvSeq*> it = all_contours.begin();
for (size_t i = 0; i < total; i++, ++it)
{
CvSeq* c = *it;
reinterpret_cast<CvContour*>(c)->color = static_cast<int>(i);
int count = c->total;
int* data = new int[static_cast<size_t>(count * 2)];
cvCvtSeqToArray(c, data);
for (int j = 0; j < count; j++)
{
contours[i].push_back(cv::Point(data[j * 2], data[j * 2 + 1]));
}
delete[] data;
}
hierarchy.resize(total);
it = all_contours.begin();
for (size_t i = 0; i < total; i++, ++it)
{
CvSeq* c = *it;
int h_next = c->h_next ? reinterpret_cast<CvContour*>(c->h_next)->color : -1;
int h_prev = c->h_prev ? reinterpret_cast<CvContour*>(c->h_prev)->color : -1;
int v_next = c->v_next ? reinterpret_cast<CvContour*>(c->v_next)->color : -1;
int v_prev = c->v_prev ? reinterpret_cast<CvContour*>(c->v_prev)->color : -1;
hierarchy[i] = cv::Vec4i(h_next, h_prev, v_next, v_prev);
}
storage.release();
}
int CISTestImageProcess::findPaperContour(const std::vector<std::vector<cv::Point>>& contours, const std::vector<cv::Vec4i>& hierarchy, cv::RotatedRect& paperRect)
{
std::vector<cv::Point> maxContour;
if (contours.size() < 1) return {};
for (size_t i = 0, length = hierarchy.size(); i < length; i++)
if (hierarchy[i][3] == -1)
for (const auto& item : contours[i])
maxContour.push_back(item);
if (maxContour.size() == 0)
return -1;
paperRect = cv::minAreaRect(maxContour);
if (paperRect.angle < -45)
{
paperRect.angle += 90;
float temp = paperRect.size.width;
paperRect.size.width = paperRect.size.height;
paperRect.size.height = temp;
}
if (paperRect.angle > 45)
{
paperRect.angle -= 90;
float temp = paperRect.size.width;
paperRect.size.width = paperRect.size.height;
paperRect.size.height = temp;
}
return 0;
}
int CISTestImageProcess::classfiyContours(const std::vector<std::vector<cv::Point>>& contours, std::vector<std::vector<cv::Point>>& marks,
std::vector<std::vector<cv::Point>>& colorBlocks,
std::vector<std::vector<cv::Point>>& grayBlocks)
{
marks.clear();
colorBlocks.clear();
grayBlocks.clear();
for (size_t i = 0; i < contours.size(); i++)
{
double area = cv::contourArea(contours[i]);
}
return 0;
}
int CISTestImageProcess::findMarks(const cv::Mat& image, std::vector<cv::RotatedRect>& marks)
{
int res = 0;
cv::Mat thre;
if (image.channels() != 1)
{
cv::cvtColor(image, thre, cv::COLOR_BGR2GRAY);
cv::threshold(thre, thre, 127, 255, cv::THRESH_BINARY);
}
else
cv::threshold(image, thre, 127, 255, cv::THRESH_BINARY);
std::vector<std::vector<cv::Point>> contours;
std::vector<cv::Vec4i> hierarchy;
findContours(thre, contours, hierarchy, cv::RETR_CCOMP, cv::CHAIN_APPROX_SIMPLE);
cv::RotatedRect paperRect;
res = findPaperContour(contours, hierarchy, paperRect);
if (res != 0)
return res;
return res;
}

74
hgdriver/ImageProcess/CISTestImageProcess.h Normal file
View File

@ -0,0 +1,74 @@
#ifndef CIS_TEST_IMAGE_PROCESS_H
#define CIS_TEST_IMAGE_PROCESS_H
#include <opencv2/opencv.hpp>
class CISTestImageProcess
{
public:
struct CISTestResult
{
double scaleXY1; //圆1横纵比
double scaleXY2; //圆2横纵比
double scaleXY3; //圆3横纵比
uchar colorBlock1[3]; //彩色色块1RGB
uchar colorBlock2[3]; //彩色色块2RGB
uchar colorBlock3[3]; //彩色色块3RGB
uchar colorBlock4[3]; //彩色色块4RGB
uchar colorBlock5[3]; //彩色色块5RGB
uchar colorBlock6[3]; //彩色色块6RGB
uchar colorBlock7[3]; //彩色色块7RGB
uchar colorBlock8[3]; //彩色色块8RGB
uchar colorBlock9[3]; //彩色色块9RGB
uchar grayBlock1; //灰度色块1灰度值
uchar grayBlock2; //灰度色块2灰度值
uchar grayBlock3; //灰度色块3灰度值
uchar grayBlock4; //灰度色块4灰度值
uchar grayBlock5; //灰度色块5灰度值
uchar grayBlock6; //灰度色块6灰度值
uchar grayBlock7; //灰度色块7灰度值
uchar grayBlock8; //灰度色块8灰度值
uchar grayBlock9; //灰度色块9灰度值
};
static int test(const cv::Mat& image, CISTestResult& result);
private:
CISTestImageProcess();
/// <summary>
/// 获取连通区域轮廓
/// </summary>
/// <param name="src">源图像</param>
/// <param name="contours">结果轮廓集</param>
/// <param name="hierarchy">轮廓集的排序关系。与contours的数量对应，受retr选项不同，排序会有变化</param>
/// <param name="retr">轮廓集排序方式，默认为链式排序</param>
/// <param name="method">查找算法选择，默认为普通查找</param>
/// <param name="offset">查找起始点，默认为（0,0）点</param>
static void findContours(const cv::Mat& src, std::vector<std::vector<cv::Point>>& contours, std::vector<cv::Vec4i>& hierarchy,
int retr = cv::RETR_LIST, int method = cv::CHAIN_APPROX_SIMPLE, cv::Point offset = cv::Point(0, 0));
/// <summary>
///
/// </summary>
/// <param name="contours"></param>
/// <param name="hierarchy"></param>
/// <param name="paperRect"></param>
/// <returns></returns>
static int findPaperContour(const std::vector<std::vector<cv::Point>>& contours, const std::vector<cv::Vec4i>& hierarchy, cv::RotatedRect& paperRect);
static int classfiyContours(const std::vector<std::vector<cv::Point>>& contours, std::vector<std::vector<cv::Point>>& marks,
std::vector<std::vector<cv::Point>>& colorBlocks,
std::vector<std::vector<cv::Point>>& grayBlocks);
/// <summary>
///
/// </summary>
/// <param name="vector"></param>
/// <param name=""></param>
static int findMarks(const cv::Mat& image, std::vector<cv::RotatedRect>& marks);
};
#endif

1
hgdriver/ImageProcess/ImageApplyHeaders.h
View File

@ -30,4 +30,5 @@
#include "ImageMulti.h" #include "ImageMulti.h"
#include "ImageMultiOutputRed.h" #include "ImageMultiOutputRed.h"
#include "ImageApplySplit.h" #include "ImageApplySplit.h"
#include "CISTestImageProcess.h"
#endif #endif

144
hgdriver/hgdev/common_setting.h
View File

@ -633,7 +633,7 @@ namespace setting_hardware
unsigned int is_fixedpaper : 1; // unsigned int is_fixedpaper : 1; //
unsigned int en_anlogic_key : 1; // unsigned int en_anlogic_key : 1; //
unsigned int en_autosize : 1; // unsigned int en_autosize : 1; //
unsigned int pc_correct : 1; // 是否在PC端校正 unsigned int pc_correct : 1; // 是否在PC端校正 1:不校正 cis原图，0:校正
unsigned int enable_sizecheck : 1; // 是否进行尺寸检测 unsigned int enable_sizecheck : 1; // 是否进行尺寸检测
unsigned int enabledsp_cache : 1; // 是否在片上缓存 unsigned int enabledsp_cache : 1; // 是否在片上缓存
unsigned int sizeerror_errorratio : 9; // 幅面检测 unsigned int sizeerror_errorratio : 9; // 幅面检测
@ -651,7 +651,8 @@ namespace setting_hardware
unsigned int stable_enbale : 1; unsigned int stable_enbale : 1;
unsigned int screw_detect_enable : 1; unsigned int screw_detect_enable : 1;
unsigned int screw_detect_level : 3; unsigned int screw_detect_level : 3;
unsigned int unused_one : 6; unsigned int isCorrect : 1; //设置0 为原图，1为校正后的图
unsigned int unused_one : 5;
unsigned int pc_correct : 1; unsigned int pc_correct : 1;
unsigned int enable_sizecheck : 1; unsigned int enable_sizecheck : 1;
unsigned int unused_two : 10; unsigned int unused_two : 10;
@ -685,7 +686,7 @@ namespace setting_hardware
unsigned int enableSizeDetect : 1; unsigned int enableSizeDetect : 1;
unsigned int lutmode : 1; // 设置文本和照片模式， 0 - 文本；1 - 照片。默认值为“0” unsigned int lutmode : 1; // 设置文本和照片模式， 0 - 文本；1 - 照片。默认值为“0”
unsigned int reversed1 : 4; unsigned int reversed1 : 4;
unsigned int isCorrect : 1; unsigned int isCorrect : 1; //设置0 为原图，1为校正后的图
unsigned int dstHeight : 8; unsigned int dstHeight : 8;
unsigned int reversed2 : 6; unsigned int reversed2 : 6;
}params_3288; }params_3288;
@ -738,47 +739,164 @@ namespace setting3288dsp
enum tagUsbKeyWords enum tagUsbKeyWords
{ {
//无命令
NO_COMMAND = 0, NO_COMMAND = 0,
//获取dsp 状态
GET_DSP_STATUS = 1, GET_DSP_STATUS = 1,
//取图
GET_IMAGE = 2, GET_IMAGE = 2,
//销毁DSP中驻存的图
POP_IMAGE = 3, POP_IMAGE = 3,
//开始扫描命令
START_COMMAND = 4, START_COMMAND = 4,
//停止扫描命令
STOP = 5, STOP = 5,
//获取扫描仪扫描模式
GET_SCAN_MODE = 6, GET_SCAN_MODE = 6,
//获取固件版本号
GET_FW_VERSION = 7, GET_FW_VERSION = 7,
//返回PC端的状态
SEND_STATUS_PC = 8, SEND_STATUS_PC = 8,
//下发扫描配置参数
CONFIGURED_DATA = 9, CONFIGURED_DATA = 9,
//下发固件信息
SEND_FW = 10, SEND_FW = 10,
//获取扫描参数
GET_CONFIG_DATA = 11, GET_CONFIG_DATA = 11,
//获取扫描总张数
GET_SCANN_NUM = 12, GET_SCANN_NUM = 12,
//获取有无纸的状态
GET_PAPERFEEDER_STATUS = 13, GET_PAPERFEEDER_STATUS = 13,
//DSP初始化
INIT_HARDWARE_SYS = 14, INIT_HARDWARE_SYS = 14,
GET_PAPER_STATUS = 0x0d, //下发元器件配置参数（灰度，LED R曝光时间）
SEND_COMPONENTS_GR = 15, SEND_COMPONENTS_GR = 15,
//下发元器件配置参数（LED G/B曝光时间）
SEND_COMPONENTS_GB = 16, SEND_COMPONENTS_GB = 16,
//下发扫描模式
SEND_SCAN_MODE = 17, SEND_SCAN_MODE = 17,
//开始进行平场矫正
START_FLAT = 18, START_FLAT = 18,
//停止平场矫正
STOP_FLAT = 19, STOP_FLAT = 19,
//下发200dpi彩色平场矫正参数
SEND_200_COLOR_FLAT_DATA = 20, SEND_200_COLOR_FLAT_DATA = 20,
//下发300dpi彩色平场矫正参数
SEND_300_COLOR_FLAT_DATA = 21, SEND_300_COLOR_FLAT_DATA = 21,
//获取200dpi彩色平场矫正参数
GET_200_COLOR_FLAT_DATA = 22, GET_200_COLOR_FLAT_DATA = 22,
//获取300dpi彩色平场矫正参数
GET_300_COLOR_FLAT_DATA = 23, GET_300_COLOR_FLAT_DATA = 23,
//下发200dpi灰度平场校正参数
SEND_200_GRAY_FLAT_DATA = 24, SEND_200_GRAY_FLAT_DATA = 24,
//下发300dpi灰度平场校正参数
SEND_300_GRAY_FLAT_DATA = 25, SEND_300_GRAY_FLAT_DATA = 25,
//获取200DPI灰度平场校正参数
GET_200_GRAY_FLAT_DATA = 26, GET_200_GRAY_FLAT_DATA = 26,
//获取300DPI灰度平场校正参数
GET_300_GRAY_FLAT_DATA = 27, GET_300_GRAY_FLAT_DATA = 27,
//下发序列号命令
SEND_SERIAL = 28, SEND_SERIAL = 28,
//获取序列号命令
GET_SERIAL = 29, GET_SERIAL = 29,
GET_ROLLER_NUM = 30, //获取滚轴数
CLR_ROLLER_NUM = 31, GET_ROLLER_NUM = 0x1e,
START_COMMAND_COUNT = 38, //清零滚轴数
SET_SLEEP_TIME = 39, CLR_ROLLER_NUM = 0x1f,
GET_SLEEP_TIME = 40, //清除扫描总张数
CLR_HARDWARE_CACHE = 41, CLR_SCAN_NUM = 0x20,
//准备更新固件
CHECK_IS_SLEEP = 0x100, PRE_UPGRADE = 0X21,
//开始更新固件
START_UPGRADE = 0x22,
//彩色的AD参数
RGB_ADI_PARA = 0x23,
//灰度的AD参数
ADI_PARA = 0x24,
//获取CIS参数（曝光时间，ad参数)
GET_CIS_PARA = 0x25,
//扫描张数
START_COMMAND_COUNT = 0x26,
//下发休眠时间
SET_SLEEP_TIME = 0x27,
//获取休眠时间
GET_SLEEP_TIME = 0x28,
//清除缓存
CLR_CACHE = 0x29,
//下发速度模式
SET_SPEED_MODE = 0x2a,
//获取扫描速度模式
GET_SPEED_MODE = 0X2b,
//设置固件版本一共8个字节
SET_FW_VERSION = 0X2c,
//获取DSP版本
GET_DSP_VERSION = 0X2d,
//采集板FPGA固件版本
GET_SCANFPGA_VERSION = 0x2e,
//电机板FPGA固件版本
GET_MOTORFPGA_VERSION = 0X2f,
//设置制造商信息
SET_USB_INFOR_MANUFACTURE = 0X30,
//获取制造商信息
GET_USB_INFOR_MANUFACTURE = 0X31,
//设置产品型号信息
SET_USB_INFOR_MODEL_NAME = 0X32,
//获取产品型号信息
GET_USB_INFOR_MODEL_NAME = 0X33,
//设置USB PID / VID信息
SET_USB_INFOR_VIDPID = 0X34,
GET_USB_INFOR_VIDPID = 0X35,
//设置卡纸急停检测灵敏度
SET_JAM_DETECT_SENSITIVE = 0X36,
//获取卡纸急停检测灵敏度
GET_JAM_DETECT_SENSITIVE = 0X37,
//设置横向畸变系数
SET_JUST_COF_H = 0x38,
//读取横向畸变系数
GET_JUST_COF_H = 0x39,
//G400 清除硬件异常
CLEAR_HWERROR = 0x40,
//设置纵向畸变系数
SET_JUST_COF_V = 0x41,
//读取纵向畸变系数
GET_JUST_COF_V = 0x42,
//设置彩色校正参数
SEND_COLOR_FLAT = 0x43,
//设置彩色平场校正参数
SEND_COLORCORRECT_FLAT = 0x44,
//设置灰度校正参数
SEND_GRAY_FLAT = 0x45,
//设置灰度平场校正参数
SEND_GRAYCORRECT_FLAT = 0x46,
//设置平场校正参数
GET_FLAT_DATA = 0x47,
//更新完成
UPDATE_FINISHED = 0x48,
//重启 1进入loader,0普通重启
REBOOT = 0x49,
//获取日志
GET_LOG_FILES_INFO = 0x50,
//发送log文件完成
GET_UPDATE_RESULT = 0x51,
//清空日志
CLEAR_LOG_FILES = 0x52,
//获取搓纸失败
GET_CUO_ERROR,
//获取双张失败次数
GET_DOU_ERROR,
//获取卡纸次数
GET_JAM_ERROR,
//获取设备是否睡眠状态
ACTIVE_SCANNER = 0x100,
//图像处理参数下发
GETSYSINFO_LEN = 0x200,
GETSYSINFO = 0x201,
GETMOTORPARAM = 0x202,
GETMOTORPARMLEN = 0x203,
SETMOTORPARAM = 0x204,
SETMOTORPARAMLEN = 0x205
}; };
typedef enum tagUsbKeyWords UsbKeyWords, * PUsbKeyWords;
//G300 G400 纸张类型协议 注：只支持3288 300 400 //G300 G400 纸张类型协议 注：只支持3288 300 400
// //
enum G400_PaperSize { enum G400_PaperSize {

71
hgdriver/hgdev/hg_scanner.cpp
View File

@ -155,7 +155,8 @@ hg_scanner::hg_scanner(ScannerSerial serial
, isremove_left_hole_threshold(0), isremove_right_hole_threshold(0), isremove_top_hole_threshold(0), isremove_low_hole_threshold(0) , isremove_left_hole_threshold(0), isremove_right_hole_threshold(0), isremove_top_hole_threshold(0), isremove_low_hole_threshold(0)
, dump_usb_path_(""),is_kernelsnap_211209_(false), pid_(0), dump_img_(&hg_scanner::dump_image_empty), is_kernelsnap_220830_(false),is_kernelsnap3288_221106_(false) , dump_usb_path_(""),is_kernelsnap_211209_(false), pid_(0), dump_img_(&hg_scanner::dump_image_empty), is_kernelsnap_220830_(false),is_kernelsnap3288_221106_(false)
, is_kernelsnap_221027_(false), memory_size_(1024/*USB+JPEG压缩及图像处理图队列，总共1GB*/), isx86_Advan_(true), stop_fatal_(SCANNER_ERR_OK), is_auto_paper_scan(false) , is_kernelsnap_221027_(false), memory_size_(1024/*USB+JPEG压缩及图像处理图队列，总共1GB*/), isx86_Advan_(true), stop_fatal_(SCANNER_ERR_OK), is_auto_paper_scan(false)
,size_check(false), save_sleeptime_type_(false), is_kernelsnap_devsislock(false), is_checksum_strat_scan(false) , size_check(false), save_sleeptime_type_(false), is_kernelsnap_devsislock(false), is_checksum_strat_scan(false), is_cis_image(false)
, is_dpi_color_check(false),save_dpi_color_check_val(0.0f)
{ {
#if !defined(_WIN32) && !defined(_WIN64) &&defined(x86_64) #if !defined(_WIN32) && !defined(_WIN64) &&defined(x86_64)
isx86_Advan_ = false; isx86_Advan_ = false;
@ -2221,6 +2222,10 @@ int hg_scanner::on_is_auto_paper(bool isautopaper)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::on_cis_get_image(bool isautopaper)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
void hg_scanner::on_device_reconnected(void) void hg_scanner::on_device_reconnected(void)
{ {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
@ -2292,7 +2297,7 @@ hg_imgproc::IMGPRCPARAM hg_scanner::get_image_process_object(int model)
param.color_mode = image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH ? 2 : image_prc_param_.bits.color_mode; param.color_mode = image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH ? 2 : image_prc_param_.bits.color_mode;
param.double_side = img_conf_.is_duplex; param.double_side = img_conf_.is_duplex;
param.dpi = img_conf_.resolution_dst; param.dpi = img_conf_.resolution_dst;
param.cis_image = is_dpi_color_check || is_cis_image;
//img_conf_.brightness = (float)bright_; //img_conf_.brightness = (float)bright_;
//img_conf_.contrast = (float)contrast_; //img_conf_.contrast = (float)contrast_;
@ -3203,14 +3208,12 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len)
sleeptime = 120; sleeptime = 120;
break; break;
case SANE_POWER_MINUTES_240: case SANE_POWER_MINUTES_240:
sleeptime = 14424000; sleeptime = 240;
break; break;
case SANE_POWER_SHUTDOWN: case SANE_POWER_SHUTDOWN:
set_devshtudown(); return set_devshtudown();
break;
case SANE_POWER_RESTART: case SANE_POWER_RESTART:
set_devreboot(); return set_devreboot(val);
break;
default: default:
sleeptime = -1; sleeptime = -1;
break; break;
@ -3347,6 +3350,26 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len)
{ {
return get_scan_mode(*((bool*)data)); return get_scan_mode(*((bool*)data));
} }
else if (code == IO_CTRL_CODE_SET_ULTRASONIC_MODULE)
{
return on_ultrasonic_check_changed(*((bool*)data));
}
else if (code == IO_CTRL_CODE_SET_SPEED_MODE)
{
return set_speed_mode(*((int*)data));
}
else if (code == IO_CTRL_CODE_SET_CIS_IMAGE)
{
return on_cis_get_image(*((bool*)data));
}
else if(code == IO_CTRL_CODE_GET_IMAGE)
{
return start();;
}
else if (code == IO_CTRL_CODE_GET_DPI_COLOR_CHECK_VAL)
{
return set_dpi_color_check(*((bool*)data));
}
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
std::string hg_scanner::get_firmware_version(void) std::string hg_scanner::get_firmware_version(void)
@ -3369,7 +3392,7 @@ int hg_scanner::get_device_log(string &log)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::set_devreboot() int hg_scanner::set_devreboot(int data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
@ -3417,6 +3440,24 @@ int hg_scanner::get_scan_mode(bool& type)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::set_speed_mode(int data)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner::set_dpi_color_check(bool type)
{
is_dpi_color_check = type;
int ret = SCANNER_ERR_OK;
if (type)
{
ret = set_leaflet_scan();
}
return ret;
}
int hg_scanner::set_dpi_color_check_val(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner::set_leaflet_scan(void) int hg_scanner::set_leaflet_scan(void)
{ {
@ -3516,6 +3557,19 @@ void hg_scanner::image_process(std::shared_ptr<tiny_buffer>& buffer)
hg_imgproc::decode(ImagePrc_pHandle_, pid_, &img_conf_, &param); hg_imgproc::decode(ImagePrc_pHandle_, pid_, &img_conf_, &param);
(this->*dump_img_)(ImagePrc_pHandle_, "decode"); (this->*dump_img_)(ImagePrc_pHandle_, "decode");
if (param.cis_image)
{
if (is_dpi_color_check)
{
CISTestImageProcess::CISTestResult res;
err = hg_imgproc::cis_test_image(ImagePrc_pHandle_, res);
save_dpi_color_check_val = res.scaleXY1;
set_dpi_color_check_val();
}
}
else
{
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(ImagePrc_pHandle_, 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);
@ -3680,6 +3734,7 @@ void hg_scanner::image_process(std::shared_ptr<tiny_buffer>& buffer)
err = hg_imgproc::multi_out(ImagePrc_pHandle_, multi_out); err = hg_imgproc::multi_out(ImagePrc_pHandle_, multi_out);
(this->*dump_img_)(ImagePrc_pHandle_, "multi_out"); (this->*dump_img_)(ImagePrc_pHandle_, "multi_out");
} }
}
hg_imgproc::final(ImagePrc_pHandle_); hg_imgproc::final(ImagePrc_pHandle_);
(this->*dump_img_)(ImagePrc_pHandle_, "final"); (this->*dump_img_)(ImagePrc_pHandle_, "final");

47
hgdriver/hgdev/hg_scanner.h
View File

@ -242,25 +242,29 @@ protected:
int setting_isremove_low_hole_threshold(void* data); int setting_isremove_low_hole_threshold(void* data);
int setting_fold_type(void* data); int setting_fold_type(void* data);
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_check_changed(bool& check);
virtual int on_resolution_changed(int& dpi);
virtual int on_ultrasonic_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_level_changed(int& check);
virtual int on_get_feedmode(int& feedmode); //获取分纸强度
virtual int on_set_feedmode(int feedmode); //设置分纸强度
virtual int on_pic_type(bool& pic); //照片模式或者文本模式
virtual int on_pick_paper(bool autostrength); //设置搓纸使能
virtual int on_pick_paper_threshold(double threshold); //设置搓纸阈值
virtual int on_is_auto_paper(bool isautopaper); //待纸扫描
protected:
virtual void on_device_reconnected(void); virtual void on_device_reconnected(void);
virtual int set_setting_value(const char* name, void* data, int len);
virtual int on_scanner_closing(bool force); virtual int on_scanner_closing(bool force);
virtual int on_color_mode_changed(int& color_mode) = 0; // COLOR_MODE_xxx
virtual int on_paper_changed(int& paper) = 0; // PAPER_xxx
virtual int on_paper_check_changed(bool& check)=0;
virtual int on_resolution_changed(int& dpi)=0;
virtual int on_ultrasonic_check_changed(bool& check)=0;
virtual int on_staple_check_changed(bool& check) = 0;
virtual int on_skew_check_changed(bool& check) = 0;
virtual int on_skew_check_level_changed(int& check) = 0;
virtual int on_get_feedmode(int& feedmode) = 0; //获取分纸强度
virtual int on_set_feedmode(int feedmode) = 0; //设置分纸强度
virtual int on_pic_type(bool& pic) = 0; //照片模式或者文本模式
virtual int on_pick_paper(bool autostrength) = 0; //设置搓纸使能
virtual int on_pick_paper_threshold(double threshold) = 0; //设置搓纸阈值
virtual int on_is_auto_paper(bool isautopaper) = 0; //待纸扫描
virtual int on_cis_get_image(bool type) = 0;
protected:
virtual int set_setting_value(const char* name, void* data, int len);
virtual void thread_handle_usb_read(void) = 0; virtual void thread_handle_usb_read(void) = 0;
virtual void thread_handle_islock_read(); virtual void thread_handle_islock_read();
int hg_version_init_handle(); int hg_version_init_handle();
@ -329,6 +333,10 @@ protected:
double isremove_top_hole_threshold; //设置上边除穿孔阈值 double isremove_top_hole_threshold; //设置上边除穿孔阈值
double isremove_low_hole_threshold; //设置下边除穿孔阈值 double isremove_low_hole_threshold; //设置下边除穿孔阈值
int fold_type_; //对折类型 int fold_type_; //对折类型
bool is_cis_image; //设置cis获取原图
bool is_dpi_color_check; //纵向DPI、色差检测 ,畸变自动计算
double save_dpi_color_check_val; //保存纵向DPI、色差检测 ,畸变自动计算 的值
int split3399_; //3399设备正面和反面图像是相对的，所以对折时反面需要进行特殊处理 int split3399_; //3399设备正面和反面图像是相对的，所以对折时反面需要进行特殊处理
int pid_; int pid_;
@ -454,7 +462,7 @@ public:
virtual int get_roller_num(int &data) = 0; //获取滚轮张数 /*/ data > 0*/ virtual int get_roller_num(int &data) = 0; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) = 0; //唤醒设备 virtual int set_notify_sleep(void) = 0; //唤醒设备
virtual int get_device_log(string &log) = 0; //获取设备日志 /*/ log :储存路径*/ virtual int get_device_log(string &log) = 0; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() = 0; //设置设备重启 virtual int set_devreboot(int data) = 0; //设置设备重启 /*/ data:0 reboot data:1
virtual int set_devshtudown() = 0; //设置设备关机 virtual int set_devshtudown() = 0; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) = 0; //设置设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int set_scan_islock(SANE_Bool type) = 0; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) = 0; //获取设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int get_scan_islock(SANE_Bool& type) = 0; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
@ -464,6 +472,9 @@ public:
virtual int get_dev_islock_file(int &data) = 0; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/ virtual int get_dev_islock_file(int &data) = 0; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) = 0; //设置设备文件 /*/ data:0 未上锁，1 上锁*/ virtual int set_dev_islock_file(int data) = 0; //设置设备文件 /*/ data:0 未上锁，1 上锁*/
virtual int get_scan_mode(bool& type) ; //获取设备是否计数模式 /*/ type:false计数模式 true非计数模式 virtual int get_scan_mode(bool& type) ; //获取设备是否计数模式 /*/ type:false计数模式 true非计数模式
virtual int set_speed_mode(int data) = 0; //设置速度模式 /*/ 设备不同值不同，详情见子类注释
virtual int set_dpi_color_check(bool type); //获取畸变矫正
virtual int set_dpi_color_check_val(void) = 0; //设置畸变矫正值
}; };
#ifdef UOS #ifdef UOS

38
hgdriver/hgdev/hg_scanner_200.cpp
View File

@ -559,6 +559,28 @@ int hg_scanner_200::on_set_feedmode(int feedmode)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_200::on_pic_type(bool& pic)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::on_pick_paper(bool autostrength)
{
return 0;
}
int hg_scanner_200::on_pick_paper_threshold(double threshold)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::on_is_auto_paper(bool isautopaper)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::on_cis_get_image(bool isautopaper)
{
is_cis_image = isautopaper;
dsp_config_.params_dsp.isCorrect = isautopaper == true ? 0 : 1; //0设置获取cis原图，1校正之后的图
return writedown_device_configuration();
}
int hg_scanner_200::on_get_feedmode(int &feedmode) int hg_scanner_200::on_get_feedmode(int &feedmode)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -729,7 +751,7 @@ int hg_scanner_200::get_scanner_paperon(SANE_Bool& type)
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::GET_PAPER_STATUS, 0, 0 }; USBCB usbcb = { setting3288dsp::GET_PAPERFEEDER_STATUS, 0, 0 };
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
@ -751,7 +773,7 @@ int hg_scanner_200::get_scan_is_sleep(SANE_Bool& type)
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::CHECK_IS_SLEEP, 0, 0 }; USBCB usbcb = { setting3288dsp::ACTIVE_SCANNER, 0, 0 };
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
@ -777,7 +799,7 @@ int hg_scanner_200::get_device_log(string &log)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_200::set_devreboot() int hg_scanner_200::set_devreboot(int data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
@ -813,6 +835,16 @@ int hg_scanner_200::set_dev_islock_file(int data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT;; return SCANNER_ERR_DEVICE_NOT_SUPPORT;;
} }
int hg_scanner_200::set_speed_mode(int data)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::set_dpi_color_check_val(void)
{
return 0;
}
int hg_scanner_200::set_notify_sleep() int hg_scanner_200::set_notify_sleep()
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;

34
hgdriver/hgdev/hg_scanner_200.h
View File

@ -22,20 +22,25 @@
class hg_scanner_200 : public hg_scanner class hg_scanner_200 : public hg_scanner
{ {
void discard_prev(void); void discard_prev(void);
protected: protected:
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_scanner_closing(bool force) override;
virtual int on_paper_changed(int& paper); // PAPER_xxx protected:
virtual int on_paper_check_changed(bool& check); virtual int on_color_mode_changed(int& color_mode) override; // COLOR_MODE_xxx
virtual int on_resolution_changed(int& dpi); virtual int on_paper_changed(int& paper) override; // PAPER_xxx
virtual int on_ultrasonic_check_changed(bool& check); virtual int on_paper_check_changed(bool& check) override;
virtual int on_staple_check_changed(bool& check); virtual int on_resolution_changed(int& dpi) override;
virtual int on_skew_check_changed(bool& check); virtual int on_ultrasonic_check_changed(bool& check) override;
virtual int on_skew_check_level_changed(int& check); virtual int on_staple_check_changed(bool& check) override;
virtual int on_get_feedmode(int& feedmode);//获取分纸强度 virtual int on_skew_check_changed(bool& check) override;
virtual int on_set_feedmode(int feedmode);//设置分纸强度 virtual int on_skew_check_level_changed(int& check) override;
virtual int on_get_feedmode(int& feedmode) override; //获取分纸强度
virtual int on_set_feedmode(int feedmode) override; //设置分纸强度
virtual int on_pic_type(bool& pic) override; //照片模式或者文本模式
virtual int on_pick_paper(bool autostrength)override; //设置搓纸使能
virtual int on_pick_paper_threshold(double threshold) override; //设置搓纸阈值
virtual int on_is_auto_paper(bool isautopaper) override; //待纸扫描
virtual int on_cis_get_image(bool isautopaper) override; //获取cis原图
public: public:
hg_scanner_200(const char* dev_name,int vid, usb_io* io); hg_scanner_200(const char* dev_name,int vid, usb_io* io);
~hg_scanner_200(); ~hg_scanner_200();
@ -81,7 +86,7 @@ public:
virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/ virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) override; //唤醒设备 virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/ virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() override; //设置设备重启 virtual int set_devreboot(int data) override; //设置设备重启
virtual int set_devshtudown() override; //设置设备关机 virtual int set_devshtudown() override; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
@ -90,5 +95,6 @@ public:
virtual int set_clean_paper_road() override; //清理纸道 virtual int set_clean_paper_road() override; //清理纸道
virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/ virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/ virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/
virtual int set_speed_mode(int data) override; //设置速度模式 /*/ 不支持
virtual int set_dpi_color_check_val(void) override; //设置畸变矫正
}; };

49
hgdriver/hgdev/hg_scanner_239.cpp
View File

@ -160,11 +160,6 @@ hg_scanner_239::hg_scanner_239(const char* dev_name, int pid,usb_io* io) : hg_sc
else else
init_settings((jsontext3 + jsontext4).c_str()); init_settings((jsontext3 + jsontext4).c_str());
} }
//if (init_settings(0x239))
//init_settings((jsontext1 + jsontext2).c_str());
//writedown_device_configuration(); // initialize the hardware settings
std::string str = hg_log::get_scanimage_ver();
printf("str:%s\r\n",str.c_str());
init_version(); init_version();
hg_version_init_handle(); hg_version_init_handle();
wait_devsislock_.notify(); wait_devsislock_.notify();
@ -255,6 +250,34 @@ int hg_scanner_239::get_scan_mode(bool &type)
//} //}
return ret; return ret;
} }
int hg_scanner_239::set_speed_mode(int data)
{
return write_register(setting3399::SR_SET_SPEEDMODE, data);
}
int hg_scanner_239::set_dpi_color_check_val(void)
{
setting3399::Scanner_Reg_Defs ratio = setting3399::SR_SET_H_200_RATIO;
if (resolution_ <= 200)
ratio = setting3399::SR_SET_H_200_RATIO;
else if (resolution_ > 200 && resolution_ <= 300)
ratio = setting3399::SR_SET_H_300_RATIO;
else if (resolution_ > 300 && resolution_ <= 600)
ratio = setting3399::SR_SET_H_600_RATIO;
return write_register(ratio, *(int*)&save_dpi_color_check_val);
}
int hg_scanner_239::get_dpi_color_check_val(int &data)
{
setting3399::Scanner_Reg_Defs ratio = setting3399::SR_SET_H_200_RATIO;
if (resolution_ <= 200)
ratio = setting3399::SR_GET_H_200_RATIO;
else if (resolution_ > 200 && resolution_ <= 300)
ratio = setting3399::SR_GET_H_300_RATIO;
else if (resolution_ > 300 && resolution_ <= 600)
ratio = setting3399::SR_GET_H_600_RATIO;
int ret = read_register(ratio, &data);
return ret;
}
int hg_scanner_239::get_status(void) int hg_scanner_239::get_status(void)
{ {
int val = 0, int val = 0,
@ -835,11 +858,15 @@ int hg_scanner_239::on_is_auto_paper(bool isautopaper)
if (isautopaper) if (isautopaper)
notify_ui_working_status("\345\276\205\347\272\270\346\211\253\346\217\217\347\212\266\346\200\201\344\270\255...", SANE_EVENT_WORKING, status_); notify_ui_working_status("\345\276\205\347\272\270\346\211\253\346\217\217\347\212\266\346\200\201\344\270\255...", SANE_EVENT_WORKING, status_);
} }
return ret; return ret;
} }
int hg_scanner_239::on_cis_get_image(bool isautopaper)
{
is_cis_image = isautopaper;
dev_conf_.params_3399.pc_correct = isautopaper;
return writedown_device_configuration();
}
void hg_scanner_239::on_device_reconnected(void) void hg_scanner_239::on_device_reconnected(void)
{ {
int ret = writedown_device_configuration(); int ret = writedown_device_configuration();
@ -1352,13 +1379,9 @@ int hg_scanner_239::get_device_log(string &logpath)
VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s buffersize: %d\n", logpath.c_str(),hg_scanner_err_name(ret),buffersize); VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s buffersize: %d\n", logpath.c_str(),hg_scanner_err_name(ret),buffersize);
return ret; return ret;
} }
int hg_scanner_239::set_devreboot() int hg_scanner_239::set_devreboot(int data)
{ {
int val = 0, return write_register(setting3399::SR_REBOOT, data);
ret = write_register(setting3399::SR_REBOOT, val);
if (ret != SCANNER_ERR_OK)
return ret;
} }
int hg_scanner_239::set_devshtudown() int hg_scanner_239::set_devshtudown()
{ {

18
hgdriver/hgdev/hg_scanner_239.h
View File

@ -45,6 +45,10 @@ class hg_scanner_239 : public hg_scanner
void discard_all_images(void); void discard_all_images(void);
void init_version(void void init_version(void
); );
protected:
virtual void on_device_reconnected(void) override;
virtual int on_scanner_closing(bool force) override;
virtual void thread_handle_usb_read(void) override;
protected: protected:
virtual int on_color_mode_changed(int& color_mode) override; //颜色切换 virtual int on_color_mode_changed(int& color_mode) override; //颜色切换
virtual int on_paper_changed(int& paper) override; //纸张大小设置 virtual int on_paper_changed(int& paper) override; //纸张大小设置
@ -59,10 +63,10 @@ protected:
virtual int on_pic_type(bool& pic)override; //照片模式或者文本模式 virtual int on_pic_type(bool& pic)override; //照片模式或者文本模式
virtual int on_pick_paper(bool autostrength)override; //自动分纸强度 virtual int on_pick_paper(bool autostrength)override; //自动分纸强度
virtual int on_pick_paper_threshold(double threshold)override; virtual int on_pick_paper_threshold(double threshold)override;
virtual int on_is_auto_paper(bool isautopaper); //待纸扫描 virtual int on_is_auto_paper(bool isautopaper)override; //待纸扫描
virtual void on_device_reconnected(void) override; virtual int on_cis_get_image(bool isautopaper) override; //cis 原图获取
virtual int on_scanner_closing(bool force) override;
virtual void thread_handle_usb_read(void) override;
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);
~hg_scanner_239(); ~hg_scanner_239();
@ -97,7 +101,7 @@ public:
virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/ virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) override; //唤醒设备 virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/ virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() override; //设置设备重启 virtual int set_devreboot(int data) override; //设置设备重启
virtual int set_devshtudown() override; //设置设备关机 virtual int set_devshtudown() override; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
@ -107,5 +111,9 @@ public:
virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/ virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/ virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/
virtual int get_scan_mode(bool& type); //获取是否是计数模式 /*/ type : fasle计数模式 true非计数 */ virtual int get_scan_mode(bool& type); //获取是否是计数模式 /*/ type : fasle计数模式 true非计数 */
virtual int set_speed_mode(int data) override; //设置速度模式 /*/ data:100,110,120
virtual int set_dpi_color_check_val(void) override; //设置畸变矫正值
virtual int get_dpi_color_check_val(void); //获取畸变矫正
}; };

57
hgdriver/hgdev/hg_scanner_300.cpp
View File

@ -625,7 +625,7 @@ int hg_scanner_300::get_scanner_paperon(SANE_Bool& type)
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::GET_PAPER_STATUS, 0, 0}; USBCB usbcb = { setting3288dsp::GET_PAPERFEEDER_STATUS, 0, 0};
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
@ -647,7 +647,7 @@ int hg_scanner_300::get_scan_is_sleep(SANE_Bool& type)
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::CHECK_IS_SLEEP, 0, 0 }; USBCB usbcb = { setting3288dsp::ACTIVE_SCANNER, 0, 0 };
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
@ -666,7 +666,6 @@ int hg_scanner_300::get_scan_is_sleep(SANE_Bool& type)
type = false; type = false;
//return SCANNER_ERR_DEVICE_SLEEPING; //return SCANNER_ERR_DEVICE_SLEEPING;
} }
return ret; return ret;
} }
///此款设备无此功能 ///此款设备无此功能
@ -686,6 +685,28 @@ int hg_scanner_300::on_set_feedmode(int feedmode)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_300::on_pic_type(bool& pic)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::on_pick_paper(bool autostrength)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::on_pick_paper_threshold(double threshold)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::on_is_auto_paper(bool isautopaper)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::on_cis_get_image(bool isautopaper)
{
is_cis_image = isautopaper;
dsp_config.params_3288.isCorrect = isautopaper == true ? 0 : 1;
return writedown_device_configuration();
}
int hg_scanner_300::on_get_feedmode(int &feedmode) int hg_scanner_300::on_get_feedmode(int &feedmode)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -694,9 +715,10 @@ int hg_scanner_300::get_device_log(string &log)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_300::set_devreboot() int hg_scanner_300::set_devreboot(int data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; USBCB usbcb = { setting3288dsp::REBOOT, data ,0 };
return writeusb(usbcb);
} }
int hg_scanner_300::set_devshtudown() int hg_scanner_300::set_devshtudown()
{ {
@ -730,6 +752,31 @@ int hg_scanner_300::set_dev_islock_file(int data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_300::set_speed_mode(int data)
{
int ret = SCANNER_ERR_OK,
len = 0;
USBCB usbcb = { setting3288dsp::SET_SPEED_MODE,data,len };
len = sizeof(usbcb);
ret = io_->write_bulk(&usbcb, &len);
return 0;
}
int hg_scanner_300::set_dpi_color_check_val(void)
{
int ret = SCANNER_ERR_OK,
len = 0;
USBCB usbcb = { setting3288dsp::SET_JUST_COF_H ,1,resolution_ };
len = sizeof(usbcb);
io_->write_bulk(&usbcb, &len);
//USBCB cmd = { setting3288dsp::GET_JUST_COF_H ,0,resolution_ };
//len = sizeof(cmd);
//io_->write_bulk(&cmd, &len);
//io_->read_bulk(&cmd, &len);
//int ratio = cmd.u32_Data;
return ret;
}
int hg_scanner_300::set_notify_sleep() int hg_scanner_300::set_notify_sleep()
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;

31
hgdriver/hgdev/hg_scanner_300.h
View File

@ -25,16 +25,23 @@ 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 protected:
virtual int on_paper_changed(int& paper); // PAPER_xxx virtual int on_color_mode_changed(int& color_mode) override; //颜色切换
virtual int on_paper_check_changed(bool& check); virtual int on_paper_changed(int& paper) override; //纸张大小设置
virtual int on_resolution_changed(int& dpi); virtual int on_paper_check_changed(bool& check) override; //尺寸检测
virtual int on_ultrasonic_check_changed(bool& check); virtual int on_resolution_changed(int& dpi) override; //分辨率设置
virtual int on_staple_check_changed(bool& check); virtual int on_ultrasonic_check_changed(bool& check) override; //设置超声波检测
virtual int on_skew_check_changed(bool& check); virtual int on_staple_check_changed(bool& check) override; //设置订书针检测
virtual int on_skew_check_level_changed(int& check); virtual int on_skew_check_changed(bool& check) override; //设置歪斜检测
virtual int on_get_feedmode(int& feedmode);//获取分纸强度 virtual int on_skew_check_level_changed(int& check) override; //设置歪斜检测强度
virtual int on_set_feedmode(int feedmode);//设置分纸强度 virtual int on_get_feedmode(int& feedmode) override; //获取分纸强度
virtual int on_set_feedmode(int feedmode) override; //设置分纸强度
virtual int on_pic_type(bool& pic)override; //照片模式或者文本模式
virtual int on_pick_paper(bool autostrength)override; //自动分纸强度
virtual int on_pick_paper_threshold(double threshold)override;
virtual int on_is_auto_paper(bool isautopaper)override; //待纸扫描
virtual int on_cis_get_image(bool isautopaper) override; //cis 原图获取
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();
@ -81,7 +88,7 @@ public:
virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/ virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) override; //唤醒设备 virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/ virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() override; //设置设备重启 virtual int set_devreboot(int data) override; //设置设备重启
virtual int set_devshtudown() override; //设置设备关机 virtual int set_devshtudown() override; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
@ -90,4 +97,6 @@ public:
virtual int set_clean_paper_road() override; //清理纸道 virtual int set_clean_paper_road() override; //清理纸道
virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/ virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁* virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*
virtual int set_speed_mode(int data) override; //设置速度模式 /*/ data:40,50,60,70
virtual int set_dpi_color_check_val(void) override; //设置畸变矫正
}; };

40
hgdriver/hgdev/hg_scanner_302.cpp
View File

@ -831,6 +831,28 @@ int hg_scanner_302::on_set_feedmode(int feedmode)//设置分纸强度
return ret; return ret;
} }
int hg_scanner_302::on_pic_type(bool& pic)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::on_pick_paper(bool autostrength)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::on_pick_paper_threshold(double threshold)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::on_is_auto_paper(bool isautopaper)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::on_cis_get_image(bool isautopaper)
{
is_cis_image = isautopaper;
dev_conf_.params_3399.pc_correct = isautopaper;
return writedown_device_configuration();
}
void hg_scanner_302::on_device_reconnected(void) void hg_scanner_302::on_device_reconnected(void)
{ {
int ret = writedown_device_configuration(); int ret = writedown_device_configuration();
@ -1188,7 +1210,7 @@ int hg_scanner_302::get_device_log(string &log)
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s\n", log.c_str(),hg_scanner_err_name(ret)); VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s\n", log.c_str(),hg_scanner_err_name(ret));
return ret; return ret;
} }
int hg_scanner_302::set_devreboot() int hg_scanner_302::set_devreboot(int data)
{ {
int val = 0, int val = 0,
ret = write_register(setting3399::SR_REBOOT, val); ret = write_register(setting3399::SR_REBOOT, val);
@ -1234,6 +1256,22 @@ int hg_scanner_302::set_dev_islock_file(int data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_302::set_speed_mode(int data)
{
return write_register(setting3399::SR_SET_SPEEDMODE, data);
}
int hg_scanner_302::set_dpi_color_check_val(void)
{
setting3399::Scanner_Reg_Defs retio = setting3399::SR_SET_H_200_RATIO;
if (resolution_ <= 200)
retio = setting3399::SR_SET_H_200_RATIO;
else if (resolution_ > 200 && resolution_ <= 300)
retio = setting3399::SR_SET_H_300_RATIO;
else if (resolution_ > 300 && resolution_ <= 600)
retio = setting3399::SR_SET_H_600_RATIO;
return write_register(retio, *(int*)&save_dpi_color_check_val);
}
int hg_scanner_302::set_notify_sleep() int hg_scanner_302::set_notify_sleep()
{ {
int val = 0, int val = 0,

35
hgdriver/hgdev/hg_scanner_302.h
View File

@ -53,24 +53,27 @@ class hg_scanner_302 : public hg_scanner
int read_one_image_from_usb(SANE_Image_Statu statu = SANE_Image_Statu_OK); int read_one_image_from_usb(SANE_Image_Statu statu = SANE_Image_Statu_OK);
void discard_all_images(void); void discard_all_images(void);
protected: protected:
int on_color_mode_changed(int& color_mode) override;
virtual int on_paper_changed(int& paper) override;
virtual int on_paper_check_changed(bool& check) override;
virtual int on_resolution_changed(int& dpi) override;
virtual int on_ultrasonic_check_changed(bool& check) override;
virtual int on_staple_check_changed(bool& check) override;
virtual int on_skew_check_changed(bool& check) override;
virtual int on_skew_check_level_changed(int& check) override;
virtual int on_get_feedmode(int &feedmode);//获取分纸强度
virtual int on_set_feedmode(int feedmode);//设置分纸强度
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;
protected:
virtual int on_color_mode_changed(int& color_mode) override; //颜色切换
virtual int on_paper_changed(int& paper) override; //纸张大小设置
virtual int on_paper_check_changed(bool& check) override; //尺寸检测
virtual int on_resolution_changed(int& dpi) override; //分辨率设置
virtual int on_ultrasonic_check_changed(bool& check) override; //设置超声波检测
virtual int on_staple_check_changed(bool& check) override; //设置订书针检测
virtual int on_skew_check_changed(bool& check) override; //设置歪斜检测
virtual int on_skew_check_level_changed(int& check) override; //设置歪斜检测强度
virtual int on_get_feedmode(int& feedmode) override; //获取分纸强度
virtual int on_set_feedmode(int feedmode) override; //设置分纸强度
virtual int on_pic_type(bool& pic)override; //照片模式或者文本模式
virtual int on_pick_paper(bool autostrength)override; //自动分纸强度
virtual int on_pick_paper_threshold(double threshold)override;
virtual int on_is_auto_paper(bool isautopaper)override; //待纸扫描
virtual int on_cis_get_image(bool isautopaper) override; //cis 原图获取
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);
@ -106,7 +109,7 @@ public:
virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/ virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) override; //唤醒设备 virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/ virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() override; //设置设备重启 virtual int set_devreboot(int data) override; //设置设备重启
virtual int set_devshtudown() override; //设置设备关机 virtual int set_devshtudown() override; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
@ -115,4 +118,6 @@ public:
virtual int set_clean_paper_road() override; //清理纸道 virtual int set_clean_paper_road() override; //清理纸道
virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/ virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/ virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/
virtual int set_speed_mode(int data) override; //设置速度模式 /*/ data:40,50,60,70
virtual int set_dpi_color_check_val(void) override; //设置畸变矫正
}; };

72
hgdriver/hgdev/hg_scanner_400.cpp
View File

@ -634,14 +634,8 @@ int hg_scanner_400::get_sleep_time(int &getsleepime)
} }
int hg_scanner_400::set_sleep_time(int setsleepime) int hg_scanner_400::set_sleep_time(int setsleepime)
{ {
USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,setsleepime, 0};
int ret = SCANNER_ERR_OK, return writeusb(usbcb);
time = setsleepime;
USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,time, 0};
ret = writeusb(usbcb);
return ret;;
} }
int hg_scanner_400::get_scanner_paperon(SANE_Bool& type) int hg_scanner_400::get_scanner_paperon(SANE_Bool& type)
@ -649,7 +643,7 @@ int hg_scanner_400::get_scanner_paperon(SANE_Bool& type)
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::GET_PAPER_STATUS, 0, 0 }; USBCB usbcb = { setting3288dsp::GET_PAPERFEEDER_STATUS, 0, 0 };
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
@ -671,7 +665,7 @@ int hg_scanner_400::get_scan_is_sleep(SANE_Bool& type)
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::CHECK_IS_SLEEP, 0, 0 }; USBCB usbcb = { setting3288dsp::ACTIVE_SCANNER, 0, 0 };
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
@ -696,20 +690,42 @@ int hg_scanner_400::get_scan_is_sleep(SANE_Bool& type)
///此款设备无此功能暂时预留 ///此款设备无此功能暂时预留
int hg_scanner_400::on_staple_check_changed(bool& check) int hg_scanner_400::on_staple_check_changed(bool& check)
{ {
return SCANNER_ERR_OK; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_400::on_skew_check_changed(bool& check) int hg_scanner_400::on_skew_check_changed(bool& check)
{ {
return SCANNER_ERR_OK; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_400::on_skew_check_level_changed(int& check) int hg_scanner_400::on_skew_check_level_changed(int& check)
{ {
return SCANNER_ERR_OK; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_400::on_set_feedmode(int feedmode) int hg_scanner_400::on_set_feedmode(int feedmode)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_400::on_pic_type(bool& pic)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::on_pick_paper(bool autostrength)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::on_pick_paper_threshold(double threshold)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::on_is_auto_paper(bool isautopaper)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::on_cis_get_image(bool isautopaper)
{
is_cis_image = isautopaper;
dsp_config.params_3288.isCorrect = isautopaper == true ? false : true; //false设置获取cis原图，true校正之后的图
return writedown_device_configuration();
}
int hg_scanner_400::on_get_feedmode(int &feedmode) int hg_scanner_400::on_get_feedmode(int &feedmode)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -719,9 +735,10 @@ int hg_scanner_400::get_device_log(string &log)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_400::set_devreboot() int hg_scanner_400::set_devreboot(int data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; USBCB usbcb = { setting3288dsp::REBOOT,data ,0 };
return writeusb(usbcb);
} }
int hg_scanner_400::set_devshtudown() int hg_scanner_400::set_devshtudown()
{ {
@ -755,6 +772,31 @@ int hg_scanner_400::set_dev_islock_file(int data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_400::set_speed_mode(int data)
{
int ret = SCANNER_ERR_OK,
len = 0;
USBCB usbcb = { setting3288dsp::SET_SPEED_MODE,data,len };
len = sizeof(usbcb);
ret = io_->write_bulk(&usbcb, &len);
return ret;
}
int hg_scanner_400::set_dpi_color_check_val(void)
{
int ret = SCANNER_ERR_OK,
len = 0;
USBCB usbcb = { setting3288dsp::SET_JUST_COF_H ,1,resolution_ };
len = sizeof(usbcb);
io_->write_bulk(&usbcb, &len);
//USBCB cmd = { setting3288dsp::GET_JUST_COF_H ,0,resolution_ };
//len = sizeof(cmd);
//io_->write_bulk(&cmd, &len);
//io_->read_bulk(&cmd, &len);
//int ratio = cmd.u32_Data;
return ret;
}
int hg_scanner_400::set_notify_sleep() int hg_scanner_400::set_notify_sleep()
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;

32
hgdriver/hgdev/hg_scanner_400.h
View File

@ -25,19 +25,23 @@ 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;
protected:
virtual int on_color_mode_changed(int& color_mode) override; //颜色切换
virtual int on_paper_changed(int& paper) override; //纸张大小设置
virtual int on_paper_check_changed(bool& check) override; //尺寸检测
virtual int on_resolution_changed(int& dpi) override; //分辨率设置
virtual int on_ultrasonic_check_changed(bool& check) override; //设置超声波检测
virtual int on_staple_check_changed(bool& check) override; //设置订书针检测
virtual int on_skew_check_changed(bool& check) override; //设置歪斜检测
virtual int on_skew_check_level_changed(int& check) override; //设置歪斜检测强度
virtual int on_get_feedmode(int& feedmode) override; //获取分纸强度
virtual int on_set_feedmode(int feedmode) override; //设置分纸强度
virtual int on_pic_type(bool& pic)override; //照片模式或者文本模式
virtual int on_pick_paper(bool autostrength)override; //自动分纸强度
virtual int on_pick_paper_threshold(double threshold)override;
virtual int on_is_auto_paper(bool isautopaper)override; //待纸扫描
virtual int on_cis_get_image(bool isautopaper) override; //cis 原图获取
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_check_changed(bool& check);
virtual int on_resolution_changed(int& dpi);
virtual int on_ultrasonic_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_level_changed(int& check);
virtual int on_get_feedmode(int& feedmode);//获取分纸强度
virtual int on_set_feedmode(int feedmode);//设置分纸强度
public: public:
hg_scanner_400(const char* dev_name,int vid, usb_io* io); hg_scanner_400(const char* dev_name,int vid, usb_io* io);
@ -87,7 +91,7 @@ public:
virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/ virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) override; //唤醒设备 virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/ virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() override; //设置设备重启 virtual int set_devreboot(int data) override; //设置设备重启
virtual int set_devshtudown() override; //设置设备关机 virtual int set_devshtudown() override; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
@ -96,4 +100,6 @@ public:
virtual int set_clean_paper_road() override; //清理纸道 virtual int set_clean_paper_road() override; //清理纸道
virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/ virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁* virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*
virtual int set_speed_mode(int data) override; //设置速度模式 /*/ data:40,50,60,70，80
virtual int set_dpi_color_check_val(void) override; //设置畸变矫正
}; };

40
hgdriver/hgdev/hg_scanner_402.cpp
View File

@ -797,6 +797,28 @@ int hg_scanner_402:: on_set_feedmode(int feedmode)//设置分纸强度
return ret; return ret;
} }
int hg_scanner_402::on_pic_type(bool& pic)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::on_pick_paper(bool autostrength)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::on_pick_paper_threshold(double threshold)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::on_is_auto_paper(bool isautopaper)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::on_cis_get_image(bool isautopaper)
{
is_cis_image = isautopaper;
dev_conf_.params_3399.pc_correct = isautopaper;
return writedown_device_configuration();
}
void hg_scanner_402::on_device_reconnected(void) void hg_scanner_402::on_device_reconnected(void)
{ {
int ret = writedown_device_configuration(); int ret = writedown_device_configuration();
@ -1148,7 +1170,7 @@ int hg_scanner_402::get_device_log(string& log)
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s\n", log.c_str(), hg_scanner_err_name(ret)); VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s\n", log.c_str(), hg_scanner_err_name(ret));
return ret; return ret;
} }
int hg_scanner_402::set_devreboot() int hg_scanner_402::set_devreboot(int data)
{ {
int val = 0, int val = 0,
ret = write_register(setting3399::SR_REBOOT, val); ret = write_register(setting3399::SR_REBOOT, val);
@ -1194,6 +1216,22 @@ int hg_scanner_402::set_dev_islock_file(int data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_402::set_speed_mode(int data)
{
return write_register(setting3399::SR_SET_SPEEDMODE, data);
}
int hg_scanner_402::set_dpi_color_check_val(void)
{
setting3399::Scanner_Reg_Defs retio = setting3399::SR_SET_H_200_RATIO;
if (resolution_ <= 200)
retio = setting3399::SR_SET_H_200_RATIO;
else if (resolution_ > 200 && resolution_ <= 300)
retio = setting3399::SR_SET_H_300_RATIO;
else if (resolution_ > 300 && resolution_ <= 600)
retio = setting3399::SR_SET_H_600_RATIO;
return write_register(retio, *(int*)&save_dpi_color_check_val);
}
int hg_scanner_402::set_notify_sleep() int hg_scanner_402::set_notify_sleep()
{ {
int val = 0, int val = 0,

35
hgdriver/hgdev/hg_scanner_402.h
View File

@ -53,24 +53,27 @@ class hg_scanner_402 : public hg_scanner
int read_one_image_from_usb(SANE_Image_Statu statu = SANE_Image_Statu_OK); int read_one_image_from_usb(SANE_Image_Statu statu = SANE_Image_Statu_OK);
void discard_all_images(void); void discard_all_images(void);
protected: protected:
int on_color_mode_changed(int& color_mode) override;
virtual int on_paper_changed(int& paper) override;
virtual int on_paper_check_changed(bool& check) override;
virtual int on_resolution_changed(int& dpi) override;
virtual int on_ultrasonic_check_changed(bool& check) override;
virtual int on_staple_check_changed(bool& check) override;
virtual int on_skew_check_changed(bool& check) override;
virtual int on_skew_check_level_changed(int& check) override;
virtual int on_get_feedmode(int &feedmode);//获取分纸强度
virtual int on_set_feedmode(int feedmode);//设置分纸强度
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;
protected:
virtual int on_color_mode_changed(int& color_mode) override; //颜色切换
virtual int on_paper_changed(int& paper) override; //纸张大小设置
virtual int on_paper_check_changed(bool& check) override; //尺寸检测
virtual int on_resolution_changed(int& dpi) override; //分辨率设置
virtual int on_ultrasonic_check_changed(bool& check) override; //设置超声波检测
virtual int on_staple_check_changed(bool& check) override; //设置订书针检测
virtual int on_skew_check_changed(bool& check) override; //设置歪斜检测
virtual int on_skew_check_level_changed(int& check) override; //设置歪斜检测强度
virtual int on_get_feedmode(int& feedmode) override; //获取分纸强度
virtual int on_set_feedmode(int feedmode) override; //设置分纸强度
virtual int on_pic_type(bool& pic)override; //照片模式或者文本模式
virtual int on_pick_paper(bool autostrength)override; //自动分纸强度
virtual int on_pick_paper_threshold(double threshold)override;
virtual int on_is_auto_paper(bool isautopaper)override; //待纸扫描
virtual int on_cis_get_image(bool isautopaper) override; //cis 原图获取
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);
@ -106,7 +109,7 @@ public:
virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/ virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) override; //唤醒设备 virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/ virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() override; //设置设备重启 virtual int set_devreboot(int data) override; //设置设备重启
virtual int set_devshtudown() override; //设置设备关机 virtual int set_devshtudown() override; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/ virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
@ -115,4 +118,6 @@ public:
virtual int set_clean_paper_road() override; //清理纸道 virtual int set_clean_paper_road() override; //清理纸道
virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/ virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/ virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/
virtual int set_speed_mode(int data) override; //设置速度模式 /*/ data:40,50,60,70，80
virtual int set_dpi_color_check_val(void) override; //设置畸变矫正
}; };

28
hgdriver/hgdev/image_process.cpp
View File

@ -1,6 +1,5 @@
#include "image_process.h" #include "image_process.h"
#include "../wrapper/hg_log.h" #include "../wrapper/hg_log.h"
#include <vector> #include <vector>
#include <string.h> #include <string.h>
#if !defined(WIN32) && !defined(_WIN64) #if !defined(WIN32) && !defined(_WIN64)
@ -43,7 +42,7 @@ typedef struct BITMAPINFOHEADER
#endif #endif
#include <memory> #include <memory>
#include "ImageMatQueue.h" #include "ImageMatQueue.h"
#include "../ImageProcess/ImageApplyHeaders.h"
#include "ImageMultiOutput.h" #include "ImageMultiOutput.h"
#include "PaperSize.h" #include "PaperSize.h"
#include "imgproc/HGOCR.h" #include "imgproc/HGOCR.h"
@ -522,12 +521,17 @@ namespace hg_imgproc
} }
cv::Mat mat(cv::imdecode(*buf, rmc)); cv::Mat mat(cv::imdecode(*buf, rmc));
//cv::imwrite("1.jpg",mat); //cv::imwrite("1.jpg",mat);
if (mat.empty()) if (mat.empty())
{ {
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 || pid_ == 0x439) if (param_.cis_image)
{
mats_.push_back(mat);
}
else 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);
@ -1295,7 +1299,21 @@ namespace hg_imgproc
return SCANNER_ERR_OK; return SCANNER_ERR_OK;
} }
int cis_test_image(CISTestImageProcess::CISTestResult &res)
{
int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_);
mats_.clear();
for (size_t i = 0; i < mats.size(); ++i)
{
CISTestImageProcess::CISTestResult r;
CISTestImageProcess::test(mats[i], r);
mats_.push_back(mats[i]);
cv::imwrite("1.jpg",mats[i]);
}
return ret;
}
HGImage opencv_to_hgbase_image(const cv::Mat& mats) HGImage opencv_to_hgbase_image(const cv::Mat& mats)
{ {
HGImage image; HGImage image;
@ -1621,6 +1639,10 @@ namespace hg_imgproc
{ {
return ((imgproc*)himg)->size_detection(); return ((imgproc*)himg)->size_detection();
} }
int cis_test_image(HIMGPRC himg, CISTestImageProcess::CISTestResult &res)
{
return ((imgproc*)himg)->cis_test_image(res);
}
int final(HIMGPRC himg) int final(HIMGPRC himg)
{ {
return ((imgproc*)himg)->final(); return ((imgproc*)himg)->final();

5
hgdriver/hgdev/image_process.h
View File

@ -9,7 +9,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include <sane/sane_ex.h> #include <sane/sane_ex.h>
#include "../ImageProcess/ImageApplyHeaders.h"
class tiny_buffer; class tiny_buffer;
namespace hg_imgproc namespace hg_imgproc
{ {
@ -148,6 +148,7 @@ namespace hg_imgproc
int color_mode; int color_mode;
bool double_side; bool double_side;
bool black_white; bool black_white;
bool cis_image; //设置原图
}IMGPRCPARAM, *LPIMGPRCPARAM; }IMGPRCPARAM, *LPIMGPRCPARAM;
typedef struct _img_header typedef struct _img_header
{ {
@ -198,7 +199,7 @@ namespace hg_imgproc
int ocr_auto_txtdirect(HIMGPRC himg); int ocr_auto_txtdirect(HIMGPRC himg);
int tesseract_auto_txtdirect(HIMGPRC himg); int tesseract_auto_txtdirect(HIMGPRC himg);
int size_detection(HIMGPRC himg); int size_detection(HIMGPRC himg);
int cis_test_image(HIMGPRC himg, CISTestImageProcess::CISTestResult& res);
int final(HIMGPRC himg); int final(HIMGPRC himg);
// pimh must not to be NULL, and pimh->total_bytes indicates the length of 'buf' // pimh must not to be NULL, and pimh->total_bytes indicates the length of 'buf'