twain3.0/huagao/Device/GScanVirtual.cpp

#include "stdafx.h"
#include "GScanVirtual.h"
#include "UsbScanEx.h"
#include "opencv2/opencv.hpp"
#include "UsbScanEx.h"
#include "StopWatch.h"
#include "filetools.h"
#include "ImageMatQueue.h"

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();
}

void GScanVirtual::regist_deviceevent_callback(deviceevent_callback callback, void* usrdata)
{
}

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();//ֹͣɨÃè
				//ResetScanner();
				return HARDWARE_ERROR;
			}

			if (!is_scan()) {
				if (devState == DEV_WRONG) {
					return get_ErrorCode();
				}
				return 0;
			}
		}
		else {
			if (m_pImages->valid()) {
				bmpdata = *(m_pImages->popBmpdata());
				return 0;
			}
		}
	}
}

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

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

std::string GScanVirtual::GetSerialNum()
{
	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)
{
	m_pImages->setparam(params);
}

void GScanVirtual::Scanner_StartScan(UINT16 count)
{
	if (m_threadUsb && m_threadUsb->joinable()) {
		m_threadUsb->join();
	}

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

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

void GScanVirtual::clear_hwerror()
{
}

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();
	}
}


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_ISRUNNING;

	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 G400Decode(imgData)));
				std::this_thread::sleep_for(std::chrono::milliseconds(1000));
			}
		}
	}
	devState = DEV_STOP;
	return 0;
}


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