#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())
	{
		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())
			{
				m_OrderMap[_order] = new OrderMap();
			}
			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) {
		if (_this->m_MachineCfg->IsDataSeqStragegy())
		{
			EnterCriticalSection(&m_SeqCS);
			m_SeqDataUnFinishBit[_this->m_ScannerControlCfg->m_SeqNo] = true;
			m_SupportSeqDataUnFinishBit[_this->m_ScannerControlCfg->m_SeqNo] = true;
			LeaveCriticalSection(&m_SeqCS);
			_this->ScanSeqV2();
			EnterCriticalSection(&m_SeqCS);
			m_SeqDataUnFinishBit[_this->m_ScannerControlCfg->m_SeqNo] = false;
			m_SupportSeqDataUnFinishBit[_this->m_ScannerControlCfg->m_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)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)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);
	m_SeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo] = false;
	m_SupportSeqDataUnFinishBit[m_ScannerControlCfg->m_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();

	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) {
			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);

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

		if (m_CorrectParamCfg->m_IsDynamicFocus) {
			SetDefocus(ds);
			g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_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()) {
			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 (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] = 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<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;
						if (lrel > 0) {
							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;
					if (g_isDebug) {
						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;
				}
				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;
					if (lrel > 0) {
						LeaveCriticalSection(&m_SeqCS);
						Sleep(5);
						continue;
					}
					else {
						m_ScaningBit[dbi->order] = true;
						Printdbi = dbi;
						LeaveCriticalSection(&m_SeqCS);

						if (g_isDebug) {
							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] = 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) {
				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 - 1]->laserSpeed = laserSpeed;
			SetPower(laserPower);
			g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserPower = paramSet->laser_set->laser_power;

			if (m_CorrectParamCfg->m_IsDynamicFocus) {
				SetDefocus(ds);
				g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_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()) {
				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::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) {
		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);

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

	if (m_CorrectParamCfg->m_IsDynamicFocus) {
		SetDefocus(ds);
		g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_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 ((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)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;
}

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

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

uint64_t Scanner::GetLimitCodeV2(int ivalue)
{
	bitset<64> 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;
	}

	bitset<64> 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;
	}
	m_HorizontalSeq2[ivalue] = htemp.to_ullong();
	return btemp.to_ullong();
}


map<int, uint64_t> Scanner::m_LimitMap2 = map<int, uint64_t>();
map<int, uint64_t> Scanner::m_HorizontalSeq2 = map<int, uint64_t>();
bitset<8> Scanner::m_SeqDataUnFinishBit = bitset<8>();
bitset<8> Scanner::m_SupportSeqDataUnFinishBit = bitset<8>();
bitset<64> Scanner::m_ScaningBit = bitset<64>();
CRITICAL_SECTION Scanner::m_SeqCS;
map<int, unsigned int> Scanner::m_CurrentSerio=map<int, unsigned int>();