GrpcPrint/PrintS/ScannerCtrl/Scanner.cpp

#include "Scanner.h"
#include "../global.h"
#include "../SystemInfo.h"
#include "../Logger.h"

Scanner::Scanner(ScannerControlCfg* cfg)
	:m_ScannerControlCfg(cfg)
	, m_DebugThread(INVALID_HANDLE_VALUE)
	, m_DebugFlag(false)
	, m_Thread(INVALID_HANDLE_VALUE)
	, m_HeatingScannerThread(INVALID_HANDLE_VALUE)
	, m_HeatingScannerRunFlag(false)
	, m_InfoThread(INVALID_HANDLE_VALUE)
	, m_IsLeftScan(false)
	, m_IsOrderSeqV2(false)
{
	m_TimePowerCompensateCfg = &cfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg;
	m_PowerCompensateCfg = &cfg->m_ScanCfgWrapper.m_PowerCompensateCfg;
	m_CorrectParamCfg = &cfg->m_ScanCfgWrapper.m_CorrectParamCfg;
	m_SkyWritingCfg = &cfg->m_ScanCfgWrapper.m_SkyWritingCfg;
	m_ScanParamCfg = &cfg->m_ScanCfgWrapper.m_ScanParamCfg;
	m_ScanTestCfg = &cfg->m_ScanCfgWrapper.m_ScanTestCfg;
	m_AlarmCfgWrapper = ConfigManager::GetInstance()->GetAlarmCfg();
	m_MachineCfg = ConfigManager::GetInstance()->GetMachineCfg();
	m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
	m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
	m_ScannerIO = ConfigManager::GetInstance()->GetIoCfgWrapper()->m_Laser;
	time(&m_ScanStateUpdateTime);
	m_ScanState.m_ScanStateUpdateTime->SetValue(to_string(m_ScanStateUpdateTime));
	InitializeCriticalSection(&m_ScannerInfoCS);

	m_XOffsetAssist = 0.0f;
	m_YOffsetAssist = 0.0f;

	m_ScanParamCfgMap["BlockSupport"] = &cfg->m_ScanCfgWrapper.m_SupportParams;
	m_ScanParamCfgMap["DownBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
	m_ScanParamCfgMap["DownBorderAd"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
	m_ScanParamCfgMap["DownFBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
	m_ScanParamCfgMap["DownHatching"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["DownHatching2"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["DownHatching3"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["DownHatching4"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["DownHatching5"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["DownThin"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
	m_ScanParamCfgMap["Dummy"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["InBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
	m_ScanParamCfgMap["InBorderAd"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
	m_ScanParamCfgMap["InFBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
	m_ScanParamCfgMap["InHatching"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["InThin"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
	m_ScanParamCfgMap["Other"] = &cfg->m_ScanCfgWrapper.m_ScanParamCfg;
	m_ScanParamCfgMap["SupportBorder"] = &cfg->m_ScanCfgWrapper.m_SupportParams;
	m_ScanParamCfgMap["SupportBorderAd"] = &cfg->m_ScanCfgWrapper.m_SupportParams;
	m_ScanParamCfgMap["SupportHatching"] = &cfg->m_ScanCfgWrapper.m_SupportParams;
	m_ScanParamCfgMap["UpBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
	m_ScanParamCfgMap["UpBorderAd"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
	m_ScanParamCfgMap["UpFBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
	m_ScanParamCfgMap["UpHatching"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["UpHatching2"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["UpHatching3"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["UpHatching4"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["UpHatching5"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
	m_ScanParamCfgMap["UpThin"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
}

Scanner::~Scanner()
{
	m_ScanData.clear();
	StopGetScanInfo();
	DeleteCriticalSection(&m_ScannerInfoCS);
}

void Scanner::AddDataBlock(BPBinary::BinDataBlock* bdb, MetaData::Part* part, MetaData::ParameterSet* ps, int _order, int _delaytime)
{
	DataBlockInfo* dbi = new DataBlockInfo(bdb, part, ps, _order, _delaytime);
	if (m_MachineCfg->IsDataSeqStragegy() || m_MachineCfg->IsMassStrategy())
	{
		if (_order == 0)
		{
			if (ps->set_type.find("Support") != ps->set_type.npos)
			{
				m_SupportSeq.push_back(dbi);
			}
			else {
				m_ZeroSeq.push(dbi);
			}

		}
		else {
			if (m_OrderMap.find(_order) == m_OrderMap.end())
			{
				OrderMap* om = new OrderMap();
				om->m_Order = _order;
				m_OrderMap[_order] = om;
			}
			m_OrderMap[_order]->m_DBS.push(dbi);
			//	m_OrderSeq.insert(_order);

			m_ScanData.push_back(dbi);
			m_OrderDataCountMap[_order]++;
		}
	}
	else {
		m_ScanData.push_back(dbi);
	}
}


bool Scanner::IsDebugEnable()
{
	return (m_DebugThread == INVALID_HANDLE_VALUE);
}

void Scanner::StartDebugTest()
{
	StopDebugTest();
	m_DebugFlag = true;
	m_DebugThread = AtlCreateThread(DebugProc, this);
}

void Scanner::StopDebugTest()
{
	m_DebugFlag = false;
	if (m_DebugThread != INVALID_HANDLE_VALUE) {
		if (m_ScannerControlCfg->m_ScanCfgWrapper.m_ScanTestCfg.m_is_cycle) {
			m_ScannerControlCfg->m_ScanCfgWrapper.m_ScanTestCfg.m_is_cycle = false;
		}
		Sleep(200);
		StopWork();
		if (WaitForSingleObject(m_DebugThread, 1000) == WAIT_TIMEOUT) {
			TerminateThread(m_DebugThread, 0);
		}
		CloseHandle(m_DebugThread);
		m_DebugThread = INVALID_HANDLE_VALUE;
	}
}

DWORD WINAPI Scanner::DebugProc(Scanner* _this)
{
	if (_this) {
		_this->ScanDebug();
		if (_this->m_DebugThread != INVALID_HANDLE_VALUE) {
			CloseHandle(_this->m_DebugThread);
			_this->m_DebugThread = INVALID_HANDLE_VALUE;
		}
	}
	return 0;
}

bool Scanner::BeginWork()
{
	if (m_ScanData.empty() && m_ZeroSeq.empty() && m_SupportSeq.empty())
		return false;


	if (m_Thread != INVALID_HANDLE_VALUE) {
		StopWork();
		TerminateThread(m_Thread, 1);
		CloseHandle(m_Thread);
		m_Thread = INVALID_HANDLE_VALUE;
	}
	m_Thread = AtlCreateThread(ScanProc, this);
	return true;
}

DWORD WINAPI Scanner::ScanProc(Scanner* _this)
{
	if (_this) {
		int seqNo = _this->m_ScannerControlCfg->m_SeqNo->GetValue();
		if (_this->m_MachineCfg->IsDataSeqStragegy())
		{
			EnterCriticalSection(&m_SeqCS);
			m_SeqDataUnFinishBit[seqNo] = true;
			m_SupportSeqDataUnFinishBit[seqNo] = true;
			LeaveCriticalSection(&m_SeqCS);
			_this->ScanSeqV2();
			EnterCriticalSection(&m_SeqCS);
			m_SeqDataUnFinishBit[seqNo] = false;
			m_SupportSeqDataUnFinishBit[seqNo] = false;
			LeaveCriticalSection(&m_SeqCS);
		}
		else if (_this->m_MachineCfg->IsMassStrategy())
		{
			EnterCriticalSection(&m_SeqCS);
			m_SeqDataUnFinishBit[seqNo] = true;
			m_SupportSeqDataUnFinishBit[seqNo] = true;
			LeaveCriticalSection(&m_SeqCS);
			_this->ScanMass();
			EnterCriticalSection(&m_SeqCS);
			m_SeqDataUnFinishBit[seqNo] = false;
			m_SupportSeqDataUnFinishBit[seqNo] = false;
			LeaveCriticalSection(&m_SeqCS);
		}
		else {
			_this->Scan();
		}

	}
	return 0;
}

void Scanner::WaitFinish()
{
	if (m_Thread == INVALID_HANDLE_VALUE)return;
	if (m_RunCfg->m_LogDebugInfo->GetValue())g_log->TraceInfo(u8"开始等待振镜%d完成扫描", m_ScannerControlCfg->m_SeqNo);
	WaitForSingleObject(m_Thread, INFINITE);
	Clean();
	CloseHandle(m_Thread);
	m_Thread = INVALID_HANDLE_VALUE;
	if (m_RunCfg->m_LogDebugInfo->GetValue())g_log->TraceInfo(u8"振镜%d完成扫描", m_ScannerControlCfg->m_SeqNo);
}

void Scanner::Clean()
{
	for (unsigned int i = 0; i < m_SupportSeq.size(); i++)
	{
		delete m_SupportSeq[i];
		m_SupportSeq[i] = NULL;
	}
	m_SupportSeq.clear();
	for (unsigned int i = 0; i < m_ScanData.size(); i++)
	{
		delete m_ScanData[i];
		m_ScanData[i] = NULL;
	}
	m_ScanData.clear();
	while (!m_ZeroSeq.empty()) {
		DataBlockInfo* temp = m_ZeroSeq.front();
		delete temp;
		temp = NULL;
		m_ZeroSeq.pop();
	}
	for (map<int, OrderMap*>::iterator orderIt = m_OrderMap.begin(); orderIt != m_OrderMap.end(); orderIt++) {
		OrderMap* orderMap = orderIt->second;
		while (!orderMap->m_DBS.empty()) {
			orderMap->m_DBS.pop();
		}
		delete orderMap;
		orderMap = NULL;
	}
	m_OrderMap.clear();
	m_OrderDataCountMap.clear();

	EnterCriticalSection(&m_SeqCS);
	if (m_ScannerControlCfg){
		int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue();
		m_SeqDataUnFinishBit[seqNo] = false;
		m_SupportSeqDataUnFinishBit[seqNo] = false;
	}
	LeaveCriticalSection(&m_SeqCS);
}

void Scanner::Scan(void)
{
	unsigned int memorySize = GetMemorySize();
	bool nodebug = !g_isDebug;
	//SetAutoUpdateScanInfo(false);
	//Sleep(100);
	uint64_t tnow = GetTickCount64();
	/*bool isPowerChange = false;
	float powerChangeValue = 0.0f;
	if (m_RunCfg->m_TimePowerCompensateEnable) {
		unsigned int spendtime = tnow - m_JobStartTime;

		EnterCriticalSection(&m_TimePowerCompensateCfg->m_CS);
		bool isFind = false;
		for (size_t tpIndex = 0; tpIndex < m_TimePowerCompensateCfg->m_TimePowerCompensates.size(); tpIndex++) {
			TimePowerCompensate* tpc = m_TimePowerCompensateCfg->m_TimePowerCompensates[tpIndex];
			unsigned int startMil = tpc->m_StartMinute * 60 * 1000;
			unsigned int endMil = tpc->m_EndMinute * 60 * 1000;
			if ((spendtime > startMil) && (spendtime < endMil)) {
				isPowerChange = true;
				isFind = true;
				powerChangeValue = tpc->m_Compensate;
				break;
			}
		}
		if (!isFind) {
			isPowerChange = false;
		}
		LeaveCriticalSection(&m_TimePowerCompensateCfg->m_CS);
	}*/

	//DWORD tUpdateScanInfoFlag = GetTickCount64();
	char buffer[512];
	for (unsigned int i = 0; i < m_ScanData.size(); i++)
	{

		/*DWORD ttemp = GetTickCount64();
		if (ttemp - tUpdateScanInfoFlag > 10000) {
			UpdateScannerInfo();
			tUpdateScanInfoFlag = ttemp;
		}*/

		MetaData::Part* part = m_ScanData[i]->part;
		bool ischange = false;
		if (m_RunCfg->m_OffsetRotateEnable->GetValue()) {
			if (part->partPosBean.m_XOffset != 0.0f || part->partPosBean.m_YOffset != 0.0f || part->partPosBean.m_RotateAngle != 0.0f) {
				ischange = true;
			}
		}

		BPBinary::BinDataBlock* pdb = m_ScanData[i]->bdb;
		MetaData::ParameterSet* paramSet = m_ScanData[i]->ps;
		double laserSpeed = paramSet->laser_speed;
		double laserPower = paramSet->laser_set->laser_real_power;
		double spotDiameter = paramSet->laser_set->laser_diameter;

		float ds = 0.0f;
		bool isSkyWritingEnable = true;
		double dtmep = spotDiameter - (unsigned int)(spotDiameter);
		ds = (float)(dtmep * m_CorrectParamCfg->m_DefocusRatio);
		if (spotDiameter > 100.0) {
			isSkyWritingEnable = false;
		}

		ScanParamCfg* sp = m_ScannerControlCfg->GetScanParamCfg(paramSet->set_type);
		LoadList(1, nodebug);
		UpdateScanParamByCfg(sp);
		SetSkyWritingEnable(isSkyWritingEnable, true);
		SetScanSpeed(laserSpeed);

		int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue();
		g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserSpeed = laserSpeed;
		SetPower(laserPower);
		g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserPower = paramSet->laser_set->laser_power;

		if (m_CorrectParamCfg->m_IsDynamicFocus) {
			SetDefocus(ds);
			g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserDefocus = ds;
		}
		EndList();
		ListExecute(1, nodebug);

		EnterCriticalSection(&m_SeqCS);
		sprintf_s(buffer, sizeof(buffer), "scanner:%d scan part:%d\n", seqNo, part->id);
		OutputDebugString(buffer);
		LeaveCriticalSection(&m_SeqCS);

		unsigned int currentList = 1;
		unsigned int index = 0;
		bool isfirst = true;
		bool islistStart = true;
		if (BaseCtrl::IsStop()) {
			break;
		}
		if (pdb->type == BIN_VECTOR) {
			for (size_t j = 0; j < pdb->point_indexs.size(); ++j) {
				if (BaseCtrl::IsStop()) {
					break;
				}
				BPBinary::VectorPoint* pvp = (BPBinary::VectorPoint*)pdb->point_indexs[j];
				double real_x1 = pvp->x1;
				double real_y1 = pvp->y1;
				double real_x2 = pvp->x2;
				double real_y2 = pvp->y2;
				if (ischange) {
					double mov_x1 = part->partPosBean.m_XOffset + pvp->x1;
					double mov_y1 = part->partPosBean.m_YOffset + pvp->y1;
					double mov_x2 = part->partPosBean.m_XOffset + pvp->x2;
					double mov_y2 = part->partPosBean.m_YOffset + pvp->y2;

					real_x1 = (mov_x1 - part->partPosBean.m_PartCenterX) * cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY) * sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
					real_y1 = (mov_x1 - part->partPosBean.m_PartCenterX) * sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY) * cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
					real_x2 = (mov_x2 - part->partPosBean.m_PartCenterX) * cos(part->partPosBean.m_Radians) - (mov_y2 - part->partPosBean.m_PartCenterY) * sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
					real_y2 = (mov_x2 - part->partPosBean.m_PartCenterX) * sin(part->partPosBean.m_Radians) + (mov_y2 - part->partPosBean.m_PartCenterY) * cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
				}


				if (islistStart) {
					LoadList(currentList, nodebug);
					islistStart = false;
				}
				if (BaseCtrl::IsStop()) {
					break;
				}
				index += 2;
				AddVector(real_x1, real_y1, real_x2, real_y2);
				if (index == memorySize - 2) {
					ListNop();
					index++;
				}
				if (index >= (memorySize - 1)) {
					EndList();
					islistStart = true;
					if (isfirst) {
						ListExecute(currentList, false);
						isfirst = false;
					}
					else {
						AutoChangeList();
					}
					currentList = (currentList == 1 ? 2 : 1);
					index = 0;
				}
			}
		}
		else if (pdb->type == BIN_CHAIN) {
			for (unsigned int j = 0; j < pdb->point_indexs.size(); ++j) {
				if (BaseCtrl::IsStop()) {
					break;
				}
				BPBinary::ChainPoint* point = (BPBinary::ChainPoint*)pdb->point_indexs[j];
				for (unsigned int k = 0; k < point->points.size(); ++k) {
					double real_x = point->points[k]->x;
					double real_y = point->points[k]->y;
					if (ischange) {
						double mov_x1 = part->partPosBean.m_XOffset + point->points[k]->x;
						double mov_y1 = part->partPosBean.m_YOffset + point->points[k]->y;
						real_x = (mov_x1 - part->partPosBean.m_PartCenterX) * cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY) * sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
						real_y = (mov_x1 - part->partPosBean.m_PartCenterX) * sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY) * cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
					}

					if (islistStart) {
						LoadList(currentList, nodebug);
						islistStart = false;
					}
					if (BaseCtrl::IsStop()) {
						break;
					}
					index++;
					if (k == 0) {
						JumpAbs(real_x, real_y);
					}
					else {
						MarkAbs(real_x, real_y);
					}
					if (index >= (memorySize - 1)) {
						EndList();
						islistStart = true;
						if (isfirst) {
							ListExecute(currentList, false);
							isfirst = false;
						}
						else {
							AutoChangeList();
						}
						currentList = (currentList == 1 ? 2 : 1);
						index = 0;
					}
				}
			}
		}
		if (!islistStart) {
			EndList();
			if (isfirst) {
				ListExecute(1, false);
			}
			else {
				AutoChangeList();
			}
		}
		if (nodebug)
		{
			WaitListFree();
		}

		if (g_isDebug) {
			Sleep(m_ScanData[i]->delayTime);
		}
		if (BaseCtrl::IsStop())
			break;

		Sleep(100);
	}
	//UpdateScannerInfo();
	//SetAutoUpdateScanInfo(true);
}

void Scanner::ScanSeqV2() {
	unsigned int memorySize = GetMemorySize();
	bool nodebug = !g_isDebug;
	uint64_t tnow = GetTickCount64();

	bool isSupportFinish = false;
	for (size_t supIndex = 0; supIndex < m_SupportSeq.size(); supIndex++) {
		if (BaseCtrl::IsStop())break;
		ScanDataBlock(m_SupportSeq[supIndex]);
	}
	if (BaseCtrl::IsStop())return;

	EnterCriticalSection(&m_SeqCS);
	m_SupportSeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo->GetValue()] = false;
	LeaveCriticalSection(&m_SeqCS);

	while (true && (!BaseCtrl::IsStop())) {
		EnterCriticalSection(&m_SeqCS);
		int sb = m_SupportSeqDataUnFinishBit.to_ulong();
		if (sb == 0) {
			LeaveCriticalSection(&m_SeqCS);
			break;
		}
		LeaveCriticalSection(&m_SeqCS);
		Sleep(100);
	}
	if (BaseCtrl::IsStop())return;
	while (true && !BaseCtrl::IsStop()) {
		bool isAllFinished = true;
		DataBlockInfo* Printdbi = NULL;
		if (!m_IsLeftScan && m_PairScan)
		{
			isAllFinished = false;
			DataBlockInfo* dbi = NULL;
			for (map<int, OrderMap*>::iterator orderIt = m_OrderMap.begin(); orderIt != m_OrderMap.end();) {
				if (BaseCtrl::IsStop()) {
					break;
				}
				OrderMap* orderMap = orderIt->second;
				if (orderMap->m_DBS.empty()) {
					delete orderMap;
					orderMap = NULL;
					m_OrderMap.erase(orderIt++);
				}
				else {
					int order = orderIt->first;
					if ((order > 0) && (order <= m_SeqCount))
					{
						EnterCriticalSection(&m_SeqCS);
						map<int, int>* PairOrderDataCountMap = m_PairScan->GetOrderDataCountMap();
						//	int hsCode = m_HorizontalSeq2[order];
						bitset<128>btemp = m_HorizontalSeqLeftFirst[order];
						//	bitset<64> btemp(hsCode);
						bool canPrint = true;
						for (int i = 1; i < m_SeqCount + 1; i++) {
							if (btemp[i]) {
								if (PairOrderDataCountMap->find(i) != PairOrderDataCountMap->end())
								{
									if ((*PairOrderDataCountMap)[i] > 0) {
										canPrint = false;
										break;
									}
								}
							}
						}
						LeaveCriticalSection(&m_SeqCS);

						if (!canPrint) {
							Sleep(3);
							continue;
						}

						EnterCriticalSection(&m_SeqCS);
						//uint64_t sb = m_ScaningBit.to_ullong();
						//uint64_t limitCode = m_LimitMap2[order];
						//uint64_t lrel = sb&limitCode;
						bitset<128> lrel = m_ScaningBit & m_LimitMap[order];
						if (lrel.any()) {
							LeaveCriticalSection(&m_SeqCS);
							continue;
						}

						m_ScaningBit[order] = true;
						DataBlockInfo* db = orderMap->m_DBS.front();
						dbi = db;
						orderMap->m_DBS.pop();
						isAllFinished = false;
						LeaveCriticalSection(&m_SeqCS);
					}
				}
				if (dbi) {
					Printdbi = dbi;
					/*
					stringstream ss;
					ss << "(" << Printdbi->order << ")" << "\n";
					for (int sindex = 1; sindex < m_SeqCount; sindex++) {
						if (m_ScaningBit[sindex])
						{
							ss << sindex << " ";
						}
					}
					ss << "\n";
					OutputDebugString(ss.str().c_str());
					*/
					break;
				}
				Sleep(3);
			}

			if (!Printdbi)Sleep(3);
			if (m_OrderMap.empty()) {
				isAllFinished = true;
			}
		}
		else {
			DataBlockInfo* dbi = NULL;
			for (map<int, OrderMap*>::iterator orderIt = m_OrderMap.begin(); orderIt != m_OrderMap.end();) {
				OrderMap* orderMap = orderIt->second;
				if (orderMap->m_DBS.empty()) {
					delete orderMap;
					orderMap = NULL;
					m_OrderMap.erase(orderIt++);
				}
				else {
					DataBlockInfo* db = orderMap->m_DBS.front();
					dbi = db;
					orderMap->m_DBS.pop();
					isAllFinished = false;
					break;
				}
			}
			if (dbi) {
				while (true && !BaseCtrl::IsStop())
				{
					EnterCriticalSection(&m_SeqCS);
					//	uint64_t sb = m_ScaningBit.to_ullong();
					//	uint64_t limitCode = m_LimitMap2[dbi->order];
					//	uint64_t lrel = sb&limitCode;
					bitset<128> lrel = m_ScaningBit & m_LimitMap[dbi->order];
					if (lrel.any()) {
						LeaveCriticalSection(&m_SeqCS);
						Sleep(5);
						continue;
					}
					else {
						m_ScaningBit[dbi->order] = true;
						Printdbi = dbi;
						LeaveCriticalSection(&m_SeqCS);
						/*
						stringstream ss;
						ss << "(" << Printdbi->order << ")" << "\n";
						for (int sindex = 1; sindex < 32; sindex++) {
							if (m_ScaningBit[sindex])
							{
								ss << sindex << " ";
							}
						}
						ss << "\n";
						OutputDebugString(ss.str().c_str());
						*/
						break;
					}
				}
			}
		}
		if (isAllFinished)
		{
			if (m_ZeroSeq.empty())
			{
				break;
			}
			else {
				EnterCriticalSection(&m_SeqCS);
				m_SeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo->GetValue()] = false;
				int sb = m_SeqDataUnFinishBit.to_ulong();
				if (sb == 0) {
					Printdbi = m_ZeroSeq.front();
					m_ZeroSeq.pop();
				}
				LeaveCriticalSection(&m_SeqCS);
			}
		}
		if (BaseCtrl::IsStop())break;
		if (Printdbi) {
			MetaData::Part* part = Printdbi->part;
			bool ischange = false;
			if (m_RunCfg->m_OffsetRotateEnable->GetValue()) {
				if (part->partPosBean.m_XOffset != 0.0f || part->partPosBean.m_YOffset != 0.0f || part->partPosBean.m_RotateAngle != 0.0f) {
					ischange = true;
				}
			}

			BPBinary::BinDataBlock* pdb = Printdbi->bdb;
			MetaData::ParameterSet* paramSet = Printdbi->ps;
			double laserSpeed = paramSet->laser_speed;
			double laserPower = paramSet->laser_set->laser_real_power;
			double spotDiameter = paramSet->laser_set->laser_diameter;


			float ds = 0.0f;
			bool isSkyWritingEnable = true;
			double dtmep = spotDiameter - (unsigned int)(spotDiameter);
			ds = (float)(dtmep * m_CorrectParamCfg->m_DefocusRatio);
			if (spotDiameter > 100.0) {
				isSkyWritingEnable = false;
			}

			ScanParamCfg* sp = m_ScannerControlCfg->GetScanParamCfg(paramSet->set_type);
			LoadList(1, nodebug);
			UpdateScanParamByCfg(sp);
			SetSkyWritingEnable(isSkyWritingEnable, true);
			SetScanSpeed(laserSpeed);

			g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo->GetValue() - 1]->laserSpeed = laserSpeed;
			SetPower(laserPower);
			g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo->GetValue() - 1]->laserPower = paramSet->laser_set->laser_power;

			if (m_CorrectParamCfg->m_IsDynamicFocus) {
				SetDefocus(ds);
				g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo->GetValue() - 1]->laserDefocus = ds;
			}
			EndList();
			ListExecute(1, nodebug);

			unsigned int currentList = 1;
			unsigned int index = 0;
			bool isfirst = true;
			bool islistStart = true;
			if (BaseCtrl::IsStop()) {
				break;
			}

			if (pdb->type == BIN_VECTOR) {
				for (size_t j = 0; j < pdb->point_indexs.size(); ++j) {
					if (BaseCtrl::IsStop()) {
						break;
					}
					BPBinary::VectorPoint* pvp = (BPBinary::VectorPoint*)pdb->point_indexs[j];
					double real_x1 = pvp->x1;
					double real_y1 = pvp->y1;
					double real_x2 = pvp->x2;
					double real_y2 = pvp->y2;
					if (ischange) {
						double mov_x1 = part->partPosBean.m_XOffset + pvp->x1;
						double mov_y1 = part->partPosBean.m_YOffset + pvp->y1;
						double mov_x2 = part->partPosBean.m_XOffset + pvp->x2;
						double mov_y2 = part->partPosBean.m_YOffset + pvp->y2;

						real_x1 = (mov_x1 - part->partPosBean.m_PartCenterX) * cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY) * sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
						real_y1 = (mov_x1 - part->partPosBean.m_PartCenterX) * sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY) * cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
						real_x2 = (mov_x2 - part->partPosBean.m_PartCenterX) * cos(part->partPosBean.m_Radians) - (mov_y2 - part->partPosBean.m_PartCenterY) * sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
						real_y2 = (mov_x2 - part->partPosBean.m_PartCenterX) * sin(part->partPosBean.m_Radians) + (mov_y2 - part->partPosBean.m_PartCenterY) * cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
					}


					if (islistStart) {
						LoadList(currentList, nodebug);
						islistStart = false;
					}
					if (BaseCtrl::IsStop()) {
						break;
					}
					index += 2;

					AddVector(real_x1, real_y1, real_x2, real_y2);
					if (index == memorySize - 2) {
						ListNop();
						index++;
					}
					if (index >= (memorySize - 1)) {
						EndList();
						islistStart = true;
						if (isfirst) {
							ListExecute(currentList, false);
							isfirst = false;
						}
						else {
							AutoChangeList();
						}
						currentList = (currentList == 1 ? 2 : 1);
						index = 0;
					}
				}
			}
			else if (pdb->type == BIN_CHAIN) {
				for (unsigned int j = 0; j < pdb->point_indexs.size(); ++j) {
					if (BaseCtrl::IsStop()) {
						break;
					}
					BPBinary::ChainPoint* point = (BPBinary::ChainPoint*)pdb->point_indexs[j];
					for (unsigned int k = 0; k < point->points.size(); ++k) {
						double real_x = point->points[k]->x;
						double real_y = point->points[k]->y;
						if (ischange) {
							double mov_x1 = part->partPosBean.m_XOffset + point->points[k]->x;
							double mov_y1 = part->partPosBean.m_YOffset + point->points[k]->y;
							real_x = (mov_x1 - part->partPosBean.m_PartCenterX) * cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY) * sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
							real_y = (mov_x1 - part->partPosBean.m_PartCenterX) * sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY) * cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
						}

						if (islistStart) {
							LoadList(currentList, nodebug);
							islistStart = false;
						}
						if (BaseCtrl::IsStop()) {
							break;
						}
						index++;
						if (k == 0) {
							JumpAbs(real_x, real_y);
						}
						else {
							MarkAbs(real_x, real_y);
						}
						if (index >= (memorySize - 1)) {
							EndList();
							islistStart = true;
							if (isfirst) {
								ListExecute(currentList, false);
								isfirst = false;
							}
							else {
								AutoChangeList();
							}
							currentList = (currentList == 1 ? 2 : 1);
							index = 0;
						}
					}
				}
			}
			if (!islistStart) {
				EndList();
				if (isfirst) {
					ListExecute(1, false);
				}
				else {
					AutoChangeList();
				}
			}
			if (nodebug)
			{
				WaitListFree();
			}
			else {
				//Sleep(Printdbi->delayTime);
			}

			if (BaseCtrl::IsStop())
				break;

			if ((Printdbi->order > 0) && (Printdbi->order <= m_SeqCount))
			{
				EnterCriticalSection(&m_SeqCS);
				m_ScaningBit[Printdbi->order] = false;
				m_OrderDataCountMap[Printdbi->order]--;
				LeaveCriticalSection(&m_SeqCS);
			}
			Printdbi->isFinished = true;

			/*DWORD ttemp = GetTickCount64();
			if (ttemp - tUpdateScanInfoFlag > 10000) {
			UpdateScannerInfo();
			tUpdateScanInfoFlag = ttemp;
			}*/

		}
		else {
			Sleep(20);
		}

	}
	//OutputDebugString("end\n");
}

void Scanner::ScanMass() {
	unsigned int memorySize = GetMemorySize();
	bool nodebug = !g_isDebug;
	uint64_t tnow = GetTickCount64();

	bool isSupportFinish = false;
	for (size_t supIndex = 0; supIndex < m_SupportSeq.size(); supIndex++) {
		if (BaseCtrl::IsStop())break;
		ScanDataBlock(m_SupportSeq[supIndex]);
	}
	if (BaseCtrl::IsStop())return;

	int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue();
	EnterCriticalSection(&m_SeqCS);
	m_SupportSeqDataUnFinishBit[seqNo] = false;
	LeaveCriticalSection(&m_SeqCS);

	while (true && (!BaseCtrl::IsStop())) {
		EnterCriticalSection(&m_SeqCS);
		int sb = m_SupportSeqDataUnFinishBit.to_ulong();
		if (sb == 0) {
			LeaveCriticalSection(&m_SeqCS);
			break;
		}
		LeaveCriticalSection(&m_SeqCS);
		Sleep(100);
	}
	if (BaseCtrl::IsStop())return;



	while (true && !BaseCtrl::IsStop()) {
		bool isAllFinished = true;

		OrderMap* printOrderMap = NULL;

		for (map<int, OrderMap*>::iterator orderIt = m_OrderMap.begin(); orderIt != m_OrderMap.end();) {

			if (BaseCtrl::IsStop()) {
				break;
			}
			Sleep(20);
			OrderMap* orderMap = orderIt->second;
			if (orderMap->m_DBS.empty()) {
				delete orderMap;
				orderMap = NULL;
				m_OrderMap.erase(orderIt++);
				continue;
			}
			else {
				int order = orderIt->first;
				if ((order <= 0) || (order > m_SeqCount) || (m_MassHorizontalSeq.find(order) == m_MassHorizontalSeq.end()))
				{
					delete orderMap;
					orderMap = NULL;
					m_OrderMap.erase(orderIt++);
					continue;
				}
				EnterCriticalSection(&m_SeqCS);
				int limitseq = m_MassHorizontalSeq[order];
				if (m_ScaningBit[limitseq]) {
					LeaveCriticalSection(&m_SeqCS);
					orderIt++;
					continue;
				}
				else {
					m_ScaningBit[order] = true;
					printOrderMap = orderMap;
					LeaveCriticalSection(&m_SeqCS);
					break;
				}

			}

		}

		if (printOrderMap != NULL)
		{

			while (!printOrderMap->m_DBS.empty()) {
				DataBlockInfo* dbi = printOrderMap->m_DBS.front();
				printOrderMap->m_DBS.pop();
				ScanDataBlock(dbi);
				if (BaseCtrl::IsStop()) {
					break;
				}
			}
			EnterCriticalSection(&m_SeqCS);
			m_ScaningBit[printOrderMap->m_Order] = false;
			LeaveCriticalSection(&m_SeqCS);
			printOrderMap = NULL;
		}

		if (m_OrderMap.empty()) {
			EnterCriticalSection(&m_SeqCS);
			m_SeqDataUnFinishBit[seqNo] = false;
			LeaveCriticalSection(&m_SeqCS);
			break;
		}
	}
	if (BaseCtrl::IsStop())return;

	if (m_ZeroSeq.empty())
	{
		return;
	}

	while (true && !BaseCtrl::IsStop()) {
		if (m_ZeroSeq.empty()) {
			break;
		}
		DataBlockInfo* Printdbi = NULL;
		EnterCriticalSection(&m_SeqCS);
		int sb = m_SeqDataUnFinishBit.to_ulong();
		if (sb == 0) {
			Printdbi = m_ZeroSeq.front();
			m_ZeroSeq.pop();
		}
		LeaveCriticalSection(&m_SeqCS);

		if (!Printdbi) {
			Sleep(20);
			continue;
		}
		ScanDataBlock(Printdbi);
	}
}


void Scanner::ScanDataBlock(DataBlockInfo* Printdbi)
{
	if (!Printdbi)return;
	unsigned int memorySize = GetMemorySize();
	bool nodebug = !g_isDebug;
	MetaData::Part* part = Printdbi->part;
	bool ischange = false;
	if (m_RunCfg->m_OffsetRotateEnable->GetValue()) {
		if (part->partPosBean.m_XOffset != 0.0f || part->partPosBean.m_YOffset != 0.0f || part->partPosBean.m_RotateAngle != 0.0f) {
			ischange = true;
		}
	}

	BPBinary::BinDataBlock* pdb = Printdbi->bdb;
	MetaData::ParameterSet* paramSet = Printdbi->ps;
	double laserSpeed = paramSet->laser_speed;
	double laserPower = paramSet->laser_set->laser_real_power;
	double spotDiameter = paramSet->laser_set->laser_diameter;

	float ds = 0.0f;
	bool isSkyWritingEnable = true;
	if (spotDiameter < 100.0) {
		ds = (float)(m_CorrectParamCfg->m_DefocusRatio * spotDiameter);
	}
	else {
		double dtmep = spotDiameter - (unsigned int)(spotDiameter);
		isSkyWritingEnable = false;
		ds = (float)(dtmep * m_CorrectParamCfg->m_DefocusRatio);
	}
	ScanParamCfg* sp = m_ScannerControlCfg->GetScanParamCfg(paramSet->set_type);
	LoadList(1, nodebug);
	UpdateScanParamByCfg(sp);
	SetSkyWritingEnable(isSkyWritingEnable, true);
	SetScanSpeed(laserSpeed);

	int seqNo = m_ScannerControlCfg->m_SeqNo->GetValue();
	g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserSpeed = laserSpeed;
	SetPower(laserPower);
	g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserPower = paramSet->laser_set->laser_power;

	if (m_CorrectParamCfg->m_IsDynamicFocus) {
		SetDefocus(ds);
		g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserDefocus = ds;
	}
	EndList();
	ListExecute(1, nodebug);

	unsigned int currentList = 1;
	unsigned int index = 0;
	bool isfirst = true;
	bool islistStart = true;
	if (BaseCtrl::IsStop()) {
		return;
	}

	if (pdb->type == BIN_VECTOR) {
		for (size_t j = 0; j < pdb->point_indexs.size(); ++j) {
			if (BaseCtrl::IsStop()) {
				break;
			}
			BPBinary::VectorPoint* pvp = (BPBinary::VectorPoint*)pdb->point_indexs[j];
			double real_x1 = pvp->x1;
			double real_y1 = pvp->y1;
			double real_x2 = pvp->x2;
			double real_y2 = pvp->y2;
			if (ischange) {
				double mov_x1 = part->partPosBean.m_XOffset + pvp->x1;
				double mov_y1 = part->partPosBean.m_YOffset + pvp->y1;
				double mov_x2 = part->partPosBean.m_XOffset + pvp->x2;
				double mov_y2 = part->partPosBean.m_YOffset + pvp->y2;

				real_x1 = (mov_x1 - part->partPosBean.m_PartCenterX) * cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY) * sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
				real_y1 = (mov_x1 - part->partPosBean.m_PartCenterX) * sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY) * cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
				real_x2 = (mov_x2 - part->partPosBean.m_PartCenterX) * cos(part->partPosBean.m_Radians) - (mov_y2 - part->partPosBean.m_PartCenterY) * sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
				real_y2 = (mov_x2 - part->partPosBean.m_PartCenterX) * sin(part->partPosBean.m_Radians) + (mov_y2 - part->partPosBean.m_PartCenterY) * cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
			}


			if (islistStart) {
				LoadList(currentList, nodebug);
				islistStart = false;
			}
			if (BaseCtrl::IsStop()) {
				break;
			}
			index += 2;

			AddVector(real_x1, real_y1, real_x2, real_y2);
			if (index == memorySize - 2) {
				ListNop();
				index++;
			}
			if (index >= (memorySize - 1)) {
				EndList();
				islistStart = true;
				if (isfirst) {
					ListExecute(currentList, false);
					isfirst = false;
				}
				else {
					AutoChangeList();
				}
				currentList = (currentList == 1 ? 2 : 1);
				index = 0;
			}
		}
	}
	else if (pdb->type == BIN_CHAIN) {
		for (unsigned int j = 0; j < pdb->point_indexs.size(); ++j) {
			if (BaseCtrl::IsStop()) {
				break;
			}
			BPBinary::ChainPoint* point = (BPBinary::ChainPoint*)pdb->point_indexs[j];
			for (unsigned int k = 0; k < point->points.size(); ++k) {
				double real_x = point->points[k]->x;
				double real_y = point->points[k]->y;
				if (ischange) {
					double mov_x1 = part->partPosBean.m_XOffset + point->points[k]->x;
					double mov_y1 = part->partPosBean.m_YOffset + point->points[k]->y;
					real_x = (mov_x1 - part->partPosBean.m_PartCenterX) * cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY) * sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
					real_y = (mov_x1 - part->partPosBean.m_PartCenterX) * sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY) * cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
				}

				if (islistStart) {
					LoadList(currentList, nodebug);
					islistStart = false;
				}
				if (BaseCtrl::IsStop()) {
					break;
				}
				index++;
				if (k == 0) {
					JumpAbs(real_x, real_y);
				}
				else {
					MarkAbs(real_x, real_y);
				}
				if (index >= (memorySize - 1)) {
					EndList();
					islistStart = true;
					if (isfirst) {
						ListExecute(currentList, false);
						isfirst = false;
					}
					else {
						AutoChangeList();
					}
					currentList = (currentList == 1 ? 2 : 1);
					index = 0;
				}
			}
		}
	}
	if (!islistStart) {
		EndList();
		if (isfirst) {
			ListExecute(1, false);
		}
		else {
			AutoChangeList();
		}
	}
	if (nodebug)
	{
		WaitListFree();
	}
	else {
		//	Sleep(Printdbi->delayTime );
	}

	if (BaseCtrl::IsStop())
		return;
	if (m_MachineCfg->IsDataSeqStragegy()) {
		if ((Printdbi->order > 0) && (Printdbi->order <= m_SeqCount))
		{
			EnterCriticalSection(&m_SeqCS);
			m_ScaningBit[Printdbi->order] = false;
			m_OrderDataCountMap[Printdbi->order]--;
			LeaveCriticalSection(&m_SeqCS);
		}
	}
	Printdbi->isFinished = true;
}



void Scanner::StartHeatingScannerTest()
{
	StopHeatingScannerTest();
	m_HeatingScannerRunFlag = true;
	m_HeatingScannerThread = AtlCreateThread(HeatingScannerProc, this);
}

void Scanner::StopHeatingScannerTest()
{
	m_HeatingScannerRunFlag = false;
	if (m_HeatingScannerThread != INVALID_HANDLE_VALUE) {
		if (WaitForSingleObject(m_HeatingScannerThread, 300) == WAIT_TIMEOUT) {
			StopWork();
			TerminateThread(m_HeatingScannerThread, 1);
		}
		CloseHandle(m_HeatingScannerThread);
		m_HeatingScannerThread = INVALID_HANDLE_VALUE;
	}
}

bool Scanner::IsHeatingScannerTest()
{
	return m_HeatingScannerRunFlag;
}

DWORD WINAPI Scanner::HeatingScannerProc(Scanner* _this)
{
	if (_this) {
		_this->HeatingScannerRun();
		_this->m_HeatingScannerRunFlag = false;
	}
	return 0;
}


void Scanner::WaitHeatingScanner()
{
	if (m_HeatingScannerThread == INVALID_HANDLE_VALUE)return;
	WaitForSingleObject(m_HeatingScannerThread, INFINITE);
}

void Scanner::StartGetScanInfo()
{
	if (!m_MachineCfg->m_IsIntelli->GetValue())return;
	if (m_InfoThread != INVALID_HANDLE_VALUE) {
		m_IsAutoInfo = false;
		m_InfoRunFlag = false;
		if (WaitForSingleObject(m_InfoThread, 500) == WAIT_TIMEOUT)
		{
			TerminateThread(m_InfoThread, 1);
		}
		CloseHandle(m_InfoThread);
		m_InfoThread = INVALID_HANDLE_VALUE;
	}
	m_InfoRunFlag = true;
	m_IsAutoInfo = true;
	m_InfoThread = AtlCreateThread(ScannerInfoProc, this);
}

void Scanner::StopGetScanInfo()
{
	m_IsAutoInfo = false;
	m_InfoRunFlag = false;
	if (m_InfoThread != INVALID_HANDLE_VALUE) {
		if (WaitForSingleObject(m_InfoThread, 500) == WAIT_TIMEOUT)
		{
			TerminateThread(m_InfoThread, 1);
		}
		CloseHandle(m_InfoThread);
		m_InfoThread = INVALID_HANDLE_VALUE;
	}
}

DWORD WINAPI Scanner::ScannerInfoProc(Scanner* _this)
{
	if (_this) {
		_this->ScannerInfoRun();
	}
	return 0;
}


void Scanner::SetAutoUpdateScanInfo(bool isauto)
{
	m_IsAutoInfo = isauto;
}


/*bool Scanner::IsUpScanner()
{
	if (m_LaserCfg->m_Cno < 3) {
		return true;
	}
	else return false;
}*/

void Scanner::GetLimitCodeV2(int ivalue)
{
	bitset<128> btemp;
	btemp.reset();
	switch (ivalue) {

	case 8: {
		btemp[17] = true;
		btemp[25] = true;
	}break;

	case 16: {
		btemp[17] = true;
		btemp[25] = true;
	}break;
	case 17: {
		btemp[8] = true;
		btemp[16] = true;
	}break;

	case 25: {
		btemp[8] = true;
		btemp[16] = true;
	}break;

	case 24: {
		btemp[33] = true;
		btemp[41] = true;
	}break;

	case 32: {
		btemp[33] = true;
		btemp[41] = true;
	}break;
	case 33: {
		btemp[24] = true;
		btemp[32] = true;
	}break;
	case 41: {
		btemp[24] = true;
		btemp[32] = true;
	}break;

	case 40: {
		btemp[49] = true;
		btemp[57] = true;
	}break;
	case 48: {
		btemp[49] = true;
		btemp[57] = true;
	}break;
	case 49: {
		btemp[40] = true;
		btemp[48] = true;
	}break;
	case 57: {
		btemp[40] = true;
		btemp[48] = true;
	}break;
	}
	m_LimitMap[ivalue] = btemp;

	bitset<128> htemp;
	htemp.reset();
	switch (ivalue) {
	case 1: {
		htemp[9] = true;
	}break;
	case 2: {
		htemp[9] = true;
		htemp[10] = true;
	}break;
	case 3: {
		htemp[10] = true;
		htemp[11] = true;
	}break;
	case 4: {
		htemp[11] = true;
		htemp[12] = true;
	}break;
	case 5: {
		htemp[12] = true;
		htemp[13] = true;
	}break;
	case 6: {
		htemp[13] = true;
		htemp[14] = true;
	}break;

	case 7: {
		htemp[14] = true;
		htemp[15] = true;
	}break;

	case 8: {
		htemp[15] = true;
		htemp[16] = true;
	}break;

	case 17: {
		htemp[25] = true;
	}break;
	case 18: {
		htemp[25] = true;
		htemp[26] = true;
	}break;
	case 19: {
		htemp[26] = true;
		htemp[27] = true;
	}break;
	case 20: {
		htemp[27] = true;
		htemp[28] = true;
	}break;
	case 21: {
		htemp[28] = true;
		htemp[29] = true;
	}break;
	case 22: {
		htemp[29] = true;
		htemp[30] = true;
	}break;
	case 23: {
		htemp[30] = true;
		htemp[31] = true;
	}break;
	case 24: {
		htemp[31] = true;
		htemp[32] = true;
	}break;

	case 33: {
		htemp[41] = true;
	}break;
	case 34: {
		htemp[41] = true;
		htemp[42] = true;
	}break;
	case 35: {
		htemp[42] = true;
		htemp[43] = true;
	}break;
	case 36: {
		htemp[43] = true;
		htemp[44] = true;
	}break;
	case 37: {
		htemp[44] = true;
		htemp[45] = true;
	}break;
	case 38: {
		htemp[45] = true;
		htemp[46] = true;
	}break;
	case 39: {
		htemp[46] = true;
		htemp[47] = true;
	}break;
	case 40: {
		htemp[47] = true;
		htemp[48] = true;
	}break;
	case 49: {
		htemp[57] = true;
	}break;
	case 50: {
		htemp[57] = true;
		htemp[58] = true;
	}break;
	case 51: {
		htemp[58] = true;
		htemp[59] = true;
	}break;
	case 52: {
		htemp[59] = true;
		htemp[60] = true;
	}break;
	case 53: {
		htemp[60] = true;
		htemp[61] = true;
	}break;
	case 54: {
		htemp[61] = true;
		htemp[62] = true;
	}break;
	case 55: {
		htemp[62] = true;
		htemp[63] = true;
	}break;
	case 56: {
		htemp[63] = true;
		htemp[64] = true;
	}break;
	}
	m_HorizontalSeqRightFirst[ivalue] = htemp;


	bitset<128> htemp2;
	htemp2.reset();
	switch (ivalue) {
	case 9: {
		htemp2[1] = true;
	}break;
	case 10: {
		htemp2[1] = true;
		htemp2[2] = true;
	}break;
	case 11: {
		htemp2[2] = true;
		htemp2[3] = true;
	}break;
	case 12: {
		htemp2[3] = true;
		htemp2[4] = true;
	}break;
	case 13: {
		htemp2[4] = true;
		htemp2[5] = true;
	}break;
	case 14: {
		htemp2[5] = true;
		htemp2[6] = true;
	}break;

	case 15: {
		htemp2[6] = true;
		htemp2[7] = true;
	}break;

	case 16: {
		htemp2[7] = true;
		htemp2[8] = true;
	}break;

	case 25: {
		htemp2[17] = true;
	}break;
	case 26: {
		htemp2[17] = true;
		htemp2[18] = true;
	}break;
	case 27: {
		htemp2[18] = true;
		htemp2[19] = true;
	}break;
	case 28: {
		htemp2[19] = true;
		htemp2[20] = true;
	}break;
	case 29: {
		htemp2[20] = true;
		htemp2[21] = true;
	}break;
	case 30: {
		htemp2[21] = true;
		htemp2[22] = true;
	}break;
	case 31: {
		htemp2[22] = true;
		htemp2[23] = true;
	}break;
	case 32: {
		htemp2[23] = true;
		htemp2[24] = true;
	}break;

	case 41: {
		htemp2[33] = true;
	}break;
	case 42: {
		htemp2[33] = true;
		htemp2[34] = true;
	}break;
	case 43: {
		htemp2[34] = true;
		htemp2[35] = true;
	}break;
	case 44: {
		htemp2[35] = true;
		htemp2[36] = true;
	}break;
	case 45: {
		htemp2[36] = true;
		htemp2[37] = true;
	}break;
	case 46: {
		htemp2[37] = true;
		htemp2[38] = true;
	}break;
	case 47: {
		htemp2[38] = true;
		htemp2[39] = true;
	}break;
	case 48: {
		htemp2[39] = true;
		htemp2[40] = true;
	}break;
	case 57: {
		htemp2[49] = true;
	}break;
	case 58: {
		htemp2[49] = true;
		htemp2[50] = true;
	}break;
	case 59: {
		htemp2[50] = true;
		htemp2[51] = true;
	}break;
	case 60: {
		htemp2[51] = true;
		htemp2[52] = true;
	}break;
	case 61: {
		htemp2[52] = true;
		htemp2[53] = true;
	}break;
	case 62: {
		htemp2[53] = true;
		htemp2[54] = true;
	}break;
	case 63: {
		htemp2[54] = true;
		htemp2[55] = true;
	}break;
	case 64: {
		htemp2[55] = true;
		htemp2[56] = true;
	}break;
	}
	m_HorizontalSeqLeftFirst[ivalue] = htemp2;

}


void Scanner::InitMassLimitCode()
{
	m_MassHorizontalSeq[1] = 9;
	m_MassHorizontalSeq[2] = 10;
	m_MassHorizontalSeq[3] = 11;
	m_MassHorizontalSeq[4] = 12;
	m_MassHorizontalSeq[5] = 13;
	m_MassHorizontalSeq[6] = 14;
	m_MassHorizontalSeq[7] = 15;
	m_MassHorizontalSeq[8] = 16;

	m_MassHorizontalSeq[9] = 1;
	m_MassHorizontalSeq[10] = 2;
	m_MassHorizontalSeq[11] = 3;
	m_MassHorizontalSeq[12] = 4;
	m_MassHorizontalSeq[13] = 5;
	m_MassHorizontalSeq[14] = 6;
	m_MassHorizontalSeq[15] = 7;
	m_MassHorizontalSeq[16] = 8;

	m_MassHorizontalSeq[17] = 25;
	m_MassHorizontalSeq[18] = 26;
	m_MassHorizontalSeq[19] = 27;
	m_MassHorizontalSeq[20] = 28;
	m_MassHorizontalSeq[21] = 29;
	m_MassHorizontalSeq[22] = 30;
	m_MassHorizontalSeq[23] = 31;
	m_MassHorizontalSeq[24] = 32;

	m_MassHorizontalSeq[25] = 17;
	m_MassHorizontalSeq[26] = 18;
	m_MassHorizontalSeq[27] = 19;
	m_MassHorizontalSeq[28] = 20;
	m_MassHorizontalSeq[29] = 21;
	m_MassHorizontalSeq[30] = 22;
	m_MassHorizontalSeq[31] = 23;
	m_MassHorizontalSeq[32] = 24;

	m_MassHorizontalSeq[33] = 41;
	m_MassHorizontalSeq[34] = 42;
	m_MassHorizontalSeq[35] = 43;
	m_MassHorizontalSeq[36] = 44;
	m_MassHorizontalSeq[37] = 45;
	m_MassHorizontalSeq[38] = 46;
	m_MassHorizontalSeq[39] = 47;
	m_MassHorizontalSeq[40] = 48;

	m_MassHorizontalSeq[41] = 33;
	m_MassHorizontalSeq[42] = 34;
	m_MassHorizontalSeq[43] = 35;
	m_MassHorizontalSeq[44] = 36;
	m_MassHorizontalSeq[45] = 37;
	m_MassHorizontalSeq[46] = 38;
	m_MassHorizontalSeq[47] = 39;
	m_MassHorizontalSeq[48] = 40;

	m_MassHorizontalSeq[49] = 57;
	m_MassHorizontalSeq[50] = 58;
	m_MassHorizontalSeq[51] = 59;
	m_MassHorizontalSeq[52] = 60;
	m_MassHorizontalSeq[53] = 61;
	m_MassHorizontalSeq[54] = 62;
	m_MassHorizontalSeq[55] = 63;
	m_MassHorizontalSeq[56] = 64;

	m_MassHorizontalSeq[57] = 49;
	m_MassHorizontalSeq[58] = 50;
	m_MassHorizontalSeq[59] = 51;
	m_MassHorizontalSeq[60] = 52;
	m_MassHorizontalSeq[61] = 53;
	m_MassHorizontalSeq[62] = 54;
	m_MassHorizontalSeq[63] = 55;
	m_MassHorizontalSeq[64] = 56;

}

void Scanner::GetXYScanState(ScanStateXYSCT* scanstate, time_t& t)
{
	EnterCriticalSection(&m_ScannerInfoCS);
	t = m_ScanStateUpdateTime;

	m_ScanState.m_X.GetState(scanstate->m_X);
	m_ScanState.m_Y.GetState(scanstate->m_Y);
	m_ScanState.m_Focus.GetState(scanstate->m_Focus);
	//memcpy_s(&scanstate->m_X, sizeof(IntelliScanState), &m_ScanState.m_X, sizeof(IntelliScanState));
	//memcpy_s(&scanstate->m_Y, sizeof(IntelliScanState), &m_ScanState.m_Y, sizeof(IntelliScanState));
	LeaveCriticalSection(&m_ScannerInfoCS);
}


map<int, bitset<128>> Scanner::m_LimitMap = map<int, bitset<128>>();
map<int, bitset<128>> Scanner::m_HorizontalSeqRightFirst = map<int, bitset<128>>();
map<int, bitset<128>> Scanner::m_HorizontalSeqLeftFirst = map<int, bitset<128>>();
bitset<16> Scanner::m_SeqDataUnFinishBit = bitset<16>();
bitset<16> Scanner::m_SupportSeqDataUnFinishBit = bitset<16>();
bitset<128> Scanner::m_ScaningBit = bitset<128>();
CRITICAL_SECTION Scanner::m_SeqCS;
map<int, unsigned int> Scanner::m_CurrentSerio = map<int, unsigned int>();
map<int, int> Scanner::m_MassHorizontalSeq = map<int, int>();
int Scanner::m_SeqCount = 64;