twain3/device/GScanVirtual.cpp

#include "GScanVirtual.h"
#include "opencv2/opencv.hpp"
#include "StopWatch.h"
#include "filetools.h"
#include "ImageMatQueue.h"
#include <IUsb.h>

using namespace std;

GScanVirtual::GScanVirtual()
{
}

GScanVirtual::~GScanVirtual()
{
	if (m_threadUsb && m_threadUsb->joinable()) {
		devState = DEV_STOP;
		m_threadUsb->join();
		m_threadUsb.reset();
	}
}

void GScanVirtual::open(int vid, int pid)
{
	fstream fs;
	fs.open("D:\\1.txt",ios::out);
	fs << 1;
	fs.close();
}

int GScanVirtual::aquire_bmpdata(std::vector<unsigned char>& bmpdata)
{
	StopWatch sw;
	while (true)
	{
		if (Get_IsImageQueueEmpty() && is_scan()) {
			DoEvents();
			this_thread::sleep_for(chrono::milliseconds(1));
			if (sw.elapsed_s() > 15.00)
			{
				if (m_threadUsb && m_threadUsb->joinable()) {
					devState = DEV_STOP;
					m_threadUsb->join();
					m_threadUsb.reset();
				}
				Stop_scan();//ֹͣɨ<D6B9><C9A8>
				ResetScanner();
				return HARDWARE_ERROR;
			}

			if (!is_scan()) {
				if (devState == DEV_WRONG) {
					return get_ErrorCode();
				}
				return 0;
			}
		}
		else {
			if (m_pImages->valid()) {
				 cv::imencode("bmp",m_pImages->popimage().mat, bmpdata);
				return 0;
			}
		}
	}
}

bool GScanVirtual::IsConnected()
{
	return true;
}

std::string GScanVirtual::GetFWVersion(int mode)
{
	return "201901012020";
}

std::string GScanVirtual::GetSerialNum(int mode)
{
	return "208881100";
}

bool GScanVirtual::is_scan()
{
	std::lock_guard<std::mutex> lck(m_imgLocker);
	std::ifstream io("d:\\1.txt");
	int ret;
	io >> ret;
	return ret;
}

bool GScanVirtual::Get_Scanner_PaperOn()
{
	std::ifstream io("d:\\1.txt");
	int ret;
	io >> ret;
	return ret;
}

void GScanVirtual::config_params(GScanCap& params,int mode)
{
	m_pImages->setparam(params);
}

void GScanVirtual::Scanner_StartScan(UINT32 count,int mode)
{
	if (m_threadUsb && m_threadUsb->joinable()) {
		m_threadUsb->join();
	}

	m_threadUsb.reset(new std::thread(&GScanVirtual::usbmain, this));
	m_pImages->run();
    devState = DEV_RUNNING;
}

void GScanVirtual::clear_hwerror()
{
	;
}

void GScanVirtual::Stop_scan()
{
	std::lock_guard<std::mutex> lck(m_imgLocker);
	fstream fs("D:\\1.txt", ios::out);
	fs << 0;
	fs.close();
}

void GScanVirtual::ResetScanner()
{

}

bool GScanVirtual::Get_IsImageQueueEmpty()
{
	std::lock_guard<std::mutex> lck(m_imgLocker);
	return m_pImages->empty();
}

void GScanVirtual::reset()
{
	std::lock_guard<std::mutex> lck(m_imgLocker);
	while (!m_pImages->empty())
	{
		m_pImages->clear();
	}
}

void GScanVirtual::setdecodepixtype(int twpixtype)
{
		pixType = twpixtype;
}

UINT32 GScanVirtual::get_ErrorCode()
{
	std::lock_guard<std::mutex> lck(m_imgLocker);
	return Error_Code;
}

void GScanVirtual::Set_ErrorCode(UINT32 value)
{
	std::lock_guard<std::mutex> lck(m_imgLocker);
	Error_Code = value;
}

int GScanVirtual::get_scanned_num()
{
	if (!m_usb->is_connected())
		return -1;

	std::lock_guard<std::mutex> lck(m_imgLocker);
	return 1;
}

DWORD GScanVirtual::usbmain()
{
	cv::Mat imgData;
	cv::Mat bufferF;
	cv::Mat bufferB;
    devState = DEV_RUNNING;

	while (Get_Scanner_PaperOn()) {
		std::vector<std::string> files = FileTools::getFiles("D:\\bb");
		for (int i = 0; i < files.size(); i++) {
			if (!Get_Scanner_PaperOn()) { break; }
			std::vector<cv::Mat> mats;
			FILE* file = fopen(files[i].c_str(), "rb");
			if (file) {
				fseek(file, 0, SEEK_END);
				int length = ftell(file);
				fseek(file, 0, SEEK_SET);
				std::shared_ptr<std::vector<char>> imgData(new std::vector<char>(length));
				fread(imgData->data(), sizeof(unsigned char), length, file);
				fclose(file);
				m_pImages->pushMat(std::shared_ptr<IDecode>(new GRawDecode(imgData)));
				this_thread::sleep_for(std::chrono::milliseconds(1000));
			}
		}
	}
	devState = DEV_STOP;
	return 0;
}


///////////////////////////////////////////////////////////////////////////
void GScanVirtual::Pop_Image()
{
}

bool GScanVirtual::close()
{
	return false;
}

bool GScanVirtual::is_open()
{
	return false;
}

void GScanVirtual::setusbreport_callback(usbreport_callback callback /* = 0 */, void* usrdata /* = 0 */)
{
}

int GScanVirtual::get_image_front_info(ImageInfo* info)
{
	return 0;
}

int GScanVirtual::aquire_image(cv::Mat& mat, int& bppinfo)
{
	return 0;
}

int GScanVirtual::get_roller_num()
{
	return 0;
}

void GScanVirtual::clr_roller_num()
{
}

int GScanVirtual::get_sleep_time()
{
	return 0;
}

void GScanVirtual::set_sleep_time(int time)
{
}

bool GScanVirtual::clr_hardware_cache()
{
	return 0;
}