#include "StdAfx.h"
#include "InterfaceManager.h"
#include "MulticamControl.h"
#include "RadientControl.h"
#include "SapControl.h"
#include "SapLineGrab.h"
#include "FreeImage.h"
#include <io.h>
#include "ExpireDayDefine.h"

//#define TEST_SIGNAL_PROCESS

#define OFFSET_SPLINE_DATA	10
#define JPEG_RATE					JPEG_QUALITYNORMAL|JPEG_OPTIMIZE
#define JPEG_FULLIMAGE_RATE			JPEG_QUALITYGOOD|JPEG_OPTIMIZE

CInterfaceManager::CInterfaceManager(void)
{
	m_pLogManager = new CLogManager(0,_T("LOGVIEW"));
	m_pView = NULL;
	m_bPLCGlassLoading = FALSE;
	m_pControlInterface = NULL;	
	m_pTransDataManager = NULL;	
	m_pLightManager = NULL;
	m_pTriggerBoardControl = NULL;

	for(int i=0;i<MAX_CAMERA_COUNT;i++)
	{
		m_pInspect[i] = NULL;
		m_pGrabber[i] = NULL;
	}

	m_pThread_SendMSG = NULL;
	m_pThread_CheckSequence = NULL;
	m_pThread_ViewRefresh = NULL;
	m_nScanStartCount = 0;
	m_bGlassLoadingEnd = FALSE;
}

CInterfaceManager::~CInterfaceManager(void)
{	
	DeleteProfileData();	

	for(int i=0;i<MAX_CAMERA_COUNT;i++)
	{
		if(m_pInspect[i] != NULL)
		{
			m_pInspect[i]->SetProcessEnd();
			Sleep(100);
			m_pInspect[i]->ReleaseThread();
			delete m_pInspect[i];
		}
		m_pInspect[i] = NULL;		
	}

	DeinitGrabber();

	if(m_pTransDataManager != NULL)
		delete m_pTransDataManager;
	m_pTransDataManager = NULL;

	if(m_pControlInterface != NULL)			
		delete m_pControlInterface;	
	m_pControlInterface = NULL;	

	if(m_pLightManager != NULL)
		delete m_pLightManager;
	m_pLightManager = NULL;

	if(m_pLogManager != NULL)
		delete m_pLogManager;
	m_pLogManager=NULL;

	if(m_pTriggerBoardControl != NULL)
		delete m_pTriggerBoardControl;
	m_pTriggerBoardControl=NULL;

	if(m_pLicense != NULL)
		delete m_pLicense;
	m_pLicense = NULL;
}

BOOL CInterfaceManager::DestroyThread()
{
	if(m_pThread_SendMSG != NULL)
	{
		m_pThread_SendMSG->StopThread();
		delete m_pThread_SendMSG;	
	}
	m_pThread_SendMSG = NULL;		

	if(m_pThread_CheckSequence != NULL)
	{
		m_pThread_CheckSequence->StopThread();
		delete m_pThread_CheckSequence;
	}
	m_pThread_CheckSequence = NULL;

	if(m_pThread_ViewRefresh != NULL)
	{
		m_pThread_ViewRefresh->StopThread();
		delete m_pThread_ViewRefresh;
	}
	m_pThread_ViewRefresh = NULL;	

	/*
	if(m_pThread_NetMSG != NULL)		
	{
		m_pThread_NetMSG->StopThread();
		delete m_pThread_NetMSG;
	}
	m_pThread_NetMSG = NULL;

		

	if(m_pThread_Light != NULL)
	{
		m_pThread_Light->StopThread();
		delete m_pThread_Light;	
	}
	m_pThread_Light = NULL;			
	*/

	return TRUE;
}

UINT CInterfaceManager::PLCSignalThreadFunc(LPVOID pParam)
{
	CInterfaceManager		*pInter = (CInterfaceManager*)pParam;

	pInter->PLCSignalRetry(pInter->m_emPLCSection,pInter->m_emPLCSendSignal,pInter->m_emPLCControlSignal);

	return 0;
}

// End SignalÀ» PLC¿¡¼­ Àß ¸ø¹Þ¾Æ¼­ Retry ³Ö¾úÀ½
void CInterfaceManager::PLCSignalRetry(SEND_MESSAGE_SECTION emSection,InspectToControlSignal emSendSignal,enInterface_Send_Control emControlSignal)
{
	if(m_HardwareRecipe.m_nPLCSignalRetry <= 0)
		return;

	switch(emSendSignal)
	{
	case IToC_Ack_LoadingSuccess:
	case IToC_Ack_ShortScanEndSuccess:
	case IToC_Ack_ShortScanEndFail:				
	case IToC_Ack_LongScanEndSuccess:	
	case IToC_Ack_LongScanEndFail:			
		break;
	default:
		return;
	}		

	int		nRetryCount = m_HardwareRecipe.m_nPLCSignalRetry;
	int		nSignalOnTime = 300;//((CPLCControl_Interface_B5*) m_pControlInterface)->GetSignalOnTime(emSendSignal);

	DWORD	dwTick = GetTickCount();
	DWORD	dwWaitTick;
	DWORD	dwWaitTime = nSignalOnTime+200;	
	int		nCount = 0;	
	BOOL	bSendSignal = FALSE;

	while(TRUE)
	{
		dwWaitTick = GetTickCount() - dwTick;
		if(dwWaitTime < dwWaitTick)
		{						
			nCount++;
			bSendSignal = FALSE;
			dwTick = GetTickCount();			
		}

		switch(emSendSignal)
		{
		case IToC_Ack_LoadingSuccess:
			break;
		case IToC_Ack_ShortScanEndSuccess:
		case IToC_Ack_ShortScanEndFail:		
			if(m_bPLCGlassLoading == TRUE)
			{
				g_pLog->DisplayMessage(_T("Ack Short PLC End : Rcv GlassLoading PLC Signal %d"),m_bPLCGlassLoading);
				return;
			}
			break;
		case IToC_Ack_LongScanEndSuccess:	
		case IToC_Ack_LongScanEndFail:	
			if(m_bShortPLCScanStart == TRUE)
			{
				g_pLog->DisplayMessage(_T("Ack Long PLC End : Rcv Short Start PLC Signal %d"),m_bShortPLCScanStart);
				return;
			}
			break;
		default:
			return;
		}		

		if(bSendSignal == FALSE)
		{
			int nRet = m_pControlInterface->SendConstrol(emControlSignal,TRUE);		
			g_pLog->DisplayMessage(_T("PLC Retry_ON[%d] Send Control Signal : Sig %d, Val %d, Ret %d"),nCount,(int)emControlSignal,TRUE,nRet);

			Sleep(nSignalOnTime);

			nRet = m_pControlInterface->SendConstrol(emControlSignal,FALSE);
			g_pLog->DisplayMessage(_T("PLC Retry_OFF[%d] Send Control Signal : Sig %d, Val %d, Ret %d"),nCount,(int)emControlSignal,TRUE,nRet);

			bSendSignal = TRUE;
		}	

		if(nCount >= nRetryCount)
			break;

		g_pLog->DisplayMessage(_T("PLC Retry_Down Check loop"));

		Sleep(1);
	}	
}

void CInterfaceManager::SendMsgInspectToControlSignal(CPostSendMessage *pNetMSG)
{
	InspectToControlSignal emSendSignal = static_cast<InspectToControlSignal>(pNetMSG->nSignal);	
	int		nValue = pNetMSG->nValue;
	CString	str;
	enInterface_Send_Control	emControlSignal = enInterface_None;

	if(nValue == TRUE)
		str = _T("On");
	else
		str = _T("Off");

	switch(emSendSignal)
	{
	case IToC_Ack_LoadingSuccess:
	case IToC_Ack_LoadingFail:
		g_pLog->DisplayMessage(_T("Send Control Signal : Ack Signal Glass Loading %s"),(TCHAR*)(LPCTSTR)str);

		emControlSignal = GLASSLOADING_HANDSHAKE;
		break;	
	case IToC_Ack_ShortScanStartSuccess:
	case IToC_Ack_ShortScanStartFail:	
		emControlSignal = SHORT_SCANSTART_HANDSHAKE;
		g_pLog->DisplayMessage(_T("Send Control Signal : Ack Signal Short Scan Start %s"),(TCHAR*)(LPCTSTR)str);	
		break;
	case IToC_Ack_ShortScanEndSuccess:
	case IToC_Ack_ShortScanEndFail:		
#ifdef			TEST_SIGNAL_PROCESS
		Sleep(2000);
#endif
		emControlSignal = SHORT_SCANEND_HANDSHAKE;
		g_pLog->DisplayMessage(_T("Send Control Signal : Ack Signal Short Scan End %s"),(TCHAR*)(LPCTSTR)str);
		break;
	case IToC_Ack_LongScanStartSuccess:
	case IToC_Ack_LongScanStartFail:	
		emControlSignal = LONG_SCANSTART_HANDSHAKE;
		g_pLog->DisplayMessage(_T("Send Control Signal : Ack Signal Long Scan Start %s"),(TCHAR*)(LPCTSTR)str);	
		break;	
	case IToC_Ack_LongScanEndSuccess:	
	case IToC_Ack_LongScanEndFail:	
#ifdef			TEST_SIGNAL_PROCESS
		Sleep(2000);
#endif
		emControlSignal = LONG_SCANEND_HANDSHAKE;
		g_pLog->DisplayMessage(_T("Send Control Signal : Ack Signal Long Scan End %s"),(TCHAR*)(LPCTSTR)str);
		break;			
	default:
		return;
	}	

	WaitEndSignal(emSendSignal);

	if(emControlSignal < enInterface_None)
	{
		int nDelayTime = m_pControlInterface->GetSignalDelayTime(pNetMSG->nSignal);

		if(nDelayTime != 0)
			Sleep(nDelayTime);

		if(m_HardwareRecipe.m_nPLCSignalRetry > 0)
		{
			switch(emSendSignal)
			{
			case IToC_Ack_LoadingSuccess:
			case IToC_Ack_ShortScanEndSuccess:
			case IToC_Ack_ShortScanEndFail:				
			case IToC_Ack_LongScanEndSuccess:	
			case IToC_Ack_LongScanEndFail:			
				{
					CSingleLock		myLock(&m_csPLCSignal);
					myLock.Lock();
					m_emPLCSection = pNetMSG->emSection;
					m_emPLCSendSignal = emSendSignal;
					m_emPLCControlSignal = emControlSignal;

					AfxBeginThread(PLCSignalThreadFunc,this);
					myLock.Unlock();
					break;
				}
			default:
				{
					int nRet = m_pControlInterface->SendConstrol(emControlSignal,nValue);		
					g_pLog->DisplayMessage(_T("Send Control Signal : Sig %d, Val %d, Ret %d"),(int)emControlSignal,nValue,nRet);

					if(nValue == TRUE && m_pThread_SendMSG != NULL)
					{
						int nSignalOnTime = m_pControlInterface->GetSignalOnTime(pNetMSG->nSignal);

						m_pThread_SendMSG->AddDisableMSG(pNetMSG->emSection,pNetMSG->nSignal,FALSE,nSignalOnTime);
						g_pLog->DisplayMessage(_T("Add Disable Msg"));
					}
				}
				break;
			}
		}
		else
		{
			int nRet = m_pControlInterface->SendConstrol(emControlSignal,nValue);		
			g_pLog->DisplayMessage(_T("Send Control Signal : Sig %d, Val %d, Ret %d"),(int)emControlSignal,nValue,nRet);

			if(nValue == TRUE && m_pThread_SendMSG != NULL)
			{
				int nSignalOnTime = m_pControlInterface->GetSignalOnTime(pNetMSG->nSignal);

				m_pThread_SendMSG->AddDisableMSG(pNetMSG->emSection,pNetMSG->nSignal,FALSE,nSignalOnTime);
			}
		}
	}
}

void CInterfaceManager::SendMsgInspectToControlAlarm(CPostSendMessage *pNetMSG)
{
	InspectToControlAlarm emSendAlarm = static_cast<InspectToControlAlarm>(pNetMSG->nSignal);	
	int		nValue = pNetMSG->nValue;	

	enInterface_Send_Control	emControlSignal = enInterface_None;

	switch(emSendAlarm)
	{
	case IToC_Alarm_InspectorError:

		break;		
	case IToC_Alarm_InspectOverflow:			

		break;	
	case IToC_Alarm_EdgeCrack:			
		break;	
	case IToC_Alarm_NoRecipe:	

		break;	
	case IToC_Alarm_FindEdgeFail:			
		break;	
	case IToC_Alarm_LightError:			

		break;
	case IToC_Alarm_UpperLimit:		
		break;	
	case IToC_Alarm_LowestLimit:		
		break;	
	case IToC_Alarm_NoImage:			
		break;
	case IToC_Alarm_GlassDetectFail:		
		break;	
	case IToC_Alarm_TransferData:		
		break;
	case IToC_Alarm_InternalValue:		
		break;	
	default:
		return;
	}	

	if(emControlSignal < enInterface_None)
	{
		int nRet = m_pControlInterface->SendConstrol(emControlSignal,nValue);		
		g_pLog->DisplayMessage(_T("Send Control Alarm : Sig %d, Val %d, Ret %d"),(int)emControlSignal,nValue,nRet);
	}
}

void CInterfaceManager::SendMSG_Received(CPostSendMessage *pSendMSG)
{
	if(pSendMSG == NULL)
		return;

	switch(pSendMSG->emSection)
	{	
	case SEND_MESSAGE_CONTROLSIGNAL:
		SendMsgInspectToControlSignal(pSendMSG);
		break;
	case SEND_MESSAGE_ALARM:
		SendMsgInspectToControlAlarm(pSendMSG);				
		break;	
	}
}

void CInterfaceManager::II2S_InspectionEnd(int iCamID,int iScan)
{
	if(iCamID < 0 || iCamID >= MAX_CAMERA_COUNT)
		return;
	if(iScan < 0 || iScan >= MAX_SCAN_COUNT)
		return;

	m_GlassData.SetScanEndCamera(iCamID,iScan);

	DimensionDir	eDimension = m_HardwareRecipe.GetCameraSettings(iCamID,iScan)->m_eDimension;

	g_pLog->DisplayMessage( _T("%s Inspection end Count! Scan %d, Cam %d StartCnt %d,End %d"),PANEL_SIDE[eDimension],iScan,iCamID,m_GlassData.GetScanStartCount(),m_GlassData.GetScanEndCameraCount());	
	
	if(m_GlassData.GetScanEndCameraCount() == m_GlassData.GetScanStartCount() && m_bPostProcess == FALSE)
	{
		m_bPostProcess = TRUE;

		g_pLog->DisplayMessage(_T("%s inspection end complete : Scan %d"),PANEL_SIDE[eDimension], iScan);
		g_pLog->DisplayMessage( _T("=========================================================="));	

		m_GlassData.SetScanStart(FALSE);
		for(int i=0;i<MAX_SCAN_COUNT;i++)
			m_GlassData.SetScanEnd(i,TRUE);

		for(int i=0;i<MAX_CAMERA_COUNT;i++)
			m_pInspect[i]->SetProcessEnd();

		AfxBeginThread(ScanEndProcess,this);
	}
	else if(m_GlassData.GetScanEndCameraCount() == m_GlassData.GetScanStartCount()/2)
	{
		g_pLog->DisplayMessage(_T("%s One Scan inspection end complete : Scan %d"),PANEL_SIDE[eDimension], iScan);
		g_pLog->DisplayMessage( _T("=========================================================="));

		m_GlassData.SetScanEnd(iScan,TRUE);
	}
}

UINT CInterfaceManager::ScanEndProcess(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);
	
	g_pLog->DisplayMessage(_T("========= Start Glass Inspection End Processing"));
	
	pInter->PostProcess();

	g_pLog->DisplayMessage(_T("========= End Glass Inspection End Processing"));
	g_pLog->DisplayMessage( _T("=========================================================="));

	return 0;
}

UINT CInterfaceManager::ScanTimeOut(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);

	pInter->ScanOverTimeSignal();

	return 0;
}

void CInterfaceManager::ScanOverTimeSignal()
{
	g_pLog->DisplayMessage(_T("Scan Over Time - Post Processing Start"));

	m_GlassData.SetScanStart(FALSE);
	for(int i=0;i<MAX_SCAN_COUNT;i++)
		m_GlassData.SetScanEnd(i,TRUE);

	for(int iCam=0;iCam<MAX_CAMERA_COUNT;iCam++)
	{		
		m_pGrabber[iCam]->GrabScanStop();
		m_pInspect[iCam]->SetProcessEnd();
	}

	m_pThread_SendMSG->ClearMSG();

	Sleep(500);

	PostProcess();
}

BOOL CInterfaceManager::PostProcess()
{
	g_pLog->DisplayMessage(_T("Start PostProcess()"));

	if(m_pThread_CheckSequence != NULL)
		m_pThread_CheckSequence->ClearMessage();

	if(m_GlassData.IsPostProcStart() == TRUE)
	{
		g_pLog->DisplayMessage(_T("Already Post Processing Start"));
		return TRUE;
	}

	m_GlassData.SetPostProc(TRUE);		

	CopyImageBuffer();
	
	m_PostProcess.SetPrameter(&m_GlassData,&m_HardwareRecipe,&m_GlassRecipe,g_pStatus->GetInspectOption(),g_pStatus->GetProfileOption(),&m_TransferData,&m_ResultData);
	m_PostProcess.RunPostProcessing();

	HISTORY_RESULT HisData;
	HistoryData(m_GlassData.GetJudgeDefectCount(), HisData);
	m_PostProcess.AddHistoryData(HisData);
	m_PostProcess.RunPostProcessing_SaveDefectInfo();
	
	WritePLCResult(HisData);

	if(m_pThread_SendMSG != NULL)
		m_pThread_SendMSG->AddSendMSG(SEND_MESSAGE_CONTROLSIGNAL,IToC_Ack_ShortScanEndSuccess,TRUE);			
	
	m_bGlassLoadingEnd = FALSE;
	m_bPLCGlassLoading = FALSE;

	m_GlassData.SetScanEndTime();

	m_TactStopWatch.End();
	
	g_pLog->DisplayMessage(_T("Inspection Time(GlassLoading -> End) : %.3f"),m_TactStopWatch.GetDurationMilliSecond());

	AfxBeginThread(CopyImageThreadFunc, this);	

	if(m_pView != NULL)
	{
		m_pView->AddHistory(HisData);
		m_pView->SetGlassData(&m_GlassData);
		m_pView->RefreshDefect(m_PostProcess.GetResultPath(EM_RESULT_DEFECT));
		
		if(m_pThread_ViewRefresh != NULL)
		{
			m_pThread_ViewRefresh->AddViewMSG(0,0,VIEW_REFRESH_INSPECT_END,0);
		}
	}		

	return TRUE;
}

void CInterfaceManager::CopyImageBuffer()
{
	DWORD dwTick = GetTickCount();
	CGLASS_INFO_PARM *pGlass = m_GlassRecipe.GetGlassInfo();

	pINSPECTSPLINE_BUFFER		pSplineBuffer;	
	CCameraSettings				*pCamera;	
	int							iCam,iScan,iPos;
	BOOL						bSplineImg[MAX_PANEL_SIDE];		
	BOOL						bSpline = m_GlassData.GetInsUseCheck(EM_INS_SPLINE);
	

	ZeroMemory(bSplineImg,sizeof(BOOL)*MAX_PANEL_SIDE);	

	g_pLog->DisplayMessage(_T("Start Copy Full Image Save"));

	DeleteAlignProfileData();

	for(iCam=0;iCam<MAX_CAMERA_COUNT;iCam++)
	{		
		for(iScan=0;iScan<MAX_SCAN_COUNT;iScan++)
		{
			pCamera = m_HardwareRecipe.GetCameraSettings(iCam,iScan);
			if(pCamera == NULL)
				continue;			
						
			std::multimap<int, CPoint *> *pCamMapAlign = m_pInspect[iCam]->GetProfileAlign(iScan);
			
			if((int)pCamMapAlign->size() > 0)
			{
				CSingleLock		csLock(&m_csProfile);
				csLock.Lock();
				m_mapAlignProfile[pCamera->m_eDimension].insert(pCamMapAlign->begin(),pCamMapAlign->end());
				csLock.Unlock();
			}

			for(iPos=0;iPos<MAX_PANEL_SIDE;iPos++)
			{
				pSplineBuffer = m_pInspect[iCam]->GetSplineBuffer(iPos);
				if(pSplineBuffer == NULL)
					continue;
				if(pSplineBuffer->iType < 0 || pSplineBuffer->iType > 1)
					continue;	

				if(pSplineBuffer->ePosition < INSPECTSPLINE_BUFFER::SPLINE_TOPLEFT || pSplineBuffer->ePosition > INSPECTSPLINE_BUFFER::SPLINE_BOTTOMRIGHT)
					continue;

				if(bSplineImg[pSplineBuffer->ePosition] == FALSE)
				{
					if(m_pView != NULL)
					{
						if(m_pView->SetSplineImg(pSplineBuffer->pOrg,pSplineBuffer->szOrg,pSplineBuffer->ePosition) == TRUE)
							bSplineImg[pSplineBuffer->ePosition] = TRUE;
					}
				}

				pSplineBuffer->Reset();				
			}	
		}
	}

	g_pLog->DisplayMessage(_T("Copy Image Save Complete : Time[%d]"),GetTickCount()-dwTick);

}

void CInterfaceManager::Send_ViewRefresh(CScheduleViewMessage *pMSG)
{	
	if(m_pView != NULL)
	{
		m_pView->ViewRefresh(pMSG->ProcMsg);
	}
}

UINT CInterfaceManager::CopyImageThreadFunc(LPVOID pParam)
{	
	CInterfaceManager *pMain = static_cast<CInterfaceManager*>(pParam);
	
	pMain->Save_FullImg();		

	return 0;
}

void CInterfaceManager::Save_FullImg()
{
	DWORD dwTick = GetTickCount();
	g_pLog->DisplayMessage(_T("Full Image Save Start"));

	int					iCam,iScan;
	CHardwareSettings	*pHard = &m_HardwareRecipe;
	CCameraSettings		*pCamera;	
	CGlassRecipe		*pGlsRcp = &m_GlassRecipe;
	CGLASS_INFO_PARM	*pGlassInfoPrm = &pGlsRcp->m_GlassParm;	
	CString				strFolder,strFileJpg,strPanelID;
	pINSPECTFULLIMAGE_BUFFER pBuffer;	

	strFolder.Format(_T("%s"),m_PostProcess.GetResultPath(EM_RESULT_FULL));			
	CreateDirectory(strFolder,NULL);

	strPanelID = g_pBase->m_strHPanelID;
	if(strPanelID.IsEmpty() == TRUE)
		strPanelID = _T("TestGlass");

	for(iCam=0;iCam<pHard->GetCameraCount();iCam++)
	{		
		for(iScan=0;iScan<MAX_SCAN_COUNT;iScan++)
		{
			pCamera = pHard->GetCameraSettings(iCam,iScan);
			if(pCamera == NULL)
				continue;			

			pBuffer = m_pInspect[iCam]->GetFullImgBuffer(iScan);
			if(pBuffer == NULL)
				continue;			

			if(pBuffer->pImage != NULL && pBuffer->szImage.cx > 100 && pBuffer->szImage.cy > 100)
			{
				
				strFileJpg.Format(_T("%s\\%s_%s_%s.jpg"),strFolder, strPanelID, PANEL_SIDE[pCamera->m_eDimension],g_pBase->m_strLoadingTime);

				SaveFullImage2(strFileJpg,pBuffer->pImage,pBuffer->szImage.cx,pBuffer->szImage.cy,(int)pCamera->m_eDimension,0,30);
			}		
		}
	}
	g_pLog->DisplayMessage(_T("Full Image Save Completed : Time[%d]"),GetTickCount()-dwTick);
}

void CInterfaceManager::CoordProfileJudge(HISTORY_RESULT& pHistory)
{
	PROFILECHAMFER_RESULT_DATA* pProfileResult1 = m_GlassData.GetProfileInspectData();
	pHistory.bResult = TRUE;
	CINSPECT_JUDGEMENT_PARM* pJudges = m_GlassRecipe.GetJudgePrm();
	NgInfo ngArray[3][NG_INF_TOTAL];
	BlVision_GetSoftVisionApp()->Execute(4, ngArray[0]);
	BlVision_GetSoftVisionApp()->Execute(5, ngArray[1]);
	BlVision_GetSoftVisionApp()->Execute(7, ngArray[2]);
	pHistory.nProAlarmResultCountB = 0;
	pHistory.nProAlarmResultCountA = 0;
	pHistory.nProAlarmResultCountD = 0;
	pHistory.nProAlarmResultCountC = 0;
	for (int i = 0; i < 3; i++)
	{
		/*A-BOT*/
		if (i == 0)
		{
			for (int c = 33; c < 47; c++)
			{
				if (pProfileResult1->ProfileData[c].bUseJudge == 1)
				{
					if (pHistory.nProfileDiff[c] > pJudges->nMinProfileNgCount_MinDiff[4])
					{
						pHistory.bResult = FALSE;
					}
					if (pHistory.nProfileDiff[c] < -1 * pProfileResult1->ProfileData[c].nJudgeMinus || pHistory.nProfileDiff[c] > pProfileResult1->ProfileData[c].nJudgePlus)
					{
						pHistory.nProAlarmResultCountA += 1;
					}

				}
			}
			for (int z = 0; z < 50; z++)
			{
				if (ngArray[i][z].ngType == 5 && ngArray[i][z].id < 6)
				{
					if (ngArray[i][z].maxValue<ngArray[i][z].result || ngArray[i][z].minValue>ngArray[i][z].result)
					{
						pHistory.nProAlarmResultCountA += 1;
						if (pHistory.nProAlarmResultCountA > pJudges->nMinProfileNgCount[4] || ngArray[i][z].result > pJudges->nMinProfileNgCount_MinDiff[4])
							pHistory.bResult = FALSE;
					}

				}
				if (ngArray[i][z].ngType == 5 && (5 < ngArray[i][z].id && ngArray[i][z].id < 11))
				{
					if (ngArray[i][z].maxValue<ngArray[i][z].result || ngArray[i][z].minValue>ngArray[i][z].result)
					{
						pHistory.nProAlarmResultCountA += 1;
						if (pHistory.nProAlarmResultCountA > pJudges->nMinProfileNgCount[4] || ngArray[i][z].result > pJudges->nMinProfileNgCount_MinDiff[4])
							pHistory.bResult = FALSE;
					}

				}
			}

		}
		/*B-BOT*/
		if (i == 1)
		{
			for (int c = 0; c < 10; c++)
			{
				if (pProfileResult1->ProfileData[c].bUseJudge == 1)
				{
					if (pHistory.nProfileDiff[c] > pJudges->nMinProfileNgCount_MinDiff[5])
					{
						pHistory.bResult = FALSE;
					}
					if (pHistory.nProfileDiff[c] < -1 * pProfileResult1->ProfileData[c].nJudgeMinus || pHistory.nProfileDiff[c] > pProfileResult1->ProfileData[c].nJudgePlus)
					{
						pHistory.nProAlarmResultCountB += 1;
					}

				}
			}
			for (int z = 0; z < 50; z++)
			{
				if (ngArray[i][z].ngType == 5 && ngArray[i][z].id < 6)
				{
					if (ngArray[i][z].maxValue<ngArray[i][z].result || ngArray[i][z].minValue>ngArray[i][z].result)
					{
						pHistory.nProAlarmResultCountB += 1;
						if (pHistory.nProAlarmResultCountB > pJudges->nMinProfileNgCount[5] || ngArray[i][z].result > pJudges->nMinProfileNgCount_MinDiff[5])
							pHistory.bResult = FALSE;
					}

				}

			}

		}
		/*D-BOT*/
		if (i == 2)
		{
			for (int c = 23; c < 33; c++)
			{
				if (pProfileResult1->ProfileData[c].bUseJudge == 1)
				{
					if (pHistory.nProfileDiff[c] > pJudges->nMinProfileNgCount_MinDiff[7])
					{
						pHistory.bResult = FALSE;
					}
					if (pHistory.nProfileDiff[c] < -1 * pProfileResult1->ProfileData[c].nJudgeMinus || pHistory.nProfileDiff[c] > pProfileResult1->ProfileData[c].nJudgePlus)
					{
						pHistory.nProAlarmResultCountD += 1;
					}

				}
			}
			for (int z = 0; z < 50; z++)
			{
				if (ngArray[i][z].ngType == 5 && ngArray[i][z].id < 6)
				{
					if (ngArray[i][z].maxValue<ngArray[i][z].result || ngArray[i][z].minValue>ngArray[i][z].result)
					{
						pHistory.nProAlarmResultCountD += 1;
						if (pHistory.nProAlarmResultCountD > pJudges->nMinProfileNgCount[7] || ngArray[i][z].result > pJudges->nMinProfileNgCount_MinDiff[7])
							pHistory.bResult = FALSE;
					}
				}

			}



		}
	}
	for (int i = 10; i < 23; i++)
	{
		if (pProfileResult1->ProfileData[i].bUseJudge == 1)
		{

			if (pHistory.nProfileDiff[i] < -1 * pProfileResult1->ProfileData[i].nJudgeMinus || pHistory.nProfileDiff[i] > pProfileResult1->ProfileData[i].nJudgePlus)
			{
				pHistory.nProAlarmResultCountC += 1;
				if (pHistory.nProAlarmResultCountD > pJudges->nMinProfileNgCount[6] || pHistory.nProfileDiff[i] > pJudges->nMinProfileNgCount_MinDiff[6])
					pHistory.bResult = FALSE;
			}
		}
	}
}

void CInterfaceManager::WritePLCResult(HISTORY_RESULT &pHistory)
{
	short *pResult = m_GlassData.GetGlassResultInfo();
	ZeroMemory(pResult,sizeof(short)*5);
	
	if (m_HardwareRecipe.GetCoordProfileUse() == 1)
	{
		CoordProfileJudge(pHistory);
		if (pHistory.nDefectCnt- (pHistory.nProAlarmResultCountD+ pHistory.nProAlarmResultCountB+ pHistory.nProAlarmResultCountA+ pHistory.nProAlarmResultCountC) >0 )
			pHistory.bResult = FALSE;
	}
	// 0 : OK, 1 : NG
	if(pHistory.bResult == TRUE)
	{
		pResult[0] = 0;
		g_pLog->DisplayMessage(_T("Inspection Result Glass %s - OK"),g_pBase->m_strHPanelID);
	}
	else
	{
		if (g_pLog->m_nHoleAlarmState ==TRUE)
		{
			pResult[10] = g_pLog->m_nHoleAlarmState;
			pResult[0] = 1;
			g_pLog->m_nHoleAlarmState = 0;
			g_pLog->DisplayMessage(_T("Inspection Result Glass %s - NG, Hole Alarm%d-NG"), g_pBase->m_strHPanelID, pResult[10]);
		}
		else
		{
			pResult[0] = 1;
			pResult[10] = 0;
			g_pLog->DisplayMessage(_T("Inspection Result Glass %s - NG"), g_pBase->m_strHPanelID);
		}
	}

	m_GlassData.GetStageTheta(0,pResult[1],pResult[2]);
	m_GlassData.GetStageTheta(1,pResult[3],pResult[4]);

	m_pControlInterface->SendCIMData(pResult,PLC_ADDR_GLASS_JUDEMENT,11);
	g_pLog->DisplayMessage(_T("write PLC Result Data : Resut %d,1_L_Theat %d,1_S_Theat %d,2_L_Theat %d,2_S_Theat %d,pResult[10]:%d"),pResult[0],pResult[1],pResult[2],pResult[3],pResult[4], pResult[10]);

	INS_PROFILE_RESULT_INFO *pProfileResult = m_GlassData.GetProfileResultInfo();

	for(int i=0;i<MAX_PROFILE_SETTING_COUNT;i++)
	{
		pProfileResult->nProfileData[i] = pHistory.nProfileDiff[i];
		pProfileResult->nChamferUp[i] = pHistory.nChamferThickUp[i];
		pProfileResult->nChamferDn[i] = pHistory.nChamferThickDn[i];
	}

	m_pControlInterface->SendCIMData((short*)pProfileResult,PLC_ADDR_PROFILE_JUDEMENT,MAX_PROFILE_SETTING_COUNT*3);

	g_pLog->DisplayMessage(_T("write PLC Profile Data : %d"),MAX_PROFILE_SETTING_COUNT*3);
}

void CInterfaceManager::HistoryData(int nDefectCnt,HISTORY_RESULT &pHistory)
{
	CResultData			*pResData = &m_ResultData;
	PROFILECHAMFER_RESULT_DATA *pProfileResult = m_GlassData.GetProfileInspectData();

	pHistory.Reset();

	int	i;
	pHistory.bResult = TRUE;

	for(i=0;i<MAX_PROFILE_SETTING_COUNT;i++)
	{
		pHistory.nProfileDiff[i] = pProfileResult->ProfileData[i].nProfileDiff;
		if(pProfileResult->ProfileData[i].bUseJudge == TRUE)
			pHistory.bProfileJudge[i] = pProfileResult->ProfileData[i].bProfileJudge;
		else
			pHistory.bProfileJudge[i] = TRUE;

		pHistory.nChamferThickUp[i] = abs(pProfileResult->ResultChamfer[i][0].nChamferCalThick);
		if(pProfileResult->ResultChamfer[i][0].bUseJudge == TRUE)
			pHistory.bChamferJudgeUp[i] = pProfileResult->ResultChamfer[i][0].bChamferJudge;
		else
			pHistory.bChamferJudgeUp[i] = TRUE;

		pHistory.nChamferThickDn[i] = abs(pProfileResult->ResultChamfer[i][1].nChamferCalThick);
		if(pProfileResult->ResultChamfer[i][1].bUseJudge == TRUE)
			pHistory.bChamferJudgeDn[i] = pProfileResult->ResultChamfer[i][1].bChamferJudge;
		else
			pHistory.bChamferJudgeDn[i] = TRUE;
	}

#if 1
	int	   nGridColumnCnt[] = { PROFILE_INSPECT_SIZE_A_C,PROFILE_INSPECT_SIZE_B_D,PROFILE_INSPECT_SIZE_A_C,PROFILE_INSPECT_SIZE_B_D,PROFILE_INSPECT_SIZE_A_C,PROFILE_INSPECT_SIZE_B_D,PROFILE_INSPECT_SIZE_B_D };
	UINT   eViewProfileIndex[] = { PROFILE_INSPECT_INDEX_A,PROFILE_INSPECT_INDEX_B,PROFILE_INSPECT_INDEX_C,PROFILE_INSPECT_INDEX_D,PROFILE_INSPECT_INDEX_CF,PROFILE_RCUT_INSPECT_INDEX_A,PROFILE_RCUT_INSPECT_INDEX_C };

	//CString str1,str2,str3;
	int	index, nProfileIndex;
	int	nRowIdx, iCol;
	int nProfileSum, nProfileCnt;
	int nChamferSumUp, nChamferCntUp;
	int nChamferSumDn, nChamferCntDn;
	BOOL isBool;

	for (i = 0; i < MAX_VIEWINFO_GRD_CNT; i++)
	{
		isBool = FALSE;
		nProfileSum = nProfileCnt = 0;
		nChamferSumUp = nChamferCntUp = 0;
		nChamferSumDn = nChamferCntDn = 0;

		for (index = 0; index < nGridColumnCnt[i]; index++)
		{
			iCol = index + 1;
			nProfileIndex = eViewProfileIndex[i] + index;

			if (i > MAX_VIEWINFO_GRD_CNT - 3 && index > 4 && !isBool)
			{
				isBool = TRUE;
				pHistory.nAVGProfileDiff[i] = nProfileCnt > 0 ? (nProfileSum / nProfileCnt) : 0;
				pHistory.nAVGChamferThickUp[i] = nChamferCntUp > 0 ? (nChamferSumUp / nChamferCntUp) : 0;
				pHistory.nAVGChamferThickDn[i] = nChamferCntDn > 0 ? (nChamferSumDn / nChamferCntDn) : 0;

				nProfileSum = nProfileCnt = 0;
				nChamferSumUp = nChamferCntUp = 0;
				nChamferSumDn = nChamferCntDn = 0;
			}

			if (pProfileResult->ProfileData[nProfileIndex].bProfileJudge)
			{
				nProfileSum += pProfileResult->ProfileData[nProfileIndex].nProfileDiff;
				nProfileCnt++;
			}

			if (pProfileResult->ResultChamfer[nProfileIndex][0].bChamferJudge)
			{
				nChamferSumUp += abs(pProfileResult->ResultChamfer[nProfileIndex][0].nChamferCalThick);
				nChamferCntUp++;
			}

			if (pProfileResult->ResultChamfer[nProfileIndex][1].bChamferJudge)
			{
				nChamferSumDn += abs(pProfileResult->ResultChamfer[nProfileIndex][1].nChamferCalThick);
				nChamferCntDn++;
			}
		}

		//str1.Format(_T("%.3f"), nProfileCnt > 0 ? (double)(nProfileSum / nProfileCnt / 1000.) : 0.000);
		//str2.Format(_T("%.3f"), nChamferCntUp > 0 ? (double)(nChamferSumUp / nChamferCntUp / 1000.) : 0.000);
		//str3.Format(_T("%.3f"), nChamferCntDn > 0 ? (double)(nChamferSumDn / nChamferCntDn / 1000.) : 0.000);
		//g_pLog->DisplayMessage(_T("HistoryData AVG%d: nProfileAVG=%s,nChamferUpAVG=%s,nChamferUpAVG=%s"), i, str1, str2, str3);

		if (i > MAX_VIEWINFO_GRD_CNT - 3 && index > 4)
		{
			pHistory.nAVGProfileDiff[i + 2] = nProfileCnt > 0 ? (nProfileSum / nProfileCnt) : 0;
			pHistory.nAVGChamferThickUp[i + 2] = nChamferCntUp > 0 ? (nChamferSumUp / nChamferCntUp) : 0;
			pHistory.nAVGChamferThickDn[i + 2] = nChamferCntDn > 0 ? (nChamferSumDn / nChamferCntDn) : 0;
		}
		else
		{
			pHistory.nAVGProfileDiff[i] = nProfileCnt > 0 ? (nProfileSum / nProfileCnt) : 0;
			pHistory.nAVGChamferThickUp[i] = nChamferCntUp > 0 ? (nChamferSumUp / nChamferCntUp) : 0;
			pHistory.nAVGChamferThickDn[i] = nChamferCntDn > 0 ? (nChamferSumDn / nChamferCntDn) : 0;
		}
	}
#endif // 1

	pHistory.strHostID = g_pBase->m_strHPanelID;
	pHistory.strGlassID = g_pBase->m_strHPanelID;
	pHistory.strEndTime = pResData->m_strScanEndTime;	
	pHistory.nDefectCnt = nDefectCnt;		

	if(nDefectCnt > 0)
		pHistory.bResult = FALSE;

	// Profile NG
	if(m_GlassData.m_bOnly_Profile_NG == TRUE)	// Profile NG CHECK..
	{
		g_pLog->DisplayMessage(_T("Only Profile Defect !!!!!!!!!!!!!!!"));
		BOOL bProfileCountNG = FALSE;
		for(int i=0; i<MAX_DIMENSION_COUNT; i++)
		{
			if(m_GlassData.m_nSide_Profile_NG_Count[i] == 0)
				continue;

			int nMinNGCount = m_GlassRecipe.GetJudgePrm()->nMinProfileNgCount[i];

			g_pLog->DisplayMessage(_T("[Side %d] Only Profile Defect Count [recipe:%d][%d] !!!!!!!!!!!!!!!"), i, nMinNGCount, m_GlassData.m_nSide_Profile_NG_Count[i]);

			if(nMinNGCount <= m_GlassData.m_nSide_Profile_NG_Count[i])
				bProfileCountNG = TRUE;

			int nMinDiff = m_GlassRecipe.GetJudgePrm()->nMinProfileNgCount_MinDiff[i];

			if(nMinDiff <= m_GlassData.m_nSide_Profile_NG_Max_Diff[i])
			{
				bProfileCountNG = TRUE;
				break;
			}
		}

		if(bProfileCountNG == FALSE)
			pHistory.bResult = TRUE;
	}

	pHistory.nCrackCount = pResData->m_nCrackCount;
	pHistory.nBrokenCount = pResData->m_nBrokenCount;
	pHistory.nChipCount = pResData->m_nChipCount;
	pHistory.nChamferCount = pResData->m_nChamferCount;
	pHistory.nBurrCount = pResData->m_nBurrCount;
	pHistory.nUnknownCount = pResData->m_nUnknownCount;
}

void CInterfaceManager::CheckSeqMSG_Received(CCheckSeqMessage *pCheckSeq)
{
	switch(pCheckSeq->emCheckSeq)
	{
	case CHECKSEQ_SHORT_SCANSTART_OVERTIME:
		g_pLog->DisplayMessage(_T("Check ScanStart TimeOut : start inspection! : %d,%d"),pCheckSeq->iScan,pCheckSeq->dwDuration);
		if(m_pThread_SendMSG != NULL)
			m_pThread_SendMSG->AddSendMSG(SEND_MESSAGE_CONTROLSIGNAL,IToC_Ack_ShortScanStartSuccess,TRUE);				
		break;
	case CHECKSEQ_SHORT_SCANSTART_COMPLETE:
		if(m_pThread_SendMSG != NULL)
			m_pThread_SendMSG->AddSendMSG(SEND_MESSAGE_CONTROLSIGNAL,IToC_Ack_ShortScanStartSuccess,TRUE);		
		g_pLog->DisplayMessage(_T("All PC - start inspection! : %d,%d"),pCheckSeq->iScan,pCheckSeq->dwDuration);
		break;
	case CHECKSEQ_LONG_SCANSTART_OVERTIME:
		g_pLog->DisplayMessage(_T("Check ScanStart TimeOut : start inspection! : %d,%d"),pCheckSeq->iScan,pCheckSeq->dwDuration);
		if(m_pThread_SendMSG != NULL)
			m_pThread_SendMSG->AddSendMSG(SEND_MESSAGE_CONTROLSIGNAL,IToC_Ack_LongScanStartSuccess,TRUE);				
		break;
	case CHECKSEQ_LONG_SCANSTART_COMPLETE:
		if(m_pThread_SendMSG != NULL)
			m_pThread_SendMSG->AddSendMSG(SEND_MESSAGE_CONTROLSIGNAL,IToC_Ack_LongScanStartSuccess,TRUE);		
		g_pLog->DisplayMessage(_T("All PC - start inspection! : %d,%d"),pCheckSeq->iScan,pCheckSeq->dwDuration);
		break;
	case CHECKSEQ_ONESCAN_OVERTIME:		
		//m_pThread_NetMSG->AddNetMSG(NET_MESSAGE_INSPECTOR,INSPECTOR_MESSAGE_SCANDISPLAY,pCheckSeq->iScan,0);
		g_pLog->DisplayMessage(_T("Scan End TimeOut! : %d,%d"),pCheckSeq->iScan,pCheckSeq->dwDuration);		
		break;
	case CHECKSEQ_ONESCAN_COMPLETE:
//		m_pThread_NetMSG->AddNetMSG(NET_MESSAGE_INSPECTOR,INSPECTOR_MESSAGE_SCANDISPLAY,pCheckSeq->iScan,0);
		g_pLog->DisplayMessage(_T("All PC - One scan Complete! : %d,%d"),pCheckSeq->iScan,pCheckSeq->dwDuration);
		//m_pView->UpdateSequence(SEQUENCE_SCANEND,(float)pCheckSeq->dwDuration);
		break;
	case CHECKSEQ_GLASS_INSPECTION_OVERTIME:
		g_pLog->DisplayMessage(_T("Glass Inspection TimeOut : Start PostProcess! : %d,%d"),pCheckSeq->iScan,pCheckSeq->dwDuration);
		AfxBeginThread(ScanTimeOut,this);
		//ScanOverTimeSignal();		
		break;
	case CHECKSEQ_GLASS_INSPECTION_COMPLETE:
		//m_pThread_NetMSG->AddNetMSG(NET_MESSAGE_INSPECTOR,INSPECTOR_MESSAGE_POSTPROCESSING,pCheckSeq->iScan,0);		
		g_pLog->DisplayMessage(_T("All PC - Inspection Complete! : Start PostProcess! : %d,%d"),pCheckSeq->iScan,pCheckSeq->dwDuration);
		break;
	}
}

void CInterfaceManager::IMI2P_PLC_ReceiveSignalValue(int nSignalIndex, int nValue)
{
	if(m_pLicense != NULL)
	{
		if(m_pLicense->Check() == FALSE)
		{
			m_pView->View_LicenseInfo();
			return;
		}
	}

	switch(nSignalIndex)
	{
	case C2I_Loading:
		g_pLog->DisplayMessage(_T("=================[GlassLoading Start]================="));
		GlassLoadingProcess();
		g_pLog->DisplayMessage(_T("=================[ GlassLoading End ]================="));
		break;
	case C2I_ShortScanStart:
		g_pLog->DisplayMessage(_T("=================[ Short Scan Start Start ]================="));
		ScanStartProcess(C2I_ShortScanStart);
		g_pLog->DisplayMessage(_T("=================[ Short Scan Start End  ]================="));
		break;
	case C2I_ShortScanEnd:
		g_pLog->DisplayMessage(_T("=================[ Short Scan End Start ]================="));
		PLCScanEndProcess(C2I_ShortScanEnd);
		g_pLog->DisplayMessage(_T("=================[ Short Scan End End  ]================="));
		break;
	case C2I_LongScanStart:
		g_pLog->DisplayMessage(_T("=================[ Long Scan Start Start ]================="));
		ScanStartProcess(C2I_LongScanStart);
		g_pLog->DisplayMessage(_T("=================[ Long Scan Start End ]================="));
		break;	
	case C2I_LongScanEnd:
		g_pLog->DisplayMessage(_T("=================[ Long Scan End Start ]================="));
		PLCScanEndProcess(C2I_LongScanEnd);
		g_pLog->DisplayMessage(_T("=================[ Long Scan End End ]================="));
		break;
	case C2I_EMOGrabStop:
		g_pLog->DisplayMessage(_T("=================[ EMO Grab Stop Start ]================="));
		EMOGrabStopProcess(C2I_EMOGrabStop);
		g_pLog->DisplayMessage(_T("=================[ EMO Grab Stop End  ]================="));
		break;
	}
}

void CInterfaceManager::InitLoadingProcess()
{
	g_pLog->DisplayMessage(_T("Start Init Loading Process"));
		
	AfxBeginThread(DeleteProfileProcess,this);

	g_pStatus->InitGlassLoading();

	m_GlassData.ResetGlass();
	m_bPostProcess = FALSE;

	if(m_pView != NULL)
	{
		m_pView->ResetViewAll();
		m_pView->SetRecipeSettings(&m_GlassRecipe);
		m_pView->SetGlassData(&m_GlassData);
		m_pView->SetTransferData(&m_TransferData);
	}
}

UINT CInterfaceManager::DeleteProfileProcess(LPVOID pParam)
{
	CInterfaceManager		*pInterface = (CInterfaceManager *)pParam;

	pInterface->DeleteAlignProfileData();

	return 0;
}

void CInterfaceManager::DeleteProfileData()
{
	std::multimap<int, CPoint*>::iterator	it;

	CPoint		*pPoint;
	for(int i=0;i<MAX_PANEL_SIDE;i++)
	{
		for(it=m_mapProfile[i].begin();it!=m_mapProfile[i].end();it++)
		{
			pPoint = it->second;
			if(pPoint == NULL)
				continue;
			delete pPoint;
			pPoint = NULL;
		}
		m_mapProfile[i].clear();		
	}

	DeleteAlignProfileData();
}

void CInterfaceManager::DeleteAlignProfileData()
{
	CSingleLock		csLock(&m_csProfile);
	csLock.Lock();

//	std::multimap<int, CPoint*>::iterator	it;
//	CPoint		*pPoint;
	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		/*
		for(it=m_mapAlignProfile[i].begin();it!=m_mapAlignProfile[i].end();it++)
		{
			pPoint = it->second;
			if(pPoint == NULL)
				continue;
			delete pPoint;
			pPoint = NULL;
		}
		*/
		
		m_mapAlignProfile[i].clear();
	}

	csLock.Unlock();
}

BOOL CInterfaceManager::EMOGrabStopProcess(ControlToInspect emSendSignal)
{

	return TRUE;
}

BOOL CInterfaceManager::PLCScanEndProcess(ControlToInspect emSendSignal)
{
	switch(emSendSignal)
	{
	case C2I_ShortScanEnd:
		{
			g_pLog->DisplayMessage(_T("Short Scan End Signal"));			
			m_bShortPLCEnd = TRUE;
		}
		break;
	case C2I_LongScanEnd:
		{
			g_pLog->DisplayMessage(_T("Long Scan End Signal"));

			if(m_pThread_SendMSG != NULL)
				m_pThread_SendMSG->AddSendMSG(SEND_MESSAGE_CONTROLSIGNAL,IToC_Ack_LongScanEndSuccess,TRUE);
			m_bLongPLCEnd = TRUE;
		}
		break;	
	}	

	return TRUE;
}

BOOL CInterfaceManager::ScanStartProcess(ControlToInspect emSendSignal)
{	
	if(m_bGlassLoadingEnd == FALSE)
	{
		g_pLog->DisplayMessage(_T("GlassLoading Not End : Skip Scan Start Signal"));
		return FALSE;
	}

	m_GlassData.SetScanStart(TRUE);
	m_nScanStartCount = 0;

	switch(emSendSignal)
	{
	case C2I_ShortScanStart:
		{
			g_pLog->DisplayMessage(_T("Short Scan Start Signal"));
			m_bShortPLCScanStart = TRUE;			

			g_pStatus->m_iScanIdx = 1;			

			AfxBeginThread(ScanStartCam_0,this);
			AfxBeginThread(ScanStartCam_1,this);
			AfxBeginThread(ScanStartCam_2,this);
			AfxBeginThread(ScanStartCam_3,this);		

			AfxBeginThread(CheckScanStart,this);
		}
		break;
	case C2I_LongScanStart:
		{
			g_pLog->DisplayMessage(_T("Long Scan Start Signal"));		

			m_GlassData.SetScanStartTime();	

			g_pStatus->m_iScanIdx = 0;

			AfxBeginThread(ScanStartCam_0,this);
			AfxBeginThread(ScanStartCam_1,this);
			AfxBeginThread(ScanStartCam_2,this);
			AfxBeginThread(ScanStartCam_3,this);			

			AfxBeginThread(CheckScanStart,this);

			m_GlassData.SetScanStartCount(MAX_DIMENSION_COUNT);
		}
		break;	
	}

	return TRUE;
}

UINT CInterfaceManager::CheckScanStart(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);

	double		CurTime = GetTickCount();
	
	do 
	{
		if (GetTickCount() - CurTime > 10000)
		{
			g_pLog->DisplayMessage(_T("Scan Start Ack TimeOut : Scan %d-%d"),g_pStatus->m_iScanIdx,pInter->m_nScanStartCount);
			break;
		}

		if(pInter->m_nScanStartCount == MAX_CAMERA_COUNT)
		{
			g_pLog->DisplayMessage(_T("Scan Start Ack Ok : Scan %d-%d"),g_pStatus->m_iScanIdx,pInter->m_nScanStartCount);
			break;
		}

		Sleep(0);
	} while (1);
	
	g_pLog->DisplayMessage(_T("Scan Start Ack Signal Send : Scan %d-%d"),g_pStatus->m_iScanIdx,pInter->m_nScanStartCount);
	if(g_pStatus->m_iScanIdx == 0)
	{			
		if(pInter->m_pThread_SendMSG != NULL)
			pInter->m_pThread_SendMSG->AddSendMSG(SEND_MESSAGE_CONTROLSIGNAL,IToC_Ack_LongScanStartSuccess,TRUE);
	}
	else
	{
		if(pInter->m_pThread_SendMSG != NULL)
			pInter->m_pThread_SendMSG->AddSendMSG(SEND_MESSAGE_CONTROLSIGNAL,IToC_Ack_ShortScanStartSuccess,TRUE);
	}

	pInter->SetGlassTimeOut();
	
	return 0;
}

void CInterfaceManager::SetGlassTimeOut()
{
	if(m_pThread_CheckSequence != NULL)		
	{
		double dOneScanTime = m_GlassRecipe.m_GlassParm.GetOneScanTime();

		m_pThread_CheckSequence->SetC2M(static_cast<ICheckSequenceInterface2Parent*>(this),&m_GlassData);
		m_pThread_CheckSequence->AddCheckSeqMSG(CHECKSEQ_GLASS_INSPECTION_OVERTIME,(int)(dOneScanTime* 1000.),m_HardwareRecipe.GetScanCount()-1);	
	}
}

void CInterfaceManager::ScanStartCamera(int iCam)
{
	BOOL bFreerun = m_HardwareRecipe.m_bUseFreerun;
	int nPeriod = m_HardwareRecipe.m_nFreerunPeriod;
	int nExposureTime = m_HardwareRecipe.m_nFreerunExposureTime;

	CCameraSettings *pCamSettings = m_HardwareRecipe.GetCameraSettings(iCam,g_pStatus->m_iScanIdx);

	g_pStatus->SetGrabFrametoScan(g_pStatus->m_iScanIdx,pCamSettings->m_nGrabFrameCount);
	if(m_pGrabber[iCam] != NULL)
	{
		m_pGrabber[iCam]->GrabScanStart(g_pStatus->m_iScanIdx,bFreerun,nPeriod,nExposureTime);
	}

	if(m_pInspect[iCam] != NULL)
	{
		if(m_pInspect[iCam]->ScanStart(g_pStatus->m_iScanIdx) == FALSE)
		{
			g_pLog->DisplayMessage(_T("Cam %d Scan %d Start Fail"),iCam,g_pStatus->m_iScanIdx);
		}
	}		

	CSingleLock		cLock(&m_csScanStart);
	cLock.Lock();
	m_nScanStartCount++;
	cLock.Unlock();	
}

UINT CInterfaceManager::ScanStartCam_0(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);

	pInter->ScanStartCamera(0);

	return 0;
}

UINT CInterfaceManager::ScanStartCam_1(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);

	pInter->ScanStartCamera(1);

	return 0;
}

UINT CInterfaceManager::ScanStartCam_2(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);

	pInter->ScanStartCamera(2);

	return 0;
}

UINT CInterfaceManager::ScanStartCam_3(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);

	pInter->ScanStartCamera(3);

	return 0;
}

BOOL CInterfaceManager::ScanStartGrabManual(int iCam,int iScan)
{
	if(m_pGrabber[iCam] != NULL)
	{
		m_pGrabber[iCam]->GrabScanStart(iScan,FALSE,0,0,FALSE);
	}

	return TRUE;
}

BOOL CInterfaceManager::ScanStartManual(int iCam,int iScan)
{	
	if(m_pInspect[iCam] != NULL)
	{
		if(m_pInspect[iCam]->ScanStart(iScan) == FALSE)
		{
			g_pLog->DisplayMessage(_T("Manual Cam %d Scan %d Start Fail"),iCam,iScan);
		}
	}		

	return TRUE;
}

BOOL CInterfaceManager::GlassLoadingProcess()
{
	g_pLog->DisplayMessage(_T("==============================================="));
	g_pLog->DisplayMessage(_T("Start Glass Loading Process"));		

	if(CheckExpireDay() == FALSE)
	{
		g_pLog->DisplayMessage(_T("*** Confirm Exit"));	
		//	ExitProcess(0);
		return TRUE;
	}


	m_bGlassLoadingEnd = FALSE;
	m_bPLCGlassLoading = TRUE;		

	InitLoadingProcess();
	
	m_GlassData.SetLoadingTime();	
	m_TactStopWatch.Start();

	g_pBase->m_strRecipeName = m_GlassRecipe.GetRecipeName();
	g_pBase->m_strLoadingDay = m_GlassData.GetLoadingDayFileName();
	g_pBase->m_strLoadingTime = m_GlassData.GetLoadingTimeFileName();
	g_pBase->m_strHPanelID.Format(_T("Manual_%s"),m_GlassData.GetLoadingTime());

	BOOL bGlassLoading;	

	bGlassLoading = Glass_Loading();	

	g_pLog->DisplayMessage(_T("Glass Loading Process Glass ID : %s"),g_pBase->m_strHPanelID);	
	
	if(bGlassLoading == FALSE)
	{
		g_pLog->DisplayMessage(_T("GlassLoading Fail %s : Inspection does not proceed."),g_pBase->m_strHPanelID);
		//AddAlarmList(IToC_Alarm_InspectorError);		

		//return FALSE;
	}

	// Trigger Control
	if(m_HardwareRecipe.GetTriggerBoardUse() == TRUE)
		SetTriggerControl();

		
	g_pStatus->LoadProfileOpt(m_GlassRecipe.GetRecipeName());
		
	m_pView->SetRecipeSettings(&m_GlassRecipe);	
	m_pView->SetGlassData(&m_GlassData);

	if(m_pThread_CheckSequence != NULL)
		m_pThread_CheckSequence->ClearMessage();		

	m_pView->UpdateTransferData();			
	m_bShortPLCEnd = FALSE;
	m_bLongPLCEnd = FALSE;
	m_bShortPLCScanStart = FALSE;	

	g_pLog->DisplayMessage(_T("Start Glass Loading Process 5"));

	if(m_pThread_SendMSG != NULL)
	{
		m_pThread_SendMSG->AddSendMSG(SEND_MESSAGE_CONTROLSIGNAL,IToC_Ack_LoadingSuccess,TRUE);	
	}

	m_GlassData.SetPostProc(FALSE);
	m_bGlassLoadingEnd = TRUE;

	return TRUE;
}

int CInterfaceManager::Glass_Loading()
{	
	g_pLog->DisplayMessage(_T("==================================================="));
	g_pLog->DisplayMessage(_T("Glass Loading Start!!!"));	
		
	if(ReadTransferData(TRANSITEM_FILEPATH_B5) == FALSE)
	{
		g_pLog->DisplayMessage(_T("Read Transfer File Fail"));
		//return FALSE;
	}
	g_pLog->DisplayMessage(_T("ReadTransferData Process"));
	
	if(AutoChangeRecipe() == FALSE)
	{
		g_pLog->DisplayMessage(_T("Recipe Change Fail"));		
	//	return FALSE;
	}
	
	g_pLog->DisplayMessage(_T("AutoChangeRecipe Process"));

	if(SendGlassRecipe() == FALSE)
	{
		g_pLog->DisplayMessage(_T("Send Recipe Fail"));		
		//return FALSE;
	}		

	return TRUE;
}

BOOL CInterfaceManager::SendGlassRecipe(BOOL bAll,int iCam)
{
	int			i;		

	if(bAll == TRUE)
	{
		for(i=0;i<MAX_CAMERA_COUNT;i++)
		{			
			if(m_pInspect[i] == NULL)
				continue;

			m_pInspect[i]->SetParameter(&m_GlassRecipe,&m_HardwareRecipe);
			g_pLog->DisplayMessage(_T("AutoChangeRecipe cam %d SetGlass"),i);
			m_pInspect[i]->SetGlassData(&m_GlassData);
			g_pLog->DisplayMessage(_T("AutoChangeRecipe cam %d setspline"),i);
			m_pInspect[i]->SetSplineModel(m_SplineModel);	
			g_pLog->DisplayMessage(_T("AutoChangeRecipe cam %d setcad"),i);
			m_pInspect[i]->SetCADData(m_mapProfile,m_ptOriginMapProfile);
			g_pLog->DisplayMessage(_T("AutoChangeRecipe cam %d setcad end"),i);
		}
	}
	else
	{
		m_pInspect[iCam]->SetParameter(&m_GlassRecipe,&m_HardwareRecipe);
		m_pInspect[iCam]->SetGlassData(&m_GlassData);
		m_pInspect[iCam]->SetSplineModel(m_SplineModel);
		m_pInspect[iCam]->SetCADData(m_mapProfile,m_ptOriginMapProfile);
	}

	g_pLog->DisplayMessage(_T("AutoChangeRecipe Process End"));

	return TRUE;	
}

CString	CInterfaceManager::GetRecipeName(int iRcpNo)
{
	if(iRcpNo < 0)
		return _T("*");

	CConfig cfg;
	if(cfg.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)LINK_FILE_NAME, FileMap_Mode) == FALSE)	
		return _T("*");

	int nUpperPPIDNumber;
	cfg.GetItemValue(_T("UPPER_NUMBER"), nUpperPPIDNumber, 0);

	if(nUpperPPIDNumber <= 0 || nUpperPPIDNumber >= 1000)
		return _T("*");

	int i;
	CString strValue = _T("");
	CString	strRecipe;

	strRecipe.Format(_T("%d"),iRcpNo);
	for(i = 0; i < nUpperPPIDNumber; i++)
	{
		cfg.GetItemValue(i, _T("UPPER_NAME"), strValue, _T("NoName"));
		strValue.MakeUpper();
		strValue.TrimLeft(_T(" "));
		strValue.TrimRight(_T(" "));

		if(strRecipe.CompareNoCase(strValue) == 0)
		{			
			cfg.GetItemValue(i, _T("INS_NAME"), strValue, _T("NoName"));
			strValue.MakeUpper();
			return strValue;
		}		
	}

	return _T("*");
}

BOOL CInterfaceManager::AutoChangeRecipe()
{
	CString		strRcp;

	strRcp = GetRecipeName(m_TransferData.m_nRecipeNo);	

	if(!m_strReserveRecipe.IsEmpty())
	{
		g_pLog->DisplayMessage(_T("Apply reserve Recipe Loading - [%s]"), m_strReserveRecipe);		
		if (LoadGlassRecipe(m_strReserveRecipe,TRUE))	// °°Àº Recipe¶óµµ Àû¿ë ¿¹¾àµÇ¾î ÀÖÀ¸¸é ´Ù½Ã ·ÎµùÇÑ´Ù.
		{					
			g_pLog->DisplayMessage(_T("Apply reserve Recipe Loading - [%s] : Success"), m_strReserveRecipe);
		}
		return TRUE;
	}	

	if(strRcp.CompareNoCase(_T("*")) == 0)
	{
		g_pLog->DisplayMessage(_T("Recipe Link Fail...!"));
		strRcp = "LinkFail";		
		return FALSE;
	}	

	if (strRcp.CompareNoCase(m_GlassRecipe.GetRecipeName()) != 0)	// strRecipeName ¹Ù²î¸é ·ÎµùÇÑ´Ù.
	{			
		if (LoadGlassRecipe(strRcp,TRUE) == FALSE)			
		{
			g_pLog->DisplayMessage(_T("Recipe[%s] Read Fail!"),strRcp);
			return FALSE;
		}		
	}	

	m_strReserveRecipe.Empty();	

	return TRUE;
}

BOOL CInterfaceManager::ReadTransferData(CString strTransItemFile)
{	
	if(m_pTransDataManager == NULL || m_pControlInterface == NULL)
		return FALSE;
	if(strTransItemFile.IsEmpty() == TRUE)
		return FALSE;

	char		lpTransBuffer[2048];
	int			nTransSize = 0;

	ZeroMemory(lpTransBuffer,sizeof(char)*2048);

	if(m_pTransDataManager->LoadTransItemFromFile(strTransItemFile) == FALSE)
	{
		g_pLog->DisplayMessage(_T("TransferData Read Fail! 1 :%s"),(TCHAR*)(LPCTSTR)strTransItemFile);
		return FALSE;
	}

	if(m_pControlInterface->ReadTransferData(m_pTransDataManager,lpTransBuffer,PLC_TRASFERDATA_ADDR) == FALSE)
	{
		g_pLog->DisplayMessage(_T("TransferData Read Fail! 2 :%s"),(TCHAR*)(LPCTSTR)strTransItemFile);
		return FALSE;
	}
	
	if(m_TransferData.SetManagerToData(m_pTransDataManager) == FALSE)
	{
		g_pLog->DisplayMessage(_T("TransferData Read Fail! 3 :%s"),(TCHAR*)(LPCTSTR)strTransItemFile);
		return FALSE;
	}

	return TRUE;
}

void CInterfaceManager::SetSlashText(EmSplashCmd emCommand, CString strLog, UINT nColor)
{
	CString strText = _T("        ");
	strText += strLog;

	switch(emCommand)
	{
	case emShow:			m_splash.ShowSplash();
		break;
	case emHide:			m_splash.CloseSplash();
		break;
	case emText:			m_splash.SetText(strText, nColor);
		break;
	default:
		break;
	}
}

BOOL CInterfaceManager::ReadHardwareSetting()
{
	m_HardwareRecipe.Reset();

	//return m_HardwareRecipe.ReadHardwareSettingsRegistry();
	return m_HardwareRecipe.ReadHardwareSettingsFile(HARDWARE_SETTING_PATH);
}

BOOL CInterfaceManager::InterfaceInit()
{
	BOOL		bIsInit = TRUE;	
	
	//////////////////////////////////////////////////////////////////////////
	// Trans Data Manager
	m_pTransDataManager = new CTransDataManager;
	
	//////////////////////////////////////////////////////////////////////////
	// Thread Init
	CreateThread();

	SetSlashText(GLOBAL_DEFINE::emText, _T("Create Thread Complete"), RGB(0,0,0));	

	m_pControlInterface = new CControl_Interface();
	m_pControlInterface->SetI2M(static_cast<IMainFrameInterface2Parent*>(this));
	if(m_pControlInterface != NULL)
	{		
		m_pControlInterface->ConnectToControl();
	}

	SetSlashText(GLOBAL_DEFINE::emText, _T("PLC Connection Complete"), RGB(0,0,0));	

	m_pLightManager = new CLightManager;
	m_pLightManager->InitLightControl();
	m_pLightManager->SetHardware(&m_HardwareRecipe);
	m_pLightManager->ConnectToLight();
	
	SetSlashText(GLOBAL_DEFINE::emText, _T("Light Control Complete"), RGB(0,0,0));	

	InitGrabber();

	SetSlashText(GLOBAL_DEFINE::emText, _T("Grabber Complete"), RGB(0,0,0));	

	InitInspect();

	SetSlashText(GLOBAL_DEFINE::emText, _T("Inspect Complete"), RGB(0,0,0));		
	
	LightTurnOnOff(TRUE);
	LightChangeValue();

	m_pTriggerBoardControl = new CTriggerControl_Mvsol;
	m_pLicense = new CLicenseChecker();

	g_pStatus->m_pLicenseChecker = m_pLicense;

	if(m_HardwareRecipe.GetTriggerBoardUse() == TRUE)
		m_pTriggerBoardControl->Connect(m_HardwareRecipe.GetTriggerBoardComport());

	if(m_pView->GetHardwareSettingView() != NULL)
		m_pView->GetHardwareSettingView()->SetTriggerBoard(m_pTriggerBoardControl);

	setLineCameraParamToSDK();

	return bIsInit;
}

void CInterfaceManager::setLineCameraParamToSDK(void) {
	/* code */
#if HALCON_VISION_KEY
	CString strRecipePath = RECIPE_PATH;
	CT2A ansiString(strRecipePath);
	BlVision_GetVisionRecipe()->setWorkDir(ansiString);

	for (int iCam = 0; iCam < MAX_CAMERA_COUNT; iCam++) {
		BlVision_GetVisionRecipe()->setGrabberControl(m_pGrabber[iCam], iCam);
	}

	int nCount = (int)(DIMENSION_NONE);
	int iCam = -1;
	int iScan = -1;
	for (int i = 0; i < nCount; i++) {
		DimensionDir eDir = (DimensionDir)(i);
		iCam = m_HardwareRecipe.GetCameraIndexToDimension(eDir);
		iScan = m_HardwareRecipe.GetScanToDimension(eDir);
		BlVision_GetVisionRecipe()->setCameraSetting(eDir, iCam, iScan);
	}

	BlVision_GetVisionRecipe()->setRecipeType(RCUT_VISION_RECIPE);
	BlVision_GetVisionRecipe()->init();

	for (int i = 0; i < nCount; i++) {        //ÉèÖ÷ֱæÂÊ
		DimensionDir eDir = (DimensionDir)(i);
		CBlSideData *pSide = BlVision_GetVisionRecipe()->getSideData(eDir);

		int iCam = m_HardwareRecipe.GetCameraIndexToDimension(eDir);
		int iScan = m_HardwareRecipe.GetScanToDimension(eDir);
		CCameraSettings* pCamSetting = m_HardwareRecipe.GetCameraSettings(iCam, iScan);

		pSide->m_dPixelSizeX = pCamSetting->m_dConvResolution[0];
		pSide->m_dPixelSizeY = pCamSetting->m_dScanResolution[1];
	}


	SetSlashText(GLOBAL_DEFINE::emText, _T("Vision Library Load"), RGB(0, 0, 0));
#endif
}

BOOL CInterfaceManager::InitInspect()
{
	int			iCam;		

	for(iCam=0;iCam<MAX_CAMERA_COUNT;iCam++)
	{
		m_pInspect[iCam] = new CInspectCamera(iCam);	
		m_pInspect[iCam]->InitInspect(MAX_THREAD,MAX_DEFECT_COUNT);
		m_pInspect[iCam]->SetParameter(&m_GlassRecipe,&m_HardwareRecipe);
		m_pInspect[iCam]->SetGrabber(m_pGrabber[iCam]);
		m_pInspect[iCam]->SetGlassData(&m_GlassData);
		m_pInspect[iCam]->SetI2S(static_cast<IInspect2Sequence*>(this));
		m_pInspect[iCam]->SetViewScanHWnd(m_pView->GetViewScanHWnd());

		m_PostProcess.SetInspectCamera(iCam,m_pInspect[iCam]);
	}

	return TRUE;
}

BOOL CInterfaceManager::InitGrabber()
{
	g_pLog->DisplayMessage( _T("CreateCamera Start!"));	

	//////////////////////////////////////////////////////////////////////////
	// Camera Handle »ý¼º.
	int			iCam;		
	BOOL		bRet = TRUE;

	for(iCam=0;iCam<MAX_CAMERA_COUNT;iCam++)
	{
		if(m_pGrabber[iCam] != NULL)
		{
			delete m_pGrabber[iCam];
		}

		switch(m_HardwareRecipe.m_nBoardType)
		{
		case GRAB_LINK_BOARD:
			m_pGrabber[iCam] = new CGrabberMulticam;	
			break;
		case RADIENT_BOARD:
			m_pGrabber[iCam] = new CGrabberRadient;	
			break;
		case SAP_BOARD:
			m_pGrabber[iCam] = new CSapLineGrab;	
			break;
		default:
			continue;
		}
		
		_GRABBER_INIT_PARAM_ Param;
		Param.hWnd = NULL;
		Param.bDemo = FALSE;
		// Param.nGrabBufSize = g_pBase->m_pBufferSize[iCam]; // miniled ÓÐÕâÐÐ
		Param.nGrabBufCount = g_pBase->m_pMemFrameNo[iCam];		
		Param.nFrameWidth = g_pBase->m_pFrameWidth[iCam];
		Param.nFrameHeight = g_pBase->m_pFrameHeight[iCam];
		Param.nConnectPort = g_pBase->m_pCameraPort[iCam];
		Param.nScanCount = g_pBase->m_nScanCount;
		// Param.nBoardIdx = g_pBase->m_nBoardID[iCam];      // miniled ÓÐÕâÐÐ
		// Param.nBoardCh = g_pBase->m_nBoardCh[iCam];       // miniled ÓÐÕâÐÐ
		Param.nImgFlipX = 0;		
		Param.nBoardCh = 0;
		Param.nCameraIdx = iCam;
		Param.nCameraScan = 0;

		CCameraSettings *pCamera = m_HardwareRecipe.GetCameraSettings(iCam,0);
		if(pCamera != NULL)
			Param.nImgFlipX = (int)pCamera->m_nImgFlipx;
		
		Param.nExposureDelay = m_HardwareRecipe.m_nFreerunPeriod;
		Param.nExposure = m_HardwareRecipe.m_nFreerunExposureTime;

#ifdef _UNICODE
		ZeroMemory(Param.cDCFPath, MAX_DFC_PATH);
		if(MAX_DFC_PATH < g_pBase->m_strCamCCA[iCam].GetLength())
		{
			delete m_pGrabber[iCam];
			m_pGrabber[iCam] = NULL;

			return FALSE;
		}
		int		nSize = WideCharToMultiByte(CP_ACP, 0, g_pBase->m_strCamCCA[iCam].GetBuffer(), -1, NULL, 0, NULL,NULL); 				
		WideCharToMultiByte(CP_ACP, 0, g_pBase->m_strCamCCA[iCam].GetBuffer(), -1, Param.cDCFPath, nSize, NULL, NULL); 		
#else				
		ZeroMemory(Param.cDCFPath, MAX_DFC_PATH);
		if(MAX_DFC_PATH < g_pBase->m_strCamCCA[iCam].GetLength())
		{
			delete m_pGrabber[iCam];
			m_pGrabber[iCam] = NULL;

			return FALSE;
		}
		CopyMemory(Param.cDCFPath, g_pBase->m_strCamCCA[iCam].GetBuffer(0), g_pBase->m_strCamCCA[iCam].GetLength());
		//Param.cDCFPath = (LPCTSTR)(TCHAR*)(g_pBase->m_strCamCCA);
#endif			

		g_pLog->DisplayMessage( _T("Cam File[%d]-%s"), iCam, (CString) Param.cDCFPath);	

		int nErrorCode;		
		int nBoardId = iCam;

		// B5 4È£±â ¼ÂÆÃ
		int		nLineID = _ttoi(m_HardwareRecipe.GetLineID());
		if(nLineID == 4)
		{
			switch(iCam)
			{
			case 0: nBoardId = 2; break;
			case 1: nBoardId = 0; break;
			case 2: nBoardId = 3; break;
			case 3: nBoardId = 1; break;
			}
		}
		else if(nLineID == 5)
		{
			switch(iCam)
			{			
			case 1: nBoardId = 3; break;
			case 3: nBoardId = 1; break;
			}
		}

		Param.nBoardIdx = nBoardId;

		g_pLog->DisplayMessage( _T("Cam File[%d]-Init"), iCam);	

		bRet |= m_pGrabber[iCam]->Initialize(&Param, &nErrorCode,nBoardId);

		g_pLog->DisplayMessage( _T("Cam File[%d]-Init End"), iCam);	

		bRet |= m_pGrabber[iCam]->InitializeBuffer(&Param);

		g_pLog->DisplayMessage( _T("Cam File[%d]-Buffer End"), iCam);	

		g_pStatus->SetFrameBuffer(iCam,m_pGrabber[iCam]->GetFrameBuffer());
	}		

	g_pLog->DisplayMessage( _T("CreateCamera Success!"));

	return bRet;
}

BOOL CInterfaceManager::DeinitGrabber()
{
	for(int i=0;i<MAX_CAMERA_COUNT;i++)
	{
		if (m_pGrabber[i])
		{
			m_pGrabber[i]->GrabScanStop();
			m_pGrabber[i]->Deinitialize();
			delete m_pGrabber[i];
			m_pGrabber[i] = NULL;
		}
	}
	return TRUE;
}

BOOL CInterfaceManager::LoadGlassRecipe(CString strRecipe,BOOL bReadProfile)
{
	if(strRecipe.IsEmpty())
		return FALSE;		
	
	m_GlassRecipe.Reset();

	if (!m_GlassRecipe.MakeRecipeFileName(strRecipe))	
		return FALSE;

	if (!m_GlassRecipe.ReadRecipeFile())
		return FALSE;	

	m_GlassData.SetGlassRecipe(&m_GlassRecipe);

	AfxBeginThread(ReadCADData_0,this);
	AfxBeginThread(ReadCADData_1,this);
	AfxBeginThread(ReadCADData_2,this);
	AfxBeginThread(ReadCADData_3,this);

	//AfxBeginThread(ReadSplineModel,this);	

	return TRUE;
}

UINT CInterfaceManager::ReadSplineModel(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);

	CString			strRecipe = pInter->m_GlassRecipe.GetRecipeName();
	pInter->ReadSplineModeldata(strRecipe);

	return 0;
}

void CInterfaceManager::ReadSplineModeldata(CString strRecipe)
{
	CString	strSide,strFile;

	for(int i=0;i<MAX_PANEL_SIDE;i++)
	{
		m_SplineModel[i].ClearModelData();

		switch(i)
		{
		case DIMENSION_A:		
			strSide = _T("A");
			break;
		case DIMENSION_B:		
			strSide = _T("B");
			break;
		case DIMENSION_C:		
			strSide = _T("C");
			break;
		case DIMENSION_D:		
			strSide = _T("D");
			break;
		}	

		strFile.Format(_T("C:\\RCutProject\\Spline\\%s_RCUT_%s.rcut"),strRecipe,strSide);
		if(m_SplineModel[i].ReadModelData(strFile,strRecipe) == TRUE)
		{
			g_pLog->DisplayMessage(_T("%s R-Cut Master Load Success"),strSide);
		}
		else
		{
			g_pLog->DisplayMessage(_T("%s  R-Cut Master Load Fail"),strSide);
		}
	}
}

UINT CInterfaceManager::ReadCADData_0(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);
	
	CString			strRecipe = pInter->m_GlassRecipe.GetRecipeName();
	pInter->ReadProfileCADdata(0,strRecipe);

	return 0;
}

UINT CInterfaceManager::ReadCADData_1(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);

	CString			strRecipe = pInter->m_GlassRecipe.GetRecipeName();
	pInter->ReadProfileCADdata(1,strRecipe);

	return 0;
}

UINT CInterfaceManager::ReadCADData_2(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);

	CString			strRecipe = pInter->m_GlassRecipe.GetRecipeName();
	pInter->ReadProfileCADdata(2,strRecipe);

	return 0;
}

UINT CInterfaceManager::ReadCADData_3(LPVOID pParam)
{
	CInterfaceManager	*pInter = static_cast<CInterfaceManager*>(pParam);

	CString			strRecipe = pInter->m_GlassRecipe.GetRecipeName();
	pInter->ReadProfileCADdata(3,strRecipe);

	return 0;
}

BOOL CInterfaceManager::ReadProfileCADdata(int iSide,CString strRecipe)
{
	g_pLog->DisplayMessage(_T("Read Profile CAD Data Start : %d"),iSide);	

	CProfileCADProc profileproc;
	CString		strFile,strDim;
	int			i = iSide;
	std::multimap<int, CPoint *>::iterator it;
	CPoint	*pPoint;
		
	switch((DimensionDir)i)
	{
	case DIMENSION_A:		
		strDim = _T("A");
		break;
	case DIMENSION_B:
		strDim = _T("B");
		break;
	case DIMENSION_C:
		strDim = _T("C");
		break;
	case DIMENSION_D:
		strDim = _T("D");
		break;	
	}

	for(it=m_mapProfile[i].begin();it!=m_mapProfile[i].end();it++)
	{
		pPoint = it->second;
		if(pPoint == NULL)
			continue;
		delete pPoint;
		pPoint = NULL;
	}
	m_mapProfile[i].clear();

	profileproc.SetProfileData(&m_mapProfile[i],NULL);		

	strFile.Format(_T("%s\\Profile\\%s_%s.prf"),PATH_INSPECTOR,strRecipe,strDim);

	if(profileproc.ReadProfileData(strFile) == FALSE)
	{
		g_pLog->DisplayMessage(_T("%s Profile CAD Load Fail:%s"),PANEL_SIDE[i],strFile);
	}
	else
	{
		g_pLog->DisplayMessage(_T("%s Profile CAD Load Success:%s"),PANEL_SIDE[i],strFile);
	}
	m_ptOriginMapProfile[i]=  profileproc.GetProfileOrigin();
	

	return TRUE;
}

void CInterfaceManager::LightTurnOnOff(BOOL bOn)
{
	if(m_pLightManager == NULL)
		return;	
	
	for(int iCam=0;iCam<m_HardwareRecipe.GetCameraCount();iCam++)
	{			
		CCameraSettings *pCamSetting = m_HardwareRecipe.GetCameraSettings(iCam,0);
		if(pCamSetting == NULL)
			continue;

		m_pLightManager->LampTurnOnOff(pCamSetting->m_nLightIdx_R,pCamSetting->m_nLightIdx_R_Ch,TRUE);
		Sleep(10);				
		m_pLightManager->LampTurnOnOff(pCamSetting->m_nLightIdx_T,pCamSetting->m_nLightIdx_T_Ch,TRUE);
		Sleep(10);
	}
}

void CInterfaceManager::LightChangeValue(int iCamera,int nValue)
{
	if(m_pLightManager == NULL)
		return;	
	
	if(iCamera == -1)
	{
		for(int iCam=0;iCam<m_HardwareRecipe.GetCameraCount();iCam++)
		{			
			CCameraSettings *pCamSetting = m_HardwareRecipe.GetCameraSettings(iCam,0);
			if(pCamSetting == NULL)
				continue;

			int		nLightVal = m_GlassRecipe.GetLightValue(pCamSetting->m_nLightIdx_R,pCamSetting->m_nLightIdx_R_Ch);
			m_pLightManager->SetLightControlValue(m_GlassRecipe.GetRecipeName(),pCamSetting->m_nLightIdx_R,pCamSetting->m_nLightIdx_R_Ch,LIGHT_TYPE_REF,TRUE,nLightVal);

			Sleep(10);
			nLightVal = m_GlassRecipe.GetLightValue(pCamSetting->m_nLightIdx_T,pCamSetting->m_nLightIdx_T_Ch);
			m_pLightManager->SetLightControlValue(m_GlassRecipe.GetRecipeName(),pCamSetting->m_nLightIdx_T,pCamSetting->m_nLightIdx_T_Ch,LIGHT_TYPE_TRANS,TRUE,nLightVal);
			Sleep(10);
		}
	}
	else
	{
		CCameraSettings *pCamSetting = m_HardwareRecipe.GetCameraSettings(iCamera,0);
		if(pCamSetting == NULL)
			return;
		
		m_pLightManager->SetLightControlValue(m_GlassRecipe.GetRecipeName(),pCamSetting->m_nLightIdx_R,pCamSetting->m_nLightIdx_R_Ch,LIGHT_TYPE_REF,TRUE,nValue);
	}
}

BOOL CInterfaceManager::WaitEndSignal(InspectToControlSignal emSendSignal)
{
	DWORD dwTick = GetTickCount();
	DWORD dwWaitTick;
	DWORD dwWaitTime = 5000;

	while(TRUE)
	{
		dwWaitTick = GetTickCount() - dwTick;
		if(dwWaitTime < dwWaitTick)
			break;

		switch(emSendSignal)
		{
		case IToC_Ack_ShortScanEndSuccess:
		case IToC_Ack_ShortScanEndFail:		
			if(m_bShortPLCEnd == TRUE)
			{
				g_pLog->DisplayMessage(_T("Ack Short PLC End : %d"),m_bShortPLCEnd);
				return TRUE;
			}
			break;
		case IToC_Ack_LongScanEndSuccess:	
		case IToC_Ack_LongScanEndFail:	
			if(m_bLongPLCEnd == TRUE)
			{
				g_pLog->DisplayMessage(_T("Ack Long PLC End : %d"),m_bShortPLCEnd);
				return TRUE;
			}
			break;
		default:
			return TRUE;
		}		

		Sleep(1);
	}

	return TRUE;
}

void CInterfaceManager::SetInspectionEnd()
{
	for(int i=0;i<MAX_CAMERA_COUNT;i++)
	{
		if(m_pInspect[i] != NULL)
		{
			m_pInspect[i]->SetProcessEnd();					
		}
	}

	Sleep(500);	
}

BOOL CInterfaceManager::IsScanNow()
{	
	BOOL bScanStart = m_GlassData.GetScanStart();
	BOOL bScanEnd = m_GlassData.GetScanEnd(m_HardwareRecipe.GetScanCount()-1);

	if (bScanStart && !bScanEnd)
		return TRUE;

	return FALSE;
}

void CInterfaceManager::CreateThread()
{
	m_pThread_SendMSG = new CThread_SendMSG();
	if(m_pThread_SendMSG != NULL)
	{
		m_pThread_SendMSG->SetIN2P(static_cast<IPLCSendInterface2Parent*>(this));
		m_pThread_SendMSG->CreateThread();
	}

	m_pThread_CheckSequence = new CThread_CheckSequence();
	if(m_pThread_CheckSequence != NULL)
	{
		m_pThread_CheckSequence->SetC2M(static_cast<ICheckSequenceInterface2Parent*>(this),&m_GlassData);
		m_pThread_CheckSequence->CreateThread();
	}

	m_pThread_ViewRefresh = new CThread_ViewRefresh();
	if(m_pThread_ViewRefresh != NULL)
	{
		m_pThread_ViewRefresh->SetIN2P(static_cast<IViewRefreshInterface2Parent*>(this));
		m_pThread_ViewRefresh->CreateThread();
	}

	/*
	m_pThread_NetMSG = new CThread_NetMSG();
	if(m_pThread_NetMSG != NULL)
	{
		m_pThread_NetMSG->SetIN2P(static_cast<IPLCReceiveInterface2Parent*>(this));
		m_pThread_NetMSG->CreateThread();
	}

	

	m_pThread_Light = new CThread_Light();
	if(m_pThread_Light != NULL)
	{
		m_pThread_Light->CreateThread();
	}	
	*/
}

LPBYTE CInterfaceManager::GetGrabBuffer(DimensionDir eDir,int iVline)
{
	int	iCam = m_HardwareRecipe.GetCameraIndexToDimension(eDir);
	int iScan = m_HardwareRecipe.GetScanToDimension(eDir);

	if(iCam < 0 || iCam >= MAX_CAMERA_COUNT)
		return NULL;
	if(iScan < 0 || iScan >= MAX_SCAN_COUNT)
		return NULL;	
	if(m_pGrabber[iCam] == NULL)
		return NULL;

	return m_pGrabber[iCam]->GetFrameHeaderLine(iScan,iVline);
}

BOOL CInterfaceManager::SaveFullImage(CString strPath,int iSide,CPoint ptStart,int nLineCnt)
{
	g_pStatus->CheckDirectory(strPath);

	FIBITMAP					*bitmap = NULL;	
	BYTE						*pBitBuffer;

	CString savePath = strPath;
	savePath += _T(".jpg");

	bitmap = FreeImage_Allocate(IMAGE_WIDTH, nLineCnt,8);

	pBitBuffer = FreeImage_GetBits(bitmap);
	if(pBitBuffer == NULL)
	{
		FreeImage_Unload(bitmap);		
		return FALSE;
	}			

	LPBYTE			lpImg = GetGrabBuffer((DimensionDir)iSide,ptStart.y);
	if(lpImg == NULL)
		return FALSE;

	CopyMemory(pBitBuffer,lpImg,IMAGE_WIDTH*nLineCnt);		

	USES_CONVERSION;
	char str_filename[1024];
	sprintf_s(str_filename, "%s", W2A(savePath));

	FreeImage_FlipVertical(bitmap);

	FreeImage_Save(FIF_JPEG, bitmap, str_filename,JPEG_FULLIMAGE_RATE);

	FreeImage_Unload(bitmap);		


	return TRUE;
}

BOOL CInterfaceManager::SaveFullImage2(CString strPath,LPBYTE lpOrigin,int nImgWidth,int nImgHeight,int iSide,int nStartY,int nQuality /*= 80*/)
{
	if(lpOrigin == NULL)
		return FALSE;

	if(nImgHeight < 100)
	{
		g_pLog->DisplayMessage(_T("Save Full Image Fail(%s, %s, %d), Height is 0"), strPath, PANEL_SIDE[iSide], nImgHeight);
		return FALSE;
	}

	//g_pLog->DisplayMessage(_T("Save Full Image (%s, %s, %d) 1"), strPath, PANEL_SIDE[iSide], nImgHeight);

	g_pStatus->CheckDirectory(strPath);

	//g_pLog->DisplayMessage(_T("Save Full Image (%s, %s, %d) 2"), strPath, PANEL_SIDE[iSide], nImgHeight);

	int p[3];
	p[0] = CV_IMWRITE_JPEG_QUALITY;
	p[1] = nQuality;
	p[2] = 0;

	double dCompressRatio = (double) m_HardwareRecipe.m_nFullImageCompressRatio;

	if(dCompressRatio < 70.0 || 90.0 < dCompressRatio)
		dCompressRatio = 70.0;

	double tmp = dCompressRatio/100.0;
	double dRatio = 1.-tmp;
	IplImage *Img  = cvCreateImageHeader(cvSize(nImgWidth,nImgHeight),8,1);
	IplImage *img2 = cvCreateImage(cvSize((int)(nImgWidth*dRatio),(int)(nImgHeight*dRatio)),8,1);

	//g_pLog->DisplayMessage(_T("Save Full Image (%s, %s, %d) 3"), strPath, PANEL_SIDE[iSide], nImgHeight);

	if(Img == NULL || img2 == NULL)
	{
		g_pLog->DisplayMessage(_T("Save Full Image Fail(%s, %s, %d), img pointer is null"), strPath, PANEL_SIDE[iSide], nStartY);
		return FALSE;
	}

	g_pLog->DisplayMessage(_T("Save Full Image Start(%s, %s, %d, %d, %d)"), strPath, PANEL_SIDE[iSide], nStartY, nImgHeight, nQuality);	

	if(nStartY < 0 || iSide < 0 || iSide >= MAX_DIMENSION_COUNT)
	{
		g_pLog->DisplayMessage(_T("Save Full Image Fail(%s, %s, %d)"), strPath, PANEL_SIDE[iSide], nStartY);
		return FALSE;
	}

	LPBYTE			lpImg =	lpOrigin+(nStartY*nImgWidth);
	if(lpImg == NULL)
	{
		g_pLog->DisplayMessage(_T("Save Full Image Fail(%s, %s, %d), Buffer is NULL"), strPath, PANEL_SIDE[iSide], nStartY);
		return FALSE;
	}

	//g_pLog->DisplayMessage(_T("Save Full Image (%s, %s, %d) 4"), strPath, PANEL_SIDE[iSide], nImgHeight);

	cvSetData(Img,lpImg,nImgWidth);

	cvResize(Img,img2);
	USES_CONVERSION;
	char str_filename[200];
	sprintf_s(str_filename, "%s", W2A(strPath));
	cvSaveImage(str_filename,img2, p);

	//g_pLog->DisplayMessage(_T("Save Full Image (%s, %s, %d) 5"), strPath, PANEL_SIDE[iSide], nImgHeight);

	cvReleaseImage(&img2);
	cvReleaseImageHeader(&Img);

	g_pLog->DisplayMessage(_T("Save Full Image Success(%s, %s, %d, %d, %d)"), strPath, PANEL_SIDE[iSide], nStartY, nImgHeight, nQuality);	

	return TRUE;
}

#define IMAGE_COMPRESSRATIO	50
int CInterfaceManager::LoadFullImage(CString strPath,int iSide,int nStartY, CGlass_Data *pGlassData,const bool bIsDebugImg)
{
	int nHeight = -1;
	if (strPath.IsEmpty() || iSide < 0 || iSide > MAX_DIMENSION_COUNT) {
		g_pLog->DisplayMessage(_T("Load Full Image Fail(%s, %d)"), strPath, iSide);
		return nHeight;
	}

#if 0
	USES_CONVERSION;
	char str_filename[200];
	sprintf_s(str_filename, "%s", W2A(strPath));

	LPBYTE lpImg = NULL;
	IplImage* Iplimg = cvLoadImage(str_filename, CV_LOAD_IMAGE_GRAYSCALE);
	g_pLog->DisplayMessage(_T("Image Size: %d x %d"), Iplimg->width, Iplimg->height);

	if (Iplimg) {
		if (bIsDebugImg == true) {
			UINT uiReadLine = 0;

			//lpImg = GetGrabBuffer((DimensionDir)iSide, nStartY);
			//if (lpImg != NULL) {
			//	memcpy(lpImg, &Iplimg->imageData[0], Iplimg->widthStep * Iplimg->height);
			//}

			for (int i = 0; i < Iplimg->height; i++) {
				lpImg = GetGrabBuffer((DimensionDir)iSide, nStartY + i);
				if (lpImg == NULL)
					break;
				memcpy(lpImg, &Iplimg->imageData[uiReadLine], Iplimg->widthStep);
				uiReadLine += Iplimg->widthStep;
			}

			if (pGlassData != NULL) {
				INS_EDGE_RESULT_INFO* pResInfo = pGlassData->GetEdgeResultInfo((DimensionDir)iSide);
				if (pResInfo != NULL)
				{
					pResInfo->nGlassStartLine = 0;
					pResInfo->nGlassEndLine = Iplimg->height + nStartY;
				}
			}

			nHeight = Iplimg->height;
			cvReleaseImage(&Iplimg);
		}
		else {
			//Full image
			const double dRatio = 1.0 - static_cast<double>(IMAGE_COMPRESSRATIO / 100.0);
			IplImage* resizeImage = cvCreateImage(cvSize((int)(Iplimg->width / dRatio), (int)(Iplimg->height / dRatio)), IPL_DEPTH_8U, 1);

			cvResize(Iplimg, resizeImage, CV_INTER_CUBIC);


			lpImg = GetGrabBuffer((DimensionDir)iSide, nStartY);
			if (lpImg != NULL) {
				memcpy(lpImg, &Iplimg->imageData[0], resizeImage->widthStep * resizeImage->height);
			}

			//UINT uiReadLine = 0;
			//for (int i = 0; i < resizeImage->height; i++) {
			//	lpImg = GetGrabBuffer((DimensionDir)iSide, nStartY + i);
			//	if (lpImg == NULL)
			//		break;
			//	memcpy(lpImg, &resizeImage->imageData[uiReadLine], resizeImage->widthStep);
			//	uiReadLine += resizeImage->widthStep;
			//}

			if (pGlassData != NULL) {
				INS_EDGE_RESULT_INFO* pResInfo = pGlassData->GetEdgeResultInfo((DimensionDir)iSide);
				if (pResInfo != NULL) {
					pResInfo->nGlassStartLine = 0;
					pResInfo->nGlassEndLine = Iplimg->height + nStartY;
				}
			}

			nHeight = resizeImage->height;
			cvReleaseImage(&Iplimg);
			cvReleaseImage(&resizeImage);
		}
		strPath.Append(_T("_OK"));
	}
	else {
		strPath.Append(_T("_NG"));
	}
#else
	// ¼ÓÔػҶÈͼÏñ
	std::string strFilename = CT2A(strPath);
	cv::Mat img = cv::imread(strFilename, cv::IMREAD_GRAYSCALE);

	if (!img.empty()) {
		g_pLog->DisplayMessage(_T("Image Size: %d x %d"), img.cols, img.rows);

		if (bIsDebugImg) {
			for (int i = 0; i < img.rows; ++i) {
				LPBYTE lpImg = GetGrabBuffer((DimensionDir)iSide, nStartY + i);
				if (lpImg == NULL) {
					break;
				}

				memcpy(lpImg, img.ptr(i), img.cols);
			}

			if (pGlassData != NULL) {
				INS_EDGE_RESULT_INFO* pResInfo = pGlassData->GetEdgeResultInfo((DimensionDir)iSide);
				if (pResInfo != NULL) {
					pResInfo->nGlassStartLine = 0;
					pResInfo->nGlassEndLine = img.rows + nStartY;
				}
			}

			nHeight = img.rows;
		}
		else {
			// °´±ÈÀýËõ·Å
			const double dRatio = 1.0 - static_cast<double>(IMAGE_COMPRESSRATIO) / 100.0;
			int newWidth = static_cast<int>(img.cols / dRatio);
			int newHeight = static_cast<int>(img.rows / dRatio);

			cv::Size newSize(newWidth, newHeight);
			cv::Mat resized;
			cv::resize(img, resized, newSize, 0, 0, cv::INTER_CUBIC);

			LPBYTE lpImg = GetGrabBuffer((DimensionDir)iSide, nStartY);
			if (lpImg != NULL) {
				memcpy(lpImg, resized.data, resized.cols * resized.rows);
			}

			if (pGlassData != NULL) {
				INS_EDGE_RESULT_INFO* pResInfo = pGlassData->GetEdgeResultInfo((DimensionDir)iSide);
				if (pResInfo != NULL) {
					pResInfo->nGlassStartLine = 0;
					pResInfo->nGlassEndLine = resized.rows + nStartY;
				}
			}

			nHeight = resized.rows;
		}

		strPath.Append(_T("_OK"));
	}
	else {
		strPath.Append(_T("_NG"));
	}
#endif // 0

	g_pLog->DisplayMessage(_T("%s"), (TCHAR*)(LPCTSTR)strPath);
	SetSlashText(GLOBAL_DEFINE::emText, strPath, RGB(0, 0, 0));

	return nHeight;
}

BOOL CInterfaceManager::SetLiveGrabCommand(DimensionDir eDir,BOOL bStop)
{
	int	iCam = m_HardwareRecipe.GetCameraIndexToDimension(eDir);

	g_pLog->DisplayMessage(_T("Live Grab Cam %d Start : Inter"),iCam);

	if(iCam < 0 || iCam >= MAX_CAMERA_COUNT)
		return FALSE;
	if(m_pGrabber[iCam] == NULL)
		return FALSE;

	BOOL	bRet = TRUE;

	if(bStop == TRUE)
		bRet = m_pGrabber[iCam]->GrabScanStop();
	else
	{
		bRet = m_pGrabber[iCam]->SetTriggerMode(FALSE);
		bRet = m_pGrabber[iCam]->GrabLiveStart();	
	}

	g_pLog->DisplayMessage(_T("Live Grab Cam %d End : Inter"),iCam);

	return bRet;
}

void CInterfaceManager::WriteLogManager(TCHAR *str)
{
	if(m_pLogManager != NULL)
	{
		m_pLogManager->WriteLog(0,(TCHAR*)(LPCTSTR)str);		
	}
}

BOOL CInterfaceManager::CheckExpireDay()
{
#if OFFLINE_KEY
	return TRUE;
#endif

	CFile	file;
	CString	strPath;
	STU_EXPIRE_DAY	stuExpire;
	
	strPath.Format(_T("C:\\Windows\\SystemConfirm.bin"));

	if(TRUE == file.Open(strPath,CFile::modeRead))
	{
		if(sizeof(STU_EXPIRE_DAY) == file.Read(&stuExpire, sizeof(STU_EXPIRE_DAY)))
		{
			if(stuExpire.m_nCode != 32783762)
			{
				file.Close();
				return FALSE;
			}		
		}

		file.Close();
	}
	else
		return FALSE;

	return TRUE;
}

void CInterfaceManager::SetTriggerControl()
{
	g_pLog->DisplayMessage(_T("Set Trigger Control : Stage %d"), g_pBase->m_nStageNo);

	if(m_pTriggerBoardControl == NULL)
		m_pTriggerBoardControl = new CTriggerControl_Mvsol;

	if(m_pTriggerBoardControl->IsConnect() == FALSE)
	{
		g_pLog->DisplayMessage(_T("Trigger Board Connect : Com Port = %d"), m_HardwareRecipe.GetTriggerBoardComport());
		m_pTriggerBoardControl->Connect(m_HardwareRecipe.GetTriggerBoardComport());
	}
		

	if(g_pBase->m_nStageNo == 0)
	{
		g_pLog->DisplayMessage(_T("Trigger Control Digital Input OFF !"));
		m_pTriggerBoardControl->SetSelectEncoder(0);
	}
	else
	{
		g_pLog->DisplayMessage(_T("Trigger Control Digital Input ON !"));
		m_pTriggerBoardControl->SetSelectEncoder(1);
	}
}