#include "StdAfx.h"
#include "SequenceProcessor_CSOT.h"

#include "CameraControlAlign.h"
#include "CameraController.h"
#include "CHReviewSetting/NetworkInfo.h"
#include "CHReviewResult/GlassResult.h"
#include "CameraControlAlign.h"
#include "CHSignalControls/SignalControl.h"
#include "CHMotorControls/MotorControl.h"
#include "CHAfmControls/AfmControl.h"
#include "CHPathScheduler/PathScheduler.h"
//#include "MeasureScheduler.h"
#include "CHMotorControls/MotorControl.h"
#include "CHReviewSetting/SystemInfo.h"
#include "CoordCalibrator.h"
#include "CHMotorControls/MotorControlInfo.h"
#include "ReviewProcessor.h"
#include "CHReviewRecipe/RsRecipeManager.h"
#include "CHReviewRecipe/RsRcpReviewInfo.h"
#include "CHReviewRecipe/RsRcpAlignInfo.h"
#include "CHReviewSetting/GlassTypeInfo.h"
#include "CHReviewSetting/Sys_AlignManager.h"
#include "CHReviewPrioritySorter/PrioritySorter.h"
#include "CHReviewRecipe/RsRcpMeasureInfo.h"
#include "DlgResultGraph.h"
#include "ChartGlassData.h"
#include "CHDefectPicker/DefectPicker.h"
#include "ReviewProcessor_CSOT.h"
#include "CameraControlReview.h"
#include "CHWsiControls/WsiControl.h"
#include "CHReviewRecipe/Rcp_RsReviewManager.h"
#include "ReviewInterface.h"
#include "DlgModuleInfo.h"
#include <algorithm>
#include "DitGlassRawStruct.h"
#include <iostream>
#include <fstream>
#include <afxwin.h>


#define GLASS_GD_FILE_PATH			_T("GD")
#define SIGNAL_SEND_RESULT_SUCCESS	_T("OK")
#define SIGNAL_SEND_RESULT_FAIL		_T("NG")
#define SIGNAL_ON_TIME_INFINITY		0

enum CSOT_MeasureMode { CSOT_ModeAuto = 0, CSOT_ModeManual };
// [2017:4:18]-[WEZASW] : WSI Module ÀåÂø ¼³ºñÀÇ °æ¿ì PlanType ¹øÈ£ º¯°æ.
enum CSOT_PlanType { CSOT_PlanReview = 0, CSOT_PlanUser, CSOT_PlanWSI, CSOT_PlanMeasure, CSOT_PlanReflow,CSOT_PlanWsiReflow,CSOT_PlanWsiUser};
enum CSOT_InsepectionType{REVIEW_REFLOW = 0, WSI_REFLOW, REV_WSI,WSIUSER, USER};

enum WSI_REFLOW_POINTINDEX { LEFTTOP=0, TOP, RIGHTTOP, LEFT, RIGHT, LEFTBOTTOM, BOTTOM, RIGHTBOTTOM, LEFTNOTCH, RIGHTNOTCH};
enum WSI_REFLOW_CELLSIDE_INDX { CELL_TOP=0, CELL_LEFT, CELL_RIGHT, CELL_LEFTTOP, CELL_RIGHTTOP, CELL_LEFTBOTTOM, CELL_RIGHTBOTTOM, CELL_BOTTOM, CELL_LEFTNOTCH, CELL_RIGHTNOTCH};


enum GlassDataType_CSOT	{
	GLASS_DATA_PROD_ID_CSOT = 0,
	GLASS_DATA_OPER_ID_CSOT,
	GLASS_DATA_LOT_ID_CSOT,
	GLASS_DATA_LOT_SEQUENCE_NUMBER_CSOT,
	GLASS_DATA_JOB_TYPE_CSOT,
	GLASS_DATA_JOB_ID_CSOT,
	GLASS_DATA_PPID_CSOT,
	GLASS_DATA_GLASS_SCAN_SCHEDULE_CSOT,
	GLASS_DATA_PPID_RECIPE_CSOT,
	GLASS_DATA_SLOT_SEQUENCE_NUMBER_CSOT,
	GLASS_DATA_PROPERTY_CODE_CSOT,
	GLASS_DATA_JOB_JUDGE_CODE_CSOT,
	GLASS_DATA_JOB_GRADE_CODE_CSOT,
	GLASS_DATA_SUBSTRATE_TYPE_CSOT,
	GLASS_DATA_PROCESSING_FLAG_CSOT,
	GLASS_DATA_INSPECTION_FLAG_CSOT,
	GLASS_DATA_SKIP_FLAG_CSOT,
	GLASS_DATA_JOB_SIZE_CSOT,
	GLASS_DATA_GLASS_THICKNESS_CSOT,
	GLASS_DATA_JOB_ANGLE_CSOT,
	GLASS_DATA_JOB_FLIP_CSOT,
	GLASS_DATA_CUTTING_GLASS_TYPE_CSOT,
	GLASS_DATA_PROCESSING_COUNT_CSOT,
	GLASS_DATA_INSPECTION_JUDGE_DATA_CSOT,
	GLASS_DATA_PAIR_JOB_ID_CSOT,
	GLASS_DATA_PAIR_FLAG_CSOT,
	GLASS_DATA_OPTION_VALUE_CSOT,
	GLASS_DATA_RESERVED_CSOT

};

enum DVDataType_CSOT	{	DV_DATA_ALIGN1_MACH_VALUE_CSOT = 0,
							DV_DATA_ALIGN2_MACH_VALUE_CSOT,
							DV_DATA_ALIGN1_GRAY_VALUE_CSOT,
							DV_DATA_ALIGN2_GRAY_VALUE_CSOT,
							DV_DATA_LIGHT_VALUE_CSOT,
							DV_DATA_LENS_MAGNIFY_CSOT,
							DV_DATA_REVIEW_DEFECT_DATA_CSOT,
							DV_DATA_WSI_DEFECT_DATA_CSOT };

BOOL CSequenceProcessor_CSOT::CompareFuction(CModuleStatus* i, CModuleStatus* j)
{
	if(i->GetMotorPosition()->dGlassPosX == j->GetMotorPosition()->dGlassPosX)
		return i->GetMotorPosition()->dGlassPosY < j->GetMotorPosition()->dGlassPosY;
	else
		return i->GetMotorPosition()->dGlassPosX < j->GetMotorPosition()->dGlassPosX;
}

BOOL CSequenceProcessor_CSOT::GantrySorting(CReviewResult i, CReviewResult j)
{
	return i.GetModuleIndex() < j.GetModuleIndex();
}

CSequenceProcessor_CSOT::CSequenceProcessor_CSOT(void) : CSequenceProcessor()
{
	m_bUseAFMHomePosition = TRUE;
	m_nGlassCount = 0;
	CDitGlassRawClient* pDitGlassRaw = CDitGlassRawClient::GetInstance();
	if(pDitGlassRaw->ConnectServer() == FALSE)
	{
		g_pLog->DisplayMessage(_T("°øÀ¯¸Þ¸ð¸® Á¢±Ù ½ÇÆÐ!(Shared memory Access Fail)"));
	}
}
    
CSequenceProcessor_CSOT::~CSequenceProcessor_CSOT(void)
{
	m_bUseAFMHomePosition = TRUE;
}

BOOL CSequenceProcessor_CSOT::SetProcessStatus(int nProcessStatus)
{
	EnterCriticalSection(&m_csProcessStatus);
	
	BOOL bReturn = FALSE;

	// ÇöÀç »óÅ°¡ ÀÌÀü »óÅÂ¿Í ´Ù¸¥°¡?
	if (nProcessStatus!=m_nProcessStatus || nProcessStatus==0)
	{
		if (nProcessStatus==0) // Ãʱâ(0) »óÅÂÀ̸é..
		{
			bReturn = TRUE;
		}
		else if (nProcessStatus==(m_nProcessStatus+1)) // ÀÌÀü »óÅ ´ÙÀ½(+1)À̸é..	
		{
			bReturn = TRUE;
		}

		if (bReturn) // ¼öÇàÀ̸é...
		{
			// Thread »ý¼º ÈÄ Thread ¼öÇà
			CSequenceProcessData* pThreadData = new CSequenceProcessData(this);
			if (pThreadData)
			{
				pThreadData->nProcessStatus = nProcessStatus;
				bReturn = CreateWorkThread(pThreadData);
				if(bReturn)
				{
					g_pLog->DisplayMessage(_T("[0] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
				}
				else
				{
					g_pLog->DisplayMessage(_T("[1] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
				}
			}
			else
			{
				g_pLog->DisplayMessage(_T("[2] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
			}
		}
		else if(nProcessStatus==2){
			// Thread »ý¼º ÈÄ Thread ¼öÇà
			CSequenceProcessData* pThreadData = new CSequenceProcessData(this);
			if (pThreadData)
			{
				pThreadData->nProcessStatus = nProcessStatus;
				bReturn = CreateWorkThread(pThreadData);
				if(bReturn)
				{
					g_pLog->DisplayMessage(_T("[0] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
				}
				else
				{
					g_pLog->DisplayMessage(_T("[1] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
				}
			}
			else
			{
				g_pLog->DisplayMessage(_T("[2] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
			}
		}
		else
		{
			g_pLog->DisplayMessage(_T("[3] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
		}
	}
	else
	{
		g_pLog->DisplayMessage(_T("[4] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
	}

	LeaveCriticalSection(&m_csProcessStatus);

	return bReturn;
}

void CSequenceProcessor_CSOT::RecvWSIResult(int nModuleIndex, const SWsiResult& measureResut)
{
	SReviewResult wisResult;
	
	if (m_pSP2P==NULL) goto RESULT_FAIL;
	CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if (pGlassResult==NULL) goto RESULT_FAIL;

	g_pLog->DisplayMessage(_T("[WSI_%d]MeasureResult index %d => code %d"), nModuleIndex, measureResut.nResultIndex, measureResut.nResultCode);

	DWORD dwCurTick = GetTickCount();

	CReviewResult* pWsiResult = pGlassResult->GetWsiResult(nModuleIndex);
	if (pWsiResult==NULL) goto RESULT_FAIL;

	// ¸¶Áö¸· À妽º¸¦ °¡Á®¿Â´Ù.
	int nCurResultIdx	= pWsiResult->GetLastSReviewResultIndex() + 1; // last index + 1
	int nStartResultIdx	= pWsiResult->GetStartSReviewResultIndex();
	int nEndResultIdx	= pWsiResult->GetEndSReviewResultIndex();

	// get grab position
	const SMotorPosition *pPosition = Module_GetMotorPosition(nModuleIndex);
	if (pPosition==NULL) goto RESULT_FAIL;
	int		nPosX	= int(pPosition->dGlassPosX * 1000.0);
	int		nPosY	= int(pPosition->dGlassPosY * 1000.0);
	int		nMPosX	= int(pPosition->dMotorPosX * 1000.0);
	int		nMPosY	= int(pPosition->dMotorPosY * 1000.0);
	double	dTime	= (double) m_ProcessTimer.GetDurationMilliSecond();

	// À妽º°¡ ´Ù¸£¸é ºñÁ¤»óÀÓ.
	if (measureResut.nResultIndex != nCurResultIdx) 
	{
		goto RESULT_FAIL;
	}

	// ÇöÀç µ¥ÀÌÅÍ ÀúÀå.
	// measureResut

	if(pWsiResult->GetSReviewResultCount() == 0) return ;

	SReviewResult* pSWsiResult = pWsiResult->GetSReviewResult(nCurResultIdx);

	wisResult.nUMOriginX = pSWsiResult->nUMOriginX;//nPosX;
	wisResult.nUMOriginY = pSWsiResult->nUMOriginY;//nPosY;

	wisResult.dTargetMotorX = pSWsiResult->dTargetMotorX;//pPosition->dMotorPosX;
	wisResult.dTargetMotorY = pSWsiResult->dTargetMotorY;//pPosition->dMotorPosY;

	wisResult.dDurationTime = dTime;
	wisResult.nWsi_ResultCode =  measureResut.nResultCode;
	wisResult.nWsi_Type = measureResut.nResultType;
	wisResult.nWsi_SlopeWarn = measureResut.nXSlopeWarn;

	memcpy(wisResult.pWsi_ResultData, measureResut.pResultData, sizeof(measureResut.pResultData));

	pGlassResult->SetWsiResultData(nModuleIndex, nCurResultIdx, wisResult, nPosX, nPosY, nMPosX, nMPosY, dTime);

	// set last result idx
	pWsiResult->SetLastSReviewResultIndex(nCurResultIdx);

	// ¸¶Áö¸· Æ÷ÀÎÆ®±îÁö ¿Ô°í, WSI °á°ú°¡ ³²¾Æ ÀÖÀ¸¸é...
	if(nCurResultIdx==nEndResultIdx && nCurResultIdx<=pWsiResult->GetSReviewResultCount())
	{
		nStartResultIdx = nCurResultIdx + 1;
		nEndResultIdx = nStartResultIdx + MAX_MOTOR_ADDRESS_SIZE - 1;
		nEndResultIdx = min(nEndResultIdx, (pWsiResult->GetSReviewResultCount()-1));

		g_pLog->DisplayMessage(_T("RemainWsi Started view[%d] start[%d] end[%d]"), nModuleIndex, nStartResultIdx, nEndResultIdx);
		pWsiResult->SetStartSReviewResultIndex(nStartResultIdx);
		pWsiResult->SetEndSReviewResultIndex(nEndResultIdx);

		// ³ª¸ÓÁö Æ÷ÀÎÆ® ¸®ºä ¼öÇàÇÏÀÚ.
		::Sleep(3000); // µô·¹ÀÌ´Â ÇʼöÀÓ. ¾øÀ¸¸é µ¿ÀÛ ¾ÈÇÔ.
//		Process_RemainWsiPoint(nModuleIndex);
	}

	// update view
	m_pSP2P->ISP2P_UpdateReviewResult(nModuleIndex, pGlassResult);
RESULT_FAIL:

	return;
}

void CSequenceProcessor_CSOT::RecvWSIUserResult(int nModuleIndex, const SWsiResult& measureResut)
{
	SReviewResult wisUserResult;

	if (m_pSP2P==NULL) goto RESULT_FAIL;
	CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if (pGlassResult==NULL) goto RESULT_FAIL;

	g_pLog->DisplayMessage(_T("[WSI_%d]MeasureResult index %d => code %d"), nModuleIndex, measureResut.nResultIndex, measureResut.nResultCode);

	DWORD dwCurTick = GetTickCount();

	CReviewResult* pWsiResult = pGlassResult->GetWsiUserResult(nModuleIndex);
	if (pWsiResult==NULL) goto RESULT_FAIL;

	// ¸¶Áö¸· À妽º¸¦ °¡Á®¿Â´Ù.
	int nCurResultIdx	= pWsiResult->GetLastSReviewResultIndex() + 1; // last index + 1
	int nStartResultIdx	= pWsiResult->GetStartSReviewResultIndex();
	int nEndResultIdx	= pWsiResult->GetEndSReviewResultIndex();

	// get grab position
	const SMotorPosition *pPosition = Module_GetMotorPosition(nModuleIndex);
	if (pPosition==NULL) goto RESULT_FAIL;
	int		nPosX	= int(pPosition->dGlassPosX * 1000.0);
	int		nPosY	= int(pPosition->dGlassPosY * 1000.0);
	int		nMPosX	= int(pPosition->dMotorPosX * 1000.0);
	int		nMPosY	= int(pPosition->dMotorPosY * 1000.0);
	double	dTime	= (double) m_ProcessTimer.GetDurationMilliSecond();

	// À妽º°¡ ´Ù¸£¸é ºñÁ¤»óÀÓ.
	if (measureResut.nResultIndex != nCurResultIdx) 
	{
		goto RESULT_FAIL;
	}

	// ÇöÀç µ¥ÀÌÅÍ ÀúÀå.
	// measureResut

	if(pWsiResult->GetSReviewResultCount() == 0) return ;

	SReviewResult* pSWsiResult = pWsiResult->GetSReviewResult(nCurResultIdx);

	wisUserResult.nUMOriginX = pSWsiResult->nUMOriginX;//nPosX;
	wisUserResult.nUMOriginY = pSWsiResult->nUMOriginY;//nPosY;

	wisUserResult.dTargetMotorX = pSWsiResult->dTargetMotorX;//pPosition->dMotorPosX;
	wisUserResult.dTargetMotorY = pSWsiResult->dTargetMotorY;//pPosition->dMotorPosY;

	wisUserResult.dDurationTime = dTime;
	wisUserResult.nWsi_ResultCode =  measureResut.nResultCode;
	wisUserResult.nWsi_Type = measureResut.nResultType;
	wisUserResult.nWsi_SlopeWarn = measureResut.nXSlopeWarn;

	memcpy(wisUserResult.pWsi_ResultData, measureResut.pResultData, sizeof(measureResut.pResultData));

	pGlassResult->SetUserWsiResultData(nModuleIndex, nCurResultIdx, wisUserResult, nPosX, nPosY, nMPosX, nMPosY, dTime);

	// set last result idx
	pWsiResult->SetLastSReviewResultIndex(nCurResultIdx);

	// ¸¶Áö¸· Æ÷ÀÎÆ®±îÁö ¿Ô°í, WSI °á°ú°¡ ³²¾Æ ÀÖÀ¸¸é...
	if(nCurResultIdx==nEndResultIdx && nCurResultIdx<=pWsiResult->GetSReviewResultCount())
	{
		nStartResultIdx = nCurResultIdx + 1;
		nEndResultIdx = nStartResultIdx + MAX_MOTOR_ADDRESS_SIZE - 1;
		nEndResultIdx = min(nEndResultIdx, (pWsiResult->GetSReviewResultCount()-1));

		g_pLog->DisplayMessage(_T("RemainWsi Started view[%d] start[%d] end[%d]"), nModuleIndex, nStartResultIdx, nEndResultIdx);
		pWsiResult->SetStartSReviewResultIndex(nStartResultIdx);
		pWsiResult->SetEndSReviewResultIndex(nEndResultIdx);

		// ³ª¸ÓÁö Æ÷ÀÎÆ® ¸®ºä ¼öÇàÇÏÀÚ.
		::Sleep(3000); // µô·¹ÀÌ´Â ÇʼöÀÓ. ¾øÀ¸¸é µ¿ÀÛ ¾ÈÇÔ.
		//		Process_RemainWsiPoint(nModuleIndex);
	}

	// update view
	m_pSP2P->ISP2P_UpdateReviewResult(nModuleIndex, pGlassResult);
RESULT_FAIL:

	return;
}



void CSequenceProcessor_CSOT::RecvAlignResult(const CAlignResult* pCurAlignResult)
{
 	if (m_pSP2P==NULL || pCurAlignResult==NULL) return;
 
 	CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
 	if (pGlassResult==NULL) 
 	{
 		g_pLog->DisplayMessage(_T("[AlignResult] Glass Result is NULL!"));
 		SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
 		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Fail Signal!"));
 		return;
	}

	SAlignResult sAlignResult;
 	CAlignResult *pAlignResult = &pGlassResult->m_AlignResult;
 	CAlignRecipe *pAlignRecipe = &pGlassResult->m_AlignRecipe; 
 
 	// ¾ó¶óÀÎ ÀÚµ¿Á¶¸í °á°ú ·¹½ÃÇÇ¿¡ ÀúÀåÇÏÀÚ. 
 	CRsRcpAlignInfo *pRsRcpAlignInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpAlignInfo();
 	if (pRsRcpAlignInfo!=NULL && pRsRcpAlignInfo->m_bAutoProcess)
 	{
 		if (pCurAlignResult->nAutoLightResult[0]==LightProcessComplete)
 		{
 			pRsRcpAlignInfo->m_dFirstCamExposure = pCurAlignResult->dExposureTime[0];
 		}
 
 		if (pCurAlignResult->nAutoLightResult[1]==LightProcessComplete)
 		{
 			pRsRcpAlignInfo->m_dSecondCamExposure = pCurAlignResult->dExposureTime[1];
 		}
 
 		// ·¹½ÃÇÇ µ¥ÀÌŸ ÀúÀå
 		//m_pDoc->Recipe_WriteRecipeFile();
 	}
 
 
 	BOOL bLastAlignResult = FALSE;
 	CCoordCalibrator *pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
 	// ÃÖÁ¾ ¾ó¶óÀÎ °á°ú..
 	if (pCoordCalibrator && pCurAlignResult->nResultCode==Align_Success)
 	{
 		g_pLog->DisplayMessage(_T("[AlignResult] Align Find Success!"));
 
 		// ¾ó¶óÀÎ °á°ú ±Û¶ó½º Á¤º¸¿¡ °»½Å
 		*pAlignResult = *pCurAlignResult;
 
 		pCoordCalibrator->SetFirstMarkPos(pAlignResult->dFindPositionX[0], pAlignResult->dFindPositionY[0], pAlignRecipe->dGlassPositionX[0], pAlignRecipe->dGlassPositionY[0]);
 		pCoordCalibrator->SetSecondMarkPos(pAlignResult->dFindPositionX[1], pAlignResult->dFindPositionY[1], pAlignRecipe->dGlassPositionX[1], pAlignRecipe->dGlassPositionY[1]);
 
 		// °¢µµ °è»ê
 		if(pCoordCalibrator->CalculateAlignResult() == TRUE)
 		{
 			sAlignResult = pCoordCalibrator->GetAlignResult();
 			g_pLog->DisplayMessage(_T("[AlignResult] Origin Pos: %.03lf, %.03lf, Degree: %.08lf"), sAlignResult.dOriginX, sAlignResult.dOriginY, sAlignResult.dDegree);
 
 			bLastAlignResult = !pAlignRecipe->bRotateProcess;
 		}
 
 		// ±Û¶ó½º °¢µµ º¸Á¤ À¯¹«
 		CCameraControlAlign *pAlignCameraControl	= m_pSP2P->ISP2P_GetAlignCameraControl();
 		SThetaMotorInfo* pThetaMotorInfo			= m_pSP2P->ISP2P_GetThetaMotorInfo();
 		CMotorControl* pMotorControl				= m_pSP2P->ISP2P_GetMotorControl();
 
 		if (pAlignRecipe->bRotateProcess && pAlignCameraControl && pMotorControl && pThetaMotorInfo)
 		{
 			if (fabs(sAlignResult.dDegree) <= pAlignRecipe->dGlassAngleMin) // ÇöÀç ±Û¶ó½º °¢µµ°¡ ÃÖ¼Ò°¢º¸´Ù ÀÛÀ¸¸é ¼º°ø
 			{
 				bLastAlignResult = TRUE;
 				g_pLog->DisplayMessage(_T("[AlignResult] Success! Last Glass Angle : %.8lf degree, Retry Count : %d ea"), 
 					sAlignResult.dDegree,  pCurAlignResult->nFindCount);
 			}
 			else if (fabs(sAlignResult.dDegree) > pAlignRecipe->dGlassAngleMax) // ÇöÀç ±Û¶ó½º °¢µµ°¡ ÃÖ´ë°¢º¸´Ù Å©¸é ½ÇÆÐ
 			{
 				bLastAlignResult = FALSE;
 				g_pLog->DisplayMessage(_T("[AlignResult] FAIL! Last Glass Angle : %.8lf degree, Retry Count : %d ea"), 
 					sAlignResult.dDegree,  pCurAlignResult->nFindCount);
 			}
 			else if (pCurAlignResult->nFindCount < pAlignRecipe->nRetryCount) // À纸Á¤ Ƚ¼ö°¡ ·¹½ÃÇÇ È½¼ö ÀÌÇÏÀ̸é À纸Á¤ ¼öÇà
 			{
 				g_pLog->DisplayMessage(_T("[AlignResult] Current Glass Angle : %.8lf degree, Retry Count : %d ea"), 
 					sAlignResult.dDegree,  pCurAlignResult->nFindCount);
 
 				// ¸ðÅÍ·Î °¢µµ º¸Á¤..
 				double dCalAngle = sAlignResult.dDegree;
 				dCalAngle = pThetaMotorInfo->dPosition - dCalAngle ;
 				g_pLog->DisplayMessage(_T("[AlignResult] Move Rotate Glass Angle : %.8lf degree"), dCalAngle);
 				pMotorControl->AxisThetaManualGoEnd(dCalAngle);
 				::Sleep(100);
 
 				// ¾ó¶óÀÎ ReProcess
 				if (pAlignCameraControl->AlignProcess())
 				{
 					g_pLog->DisplayMessage(_T("[AlignResult] Align Find Process ReStarted!"));
 					return;
 				}
 			}
 		}
 	}
 	else
 	{
 		g_pLog->DisplayMessage(_T("[AlignResult] Align Find FAIL!"));
 		*pAlignResult = *pCurAlignResult;
 	}	
 
 	g_pLog->DisplayMessage(_T("[AlignResult] Align Result: %d, Match Rate: %.3lf, %.3lf"), 
 		pAlignResult->nResultCode, pAlignResult->dFindScore[0], pAlignResult->dFindScore[1]);
 
 	g_pLog->DisplayMessage(_T("[AlignResult] 1st Align Pixel: %.3lf, %.3lf, 2nd Align Pixel: %.3lf, %.3lf"),
 		pAlignResult->dFindPixelX[0], pAlignResult->dFindPixelY[0], 
 		pAlignResult->dFindPixelX[1], pAlignResult->dFindPixelY[1]);
 
 	g_pLog->DisplayMessage(_T("[AlignResult] 1st Align Mot: %.3lf, %.3lf, 2nd Align Mot: %.3lf, %.3lf"), 
 		pAlignResult->dFindPositionX[0], pAlignResult->dFindPositionY[0], 
 		pAlignResult->dFindPositionX[1], pAlignResult->dFindPositionY[1]);
 
 	AlignNetwork_SendAlignResult(pGlassResult);
 
 
 	if(pCoordCalibrator)
 	{
 		sAlignResult = pCoordCalibrator->GetAlignResult();
 		//m_pView->SetAlignResult(pAlignResult->nResultCode, sAlignResult.dOriginX, sAlignResult.dOriginY, sAlignResult.dDegree);
 	}
 
	// PCControl ¾ó¶óÀÎ ½ÅÈ£ Àü¼Û.
	if (bLastAlignResult) // ÃÖÁ¾ ¾ó¶óÀΰá°ú...
	{	
		SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Success Data!"));
	}
	else
	{
		SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Fail Data!"));
	}

	SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_AlignComplete_CSOT);
	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Complete Signal!"));

	// LJY-20180905
	m_pSP2P->ISP2P_UpdateAlignResultStatus(0, pGlassResult);
}

BOOL CSequenceProcessor_CSOT::RecvSignalToSignalControl( int nSignalIndex, int nSignalValue, BOOL bSignalOn/*=TRUE*/ )
{
	BOOL bResult = FALSE;

	switch(nSignalIndex)
	{
	case PCControlRecvSignalIndex_State:
		bResult = ProcessSignal_State(nSignalValue, bSignalOn);
		break;

	case PCControlRecvSignalIndex_StateSub:
	//	bResult = ProcessSignal_StateSub(nSignalValue, bSignalOn);
		break;

	case PCControlRecvSignalIndex_Seq:
		bResult = ProcessSignal_Seq(nSignalValue, bSignalOn);
		break;

	case PCControlRecvSignalIndex_Ack:
		bResult = ProcessSignal_Ack(nSignalValue, bSignalOn);
		break;
	}

	return bResult;
}

void CSequenceProcessor_CSOT::CompletePlanIndex(int nReviewStatus, int nPlanIndex)
{
	CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if(pRsRcpReviewInfo == NULL) return;

	CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult == NULL) return;

	CRcpPlanInfo *BfpPlanInfo = pRsRcpReviewInfo->GetRcpPlanInfo(nPlanIndex);
	int nBeforePlanIndex = BfpPlanInfo->m_nReviewType;

	switch(nReviewStatus)
	{
	case ReviewProcessStatus_ReviewEnd:
		m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus Review End / PlanIndex : %02d"),nPlanIndex);
		break;

	case ReviewProcessStatus_MeasureEnd:
		m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus Measure End / PlanIndex : %02d"),nPlanIndex);
		break;

	case ReviewProcessStatus_UserEnd:
		m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus User End / PlanIndex : %02d"),nPlanIndex);
		break;

	case ReviewProcessStatus_WSIEnd:
		m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus WSI End / PlanIndex : %02d"),nPlanIndex);
		break;

	case ReviewProcessStatus_ReflowEnd:
		m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus Reflow End / PlanIndex : %02d"),nPlanIndex);
		break;

	case ReviewProcessStatus_WSIReflowEnd:
		m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus Wsi Reflow End / PlanIndex : %02d"),nPlanIndex);
		break;
	}

	// next plan
	nPlanIndex++;
	CRcpPlanInfo *pPlanInfo = pRsRcpReviewInfo->GetRcpPlanInfo(nPlanIndex);
	
	// last plan?
	if (pPlanInfo==NULL)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] LastPlan Complete"));
		SendResultToSignalControl(PCControlSendData_ReviewResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
		SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewComplete_CSOT);
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Success Signal!"));
		m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_None, nPlanIndex);

		//µ¥¸ð¿ë
		AFM_SetAFMTracking(FALSE);
		return;
	}

	//190727 ÃÖÇü¸ñ WSI ÁøÇà½Ã End üũ ÈÄ ÁøÇà
	if(nBeforePlanIndex==CSOT_PlanWSI||nBeforePlanIndex==CSOT_PlanWsiReflow||nBeforePlanIndex==CSOT_PlanWsiUser)
	{
		if(pPlanInfo->m_nReviewType ==CSOT_PlanWSI ||pPlanInfo->m_nReviewType ==CSOT_PlanWsiReflow||pPlanInfo->m_nReviewType==CSOT_PlanWsiUser)
		{
			DWORD dwTick = GetTickCount();
			if(GetCheckWSIEnd() == 0)
			{
				while(1)
				{
						if(GetCheckWSIEnd() == 1)
						{
							m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Wsi end Check Success!  WSI TYPE[%d]"),pPlanInfo->m_nReviewType);
							break;
						}
				
						else if(GetTickCount()-dwTick >=4000)
						{

							m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Wsi End Recv Fail! OverTime WSI TYPE[%d]"),pPlanInfo->m_nReviewType);
							m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Fail Signal!"));
							
							break;
						}
					}
				}
		}
	}

	//190727 ÃÖÇü¸ñ WSI type ÁøÇàÈÄ Review Ç÷£½Ã ÁøÇà½Ã Ä«¸Þ¶ó°¡ ±Û¶ó½º ¹Û¿¡ ÀÖÀ»°æ¿ì¸¦ À§ÇÑ... 
	if(nBeforePlanIndex==CSOT_PlanWSI ||nBeforePlanIndex==CSOT_PlanWsiReflow||nBeforePlanIndex==CSOT_PlanWsiUser)
	{
		if(  pPlanInfo->m_nReviewType == CSOT_PlanReview|| pPlanInfo->m_nReviewType ==CSOT_PlanUser|| pPlanInfo->m_nReviewType ==CSOT_PlanMeasure|| pPlanInfo->m_nReviewType ==CSOT_PlanReflow)
		{

			CTotalPitchMeasure* pTotapPithMeasure = m_pSP2P->ISP2P_GetTotalPitchMeasure(); // ºô·Á¾²±â! 20190730 ÃÖÇü¸ñ ³ªÁß¿¡ ÇÔ¼ö·Î µû·Î....
	
			const CMotorControlInfo* pSystemMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
			if(pSystemMotorInfo !=NULL) 
			{
			  
				if( SendReviewStartMotorPosition(0,pSystemMotorInfo->GetStartMotorXpos(),pSystemMotorInfo->GetStartMotorYpos(),0))
				{
					Sleep(2000);
					if(pTotapPithMeasure->GetMotorEnable())
					{
						m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send StartMotorPosition! BP:%d CP :%d"),nBeforePlanIndex,pPlanInfo->m_nReviewType);
						Sleep(3000);
					}

				}
				else
				{
					m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send StartMotorPosition Fail!!!! BP:%d CP :%d"),nBeforePlanIndex,pPlanInfo->m_nReviewType);
				}
			}
			else
			{
				 m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send StartMotorPosition pSystemMotorInfo is null"));
			}
			
		
			
		}
	}

	// execute next plan 
	DWORD nWaitTime = 0;
	int nTotalCount = 0;
	int temp = 0;
	BOOL bExcute = FALSE;
	int nPlanCount = pRsRcpReviewInfo->GetRcpPlanInfoCount();

	for (int nPlanIdx=nPlanIndex; nPlanIdx<nPlanCount; nPlanIdx++)
	{
		pPlanInfo = pRsRcpReviewInfo->GetRcpPlanInfo(nPlanIdx);
		if(pPlanInfo == NULL) continue;

		// plan motion
		switch(pPlanInfo->m_nReviewType)
		{
		case CSOT_PlanReview:
			if (( nTotalCount += pGlassResult->GetTotalSReviewResultCount()) > 0)
			{
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Review Plan Start!"));
				::Sleep(nWaitTime);
				bExcute = ReviewStartProcessing(pGlassResult, nPlanIdx);
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Review Plan End!"));
			}
			break;

		case CSOT_PlanUser:
			if (( nTotalCount += pGlassResult->GetTotalSUserResultCount()) > 0)
			{
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] User Plan Start!"));
				::Sleep(nWaitTime);
				bExcute = UserStartProcessing(pGlassResult, nPlanIdx);
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] User Plan End!"));
			}
			break;

		case CSOT_PlanWSI:
			if (( nTotalCount += pGlassResult->GetTotalSWsiResultCount()) > 0)
			{
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WSI Plan Start!"));
				::Sleep(nWaitTime);
				bExcute = WsiStartProcessing(pGlassResult, nPlanIdx);
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WSI Plan End!"));
			}
			break;
		//¹Ì»ç¿ë
		case CSOT_PlanMeasure:
			if (( nTotalCount += pGlassResult->GetTotalSMeasureResultCount()) > 0)
			{
				::Sleep(nWaitTime);
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Measure Plan Start!"));
				bExcute = MeasureStartProcessing(pGlassResult, nPlanIdx);
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Measure Plan End!"));
			}
			break;

		case CSOT_PlanReflow:
			if (( nTotalCount += pGlassResult->GetTotalSReflowResultCount()) > 0)
			{
				::Sleep(nWaitTime);
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Reflow Plan Start!"));
				bExcute = ReflowStartProcessing(pGlassResult, nPlanIdx);
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Reflow Plan End!"));
			}
			break;
		case CSOT_PlanWsiReflow:
			if (( nTotalCount += pGlassResult->GetTotalSWsiReflowResultCount()) > 0)
			{
				::Sleep(nWaitTime);
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WsiReflow Plan Start!"));
				bExcute = WsiReflowStartProcessing(pGlassResult, nPlanIdx);
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WsiReflow Plan End!"));
			}
			break;
		case CSOT_PlanWsiUser:
			if (( nTotalCount += pGlassResult->GetTotalSWsiUserResultCount()) > 0)
			{
				::Sleep(nWaitTime);
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WsiUser Plan Start!"));
				bExcute = WsiUserStartProcessing(pGlassResult, nPlanIdx);
				m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WsiUser Plan End!"));
			}
			break;
		}

		if (nTotalCount>0) break;
	}

	if (nTotalCount>0 && bExcute==FALSE)
	{
		SendResultToSignalControl(PCControlSendData_ReviewResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
		SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewComplete_CSOT);
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Fail Signal!"));
	}
	else if (nTotalCount==0)
	{
		SendResultToSignalControl(PCControlSendData_ReviewResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
		SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewComplete_CSOT);
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Success Signal!"));
	}
}

void CSequenceProcessor_CSOT::WorkThreadProcess(PVOID pParameter)
{
	if (m_pSP2P==NULL || pParameter==NULL) return;

	CSequenceProcessData* pProcessData = static_cast<CSequenceProcessData*>(pParameter);
	m_nProcessStatus = pProcessData->nProcessStatus;

	switch(pProcessData->nProcessStatus)
	{
	case ProcessLoading_CSOT:
		Process_Loading();
		break;

	case ProcessAlignStart_CSOT:
		Process_AlignStart();
		break;

	case ProcessReadRawFile_CSOT:
		Process_ReadRawFile();
		break;

	case ProcessReviewStart_CSOT:
		Process_ReviewStart();
		break;

	case ProcessReviewEnd_CSOT:
		Process_ReviewEnd();
		break;

	}
	return;
}

void CSequenceProcessor_CSOT::Process_Loading()
{
 	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::IN] Loading!"));	
	
	AllAckSignalOff();

	SetCheckWSIEnd(-1); //190726 wsiendüũ ÃʱâÈ­
	SetWsiType(-1);    //wsi reflow ŸÀÔ ±¸º° ÃʱâÈ­

	if (SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_LoadingAck_CSOT))
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::GlassLoading] Send Loading Ack Signal!"));

 	// read config file
 	if(!m_pSP2P->ISP2P_System_ReadConfigFile())
 		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor] System Value Loading FAIL!"));	
 	
	m_nWsiTotalCount = 0;

 	// make new glass result
 	int nGlassResultCount = 0;
 	CGlassResult*  pGlassResult = m_pSP2P->ISP2P_GetNewGlassResult(nGlassResultCount);
 	if (pGlassResult==NULL)
 	{
 		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Glass Result Create FAIL!"));
 		return;
 	}
 	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Glass Result Count : %d ea"), nGlassResultCount);
	
	pGlassResult->ResetDefocusCount();//·Îµù ºÎºÐ¿¡¼­ defocus count ÃʱâÈ­ 190821 ÃÖÇü¸ñ


 	CTime time = CTime::GetCurrentTime();
 	pGlassResult->m_strResultDate.Format(_T("%04d.%02d.%02d"), time.GetYear(), time.GetMonth(), time.GetDay());

	//if(Revolver_SetGoHome(0)) // ¸®º¼¹ö HOME ½ÃÄö½º 
	//{
	//	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Revolver Set GoHome Success!"));
	//}

 	// get transfer data
 	int nResultCode = 0;
 	STransferData* pTransferData = m_pSP2P->ISP2P_GetCurrentTransferData();
 	if (pTransferData==NULL)
 	{
 		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Transfer Data Read FAIL!"));
 		nResultCode = 1;
 	}
 
 	// read transfer data
 	if (pTransferData)
 	{
 		// read transfer data
 		if (ReadTransferDataFromSignalControl(pTransferData)==FALSE) 
 		{
 			m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Transfer Data Read FAIL!"));
 			nResultCode = 2;
 		}
 		else
 		{
 			m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Transfer Data Read Success!"));
 
 			UpdateGlassResultFromTransferData(pGlassResult, pTransferData);
 
 			CreateResultDirectory(pTransferData->strJobID, pGlassResult->m_strResultDate);
 
 			SetSaveImageBasePathToReviewProcessor(pTransferData->strJobID, pGlassResult->m_strResultDate);
 
 			SetSaveImageBasePathToAlignCameraControl(pTransferData->strJobID);
 

 			CString strRecipefile = _T("");
			if(ReadRecipeDataFromRecipeFile(pTransferData->strPPID_RC, strRecipefile) == 0)
 			{
 				m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Recipe File Read FAIL!"));
 				nResultCode = 3;
 			}
 			else
 			{
 				m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Recipe File Read Success![ %s ]"), strRecipefile, pTransferData->strPPID_RC);
 			}
 			
			m_pSP2P->ISP2P_DisplayMessage(_T("[Glass Loading] Current Apply Recipe Name : %s"), strRecipefile);
 
			// recipe data apply
			if(ApplyRecipeDataToGlassResult(pGlassResult)==FALSE)
 			{
				m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Apply Recipe Data To GlassResult FAIL!"));
				nResultCode = 4;
 			}
 			else
			{
			
				m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Align First File name %s"),pGlassResult->m_AlignRecipe.strFirstImageFile);
				m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Align Second File name %s"),pGlassResult->m_AlignRecipe.strSecondImageFile);
				m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Apply Recipe Data To GlassResult Success!"));
 			}		
 		}
 	}

	//// 190725 °í°´»ç ¿äû»çÇ× ÃÖÇü¸ñ ASCEND ½Ã alarm
	const CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();

	const CRcpSortingInfo *pSortingInfo = pRsRcpReviewInfo->GetRcpReviewSortInfo();
	if(pSortingInfo->m_nSortData== 1) // RCP_SORT_DATA_ORDER_ASCEND == 1 
	{
		SendSignalToSignalControl(PCControlSendSignalIndex_State,PCControlSend_RecipeASCEND,1000);//

		g_pLog->DisplayMessage(_T("[SequenceProcessor::GlassLoading] Recipe Is ASCEND!!"));
		//SendSignalOffToSignalControl(PCControlSendSignalIndex_State,PCControlSend_RecipeASCEND); //190723 recipe ASCEND bit off 
	}

	////
 	m_pSP2P->ISP2P_GlassPositionUpdate();
	
	//·¹½ÃÇÇ ¼¼ÆÃÀ¸·Î ¿È±è 190618
	if(GetUseAfmHomePosition())
	{
	g_pLog->DisplayMessage(_T("[AFM] AFM Home Position Start!!!"));

	if(!MoveAFMHomePosition())		g_pLog->DisplayMessage(_T("[AFM] AFM Home Position Fail"));

	}

	//°øÀ¯¸Þ¸ð¸® Ä¿¸àµå ¸®ºä ½ºÅ¸Æ®(±Û¶ó½º ·Îµù) 
	CDitGlassRawClient* pDitSharedGlassRaw = CDitGlassRawClient::GetInstance();
	if(pDitSharedGlassRaw->isConnect() == FALSE)				m_pSP2P->ISP2P_DisplayMessage(_T("[DitGlassRawClient] Shared Memory Connect Fail"));

	CRsRcpReviewInfo* pRecipeinfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if(pRecipeinfo == NULL)	return;
	int nWsiTypecount = 0;

	for(int nPlanIndex = 0; nPlanIndex < pRecipeinfo->GetRcpPlanInfoCount(); nPlanIndex++)
	{
		CRcpPlanInfo* pRcpPlanInfo = pRecipeinfo->GetRcpPlanInfo(nPlanIndex);
		if(pRcpPlanInfo == NULL)	continue;

		if(pRcpPlanInfo->m_nReviewType == CSOT_PlanWSI ||pRcpPlanInfo->m_nReviewType ==CSOT_PlanWsiUser||pRcpPlanInfo->m_nReviewType == CSOT_PlanWsiReflow)
		{
			if(nWsiTypecount>=1) //190725 Çѹø¸¸ Setwsi go go  
			{
				continue;
			}

			SetWsiType(pRcpPlanInfo->m_nReviewType);
			// Send Ready Signal to WIS
			if(!WSIAllReadySignal())
			{
				g_pLog->DisplayMessage(_T("[WSI] Send Ready Signal to All WIS Fail"));
			}
			nWsiTypecount += 1;
		}
	}
	
	CakAOISharedSystem* pAOIShared = CReviewInterface::GetInstance(); //20191017
	pProtocolData =pAOIShared->getReviewProtocol();

	pProtocolData->m_ModuleData[0].m_nPlanDefectCount=0;
	pProtocolData->m_ModuleData[0].m_nReviewedDefectCount=0;

	//pProtocolData->m_ModuleData[nModuleIdx].m_nPlanDefectCount += pScheduleResult->GetPathSchedulerResultCount();

	/*for (int i=0;i<pScheduleResult->GetPathSchedulerResultCount();i++)
	{
		pNode = pScheduleResult->GetPathSchedulerResult(i);
		pProtocolData->SetPlanReviewPos(nModuleIdx,nStIndex+i, 0, 0);
	}
*/
	
	//if(!ChangeUserReviewAxisCenterPosition(pGlassResult))		m_pSP2P->ISP2P_DisplayMessage(_T("[ChangeUserReviewPosition] Change Fail!!"));

	RemoveMotorCount();

 	// review camera stop
	ReviewCamera_CameraControl(CameraControlStop);	
	AlignCamera_CameraControl(CameraControlLive);

 	// send signal to plc
 	if (nResultCode==0)
 	{
 		SendResultToSignalControl(PCControlSendData_LoadingResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
 		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::GlassLoading] Send Loading Success Signal!"));
 	}
 	else
 	{
 		SendResultToSignalControl(PCControlSendData_LoadingResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
 		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::GlassLoading] Send Loading FAIL Signal!"));
 	}
 
 	// send cell data to review processorm_pDitGlass
 	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
 	if(pReviewProcessor == NULL) return ;	
 	pReviewProcessor->SetCellData(pGlassResult);
 	pReviewProcessor->SetReviewCount(0);			// ¸®ºä Sequence No ÃʱâÈ­.
 
 	// Process Status Update
 	if(pGlassResult)
 	{
 		g_pLog->DisplayMessage(_T("[SequenceProcess_CSOT] m_pGlassResult = %d"), pGlassResult);
		
 		m_pSP2P->ISP2P_UpdateProcessStatus(GetProcessStatus(), pGlassResult);
 		m_pSP2P->ISP2P_UpdateReviewResult(0, pGlassResult);
 
 		const SDefectFilter *pDefectFilter = m_pSP2P->ISP2P_GetDefectFilter();
 		m_pSP2P->ISP2P_UpdateDefectFilter(pDefectFilter);
 	}	
	
	SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_LoadingComplete_CSOT);
	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::GlassLoading] Send Loading Complete Signal!"));

 	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::OUT] Loading!"));

	//pDitSharedGlassRaw->SetReviewStart();

	if(pRecipeinfo->m_bDefocusUse){
	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::GlassLoading] Set Defocus Value : [%f]"),pRecipeinfo->m_dDefocusValue);
	}

}

void CSequenceProcessor_CSOT::Process_AlignStart()
{
 	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::IN] AlignStart!"));

	if (SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_AlignStartAck_CSOT))
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Start Ack!"));
	Sleep(400);//¾ó¶óÀÎ ÇÁ·¹ÀÓ ¹®Á¦ µô·¹ÀÌ ÁÖ±â chm190602

 	// 1. get current glass result
 	CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
 	if (pGlassResult==NULL) {	return;	}
 
	const CRsRcpAlignInfo* pRsRcpAlignInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpAlignInfo();
	if(pRsRcpAlignInfo == NULL)	return;

 	// 2. get align camera control	
 	CCameraControlAlign* pAlignCameraControl = m_pSP2P->ISP2P_GetAlignCameraControl();
 
 	// 3. align process
	if(pRsRcpAlignInfo->m_bAlignSkipMode)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Align Skip Mode !!!!!!!"));

		SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align SUCCESS Data!"));
		SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_AlignComplete_CSOT);
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Complete Signal!"));
	}
	else
	{
		// 190710 SJB Align Camera Disconnect Check, Align Step ÁøÇà Àü¿¡ È®ÀÎÇÑ´Ù.
		if(pAlignCameraControl)
		{
			if(pAlignCameraControl->AlignCameraDisconnectCheck() == FALSE)
			{
				SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
				m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Algin Camera Disconnect!!!!"));
			}
		}		

		if (pGlassResult && pAlignCameraControl && pAlignCameraControl->AlignProcess())
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Align Find Process Started!"));
		}
		else
		{
			// 4. send align fail signal to plc
			SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
			m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Fail Data!"));
			SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_AlignComplete_CSOT);
			m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Complete Signal!"));
		}
	}

	ReviewCamera_CameraControl(CameraControlStart);

	m_pSP2P->ISP2P_UpdateProcessStatus(GetProcessStatus(), pGlassResult);
	
 	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::OUT] AlignStart!"));
}

void CSequenceProcessor_CSOT::Process_ReadRawFile()
{
	CDitGlassRawClient *pDitRawClient = CDitGlassRawClient::GetInstance();
	
	pDitRawClient->SetReviewStart();

	Sleep(1000);

	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::IN] ReadRawFile!"));

	if (SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReadRawFileAck_CSOT))
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReadRawFile] Send Read Raw File Ack!"));

	// get current glass result
	CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if (pGlassResult==NULL) return;
	
	//°øÀ¯¸Þ¸ð¸® Ä¿¸àµå ¸®ºä ½ºÅ¸Æ®(±Û¶ó½º ·Îµù) 
	CDitGlassRawClient* pDitSharedGlassRaw = CDitGlassRawClient::GetInstance();
	if(pDitSharedGlassRaw->isConnect() == FALSE)				m_pSP2P->ISP2P_DisplayMessage(_T("[DitGlassRawClient] Shared Memory Connect Fail"));

	if(!UpdateMemoryUserReflowPlanInfo(pDitSharedGlassRaw))		m_pSP2P->ISP2P_DisplayMessage(_T("[User,ReflowPlan Shared Memory] Update Fail!!"));

	// read aoi result
	CProcessTimer processTimer;
	processTimer.Start();
	if(ReadAOIMemory(pGlassResult)) // 190201 SJB, Read AOI Memory
	{
		processTimer.End();
		m_pSP2P->ISP2P_DisplayMessage(_T("[ReadRawFile] AOI Result File Read Completed![%.3f ms]"), processTimer.GetDurationMilliSecond());

		pGlassResult->m_bReadRawFile = TRUE;
		CString strMessage = _T("");
		strMessage.Format(_T("[Read Raw File] Total: %d [Crack: %d, Mask: %d, Pad: %d, Common: %d, Align: %d, Active: %d]"),
			pGlassResult->GetDefectResultCount(), pGlassResult->GetCrackDefectResultCount(),
			pGlassResult->GetMaskDefectResultCount(), pGlassResult->GetPadDefectResultCount(), 
			pGlassResult->GetCommonDefectResultCount(), pGlassResult->GetAlignDefectResultCount(), 
			pGlassResult->GetActiveDefectResultCount());
		m_pSP2P->ISP2P_DisplayMessage(strMessage);

		// calculate motion plan
		int nTotalPlanCount = CalculatePlanData(pGlassResult);
		m_pSP2P->ISP2P_DisplayMessage(_T("[Read Raw File] Review All Plan Total Count : %d"), nTotalPlanCount);

		// send review ready
		SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewReady_CSOT);
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReadRawFile] Send Review Ready Signal!"));
	}
	else
	{
		processTimer.End();
		m_pSP2P->ISP2P_DisplayMessage(_T("[ReadRawFile] AOI Result File Read Fail![%.3f ms]"), processTimer.GetDurationMilliSecond());

		int nCurPlanIndex = 0;
		CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
		if(pRsRcpReviewInfo)
		{
			CRcpPlanInfo *pPlanInfo = pRsRcpReviewInfo->GetRcpPlanInfo(nCurPlanIndex);
			if (pPlanInfo)
			{
				if (pPlanInfo->m_nReviewType==CSOT_PlanUser)
				{
					// calculate motion plan
					int nTotalPlanCount = CalculatePlanData(pGlassResult);
					m_pSP2P->ISP2P_DisplayMessage(_T("[Read Raw File] Review All Plan Total Count : %d"), nTotalPlanCount);

					// send review ready
					SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewReady_CSOT);
					m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReadRawFile] Send Review Ready Signal!"));
				}
			}
		}
	}

	//// [2017:5:24]-[WEZASW] : Review Image Upload Dir »ý¼º.(FTPUploader¿¡¼­ ÀÚµ¿ »èÁ¦ µÇ´õ¶óµµ ½ÇÁ¦ ¸®ºä½Ã »ý¼º)
	//// '¹Ýº¹°Ë»ç'½Ã FTPUploader¿¡¼­ ¾÷·Îµå ÈÄ »èÁ¦ ½ÃÁ¡°ú PCControl Glass Unloading ÈÄ Áï½Ã Loading½Ã Review¿¡¼­ÀÇ ¾÷·Îµå °æ·Î(GlassID) »ý¼º ½ÃÁ¡ ¿À·ù
	const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
	CString strPath = _T("");
	//if(pNetworkInfo && pNetworkInfo->m_strUploadImagePath.IsEmpty() == FALSE)
	//{
	//	strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strUploadImagePath, *pGlassResult->GetJobID());// pGlassResult->GetGlassID() -> pGlassResult->GetJobID()
	//	CreateDirectory(strPath, NULL);
	//}

	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
	strPath = pReviewProcessor->GetUploadImagePath();
	CFileFind Uploadfile;
	CTime tmServerLoadingTime =  CDitGlassRawClient::GetInstance()->GetGlassData()->m_tmGlassLoading;
	strPath.Format(_T("%s\\%s_%04d%02d%02d%02d%02d%02d"), pNetworkInfo->m_strUploadImagePath,pGlassResult->m_strJobID,tmServerLoadingTime.GetYear(),tmServerLoadingTime.GetMonth(),tmServerLoadingTime.GetDay(),tmServerLoadingTime.GetHour(),tmServerLoadingTime.GetMinute(),tmServerLoadingTime.GetSecond());

	//¾÷·Îµå Æú´õ°¡ ¾øÀ¸¸é Æú´õ »ý¼ºÈÄ ´Ù½Ã ¾÷·Îµå °æ·Î Set 20190917ÃÖÇü¸ñ
	if(Uploadfile.FindFile(strPath)==FALSE)
	{
		CreateDirectory(strPath, NULL);
		pReviewProcessor->SetUploadImagePath(strPath);
	}

	if(pGlassResult)		m_pSP2P->ISP2P_UpdateProcessStatus(GetProcessStatus(), pGlassResult);
	
	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReadRawFile_OUT] ReadRawFile!"));
}

void CSequenceProcessor_CSOT::Process_ReviewStart()
{
	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::IN] ReviewStart!"));

	if (SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReviewStartAck_CSOT))
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Start Ack!"));

	const CRsRcpAlignInfo* pRsRcpAlignInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpAlignInfo();
	if(pRsRcpAlignInfo == NULL)	return;
	
	CTotalPitchMeasure* pTotapPithMeasure = m_pSP2P->ISP2P_GetTotalPitchMeasure();

	
	// 190708 SJB TotalPithchMeasure Start
	//if(pRsRcpAlignInfo->m_bTotalPitchMeasure && pTotapPithMeasure)
	//{
	//	ReviewCamera_CameraControl(CameraControlLive);
	//	Sleep(100);

	//	AFM_SetAFMTracking(TRUE);  

	//	pTotapPithMeasure->Reset();
	//	if(pTotapPithMeasure->StartTotalPitchMeasure())
	//	{
	//		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor] TotalPitchMeasure Result Success!"));

	//		CDitGlassRawClient *pDitRawClient = CDitGlassRawClient::GetInstance();
	//		if(pDitRawClient)
	//		{
	//			_grmCellData* pCellData = pDitRawClient->GetCellData(0);
	//			if(pCellData) 
	//			{
	//			//	pCellData->m_nTotalPitchData[0] = int(pTotapPithMeasure->GetTotalPitchBD() * 1000); // ÀåÃà, ÀÛ¾÷ÀÚ ±âÁØ À§ÂÊ
	//			//	pCellData->m_nTotalPitchData[1] = int(pTotapPithMeasure->GetTotalPitchAC() * 1000); // ÀåÃà, ÀÛ¾÷ÀÚ ±âÁØ ¾Æ·¡ÂÊ
	//			//	pCellData->m_nTotalPitchData[2] = int(pTotapPithMeasure->GetTotalPitchAB() * 1000); // ´ÜÃà, ÀÛ¾÷ÀÚ ±âÁØ ¿ÞÂÊ
	//			//	pCellData->m_nTotalPitchData[3] = int(pTotapPithMeasure->GetTotalPitchCD() * 1000); // ´ÜÃà, ÀÛ¾÷ÀÚ ±âÁØ ¿À¸¥ÂÊ
	//			}
	//		}
	//	}
	//	else
	//	{
	//		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor] TotalPitchMeasure Result Fail!"));

	//		// 190711 SJB, TotalPitchMeasure Fail½Ã¿¡ ¹Ù·Î Motor·Î ¸í·ÉÀ» ³¯¸®±â º¸´Ù´Â Motion Enable ½ÅÈ£¸¦ È®ÀÎÇÏÀÚ
	//		
	//		if(!pTotapPithMeasure->GetMotorEnable())
	//		{
	//			SendResultToSignalControl(PCControlSendData_ReviewResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
	//			m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor] MotionEnable Check Fail!!! Review Fail Signal"));
	//		}
	//	}

	//	ReviewCamera_CameraControl(CameraControlStop);
	//	Sleep(200);
	//}

	// review camera Start
	ReviewCamera_CameraControl(CameraControlStart);

	CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if (pGlassResult==NULL) return;

	if(FirstReviewPlanStart() <= 0)
	{
		SendResultToSignalControl(PCControlSendData_ReviewResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
		SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewComplete_CSOT);
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Success Signal!"));
	}

	// Process Status Update
	if(pGlassResult)
	{
		m_pSP2P->ISP2P_UpdateProcessStatus(GetProcessStatus(), pGlassResult);
	}

	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::OUT] ReviewStart!"));
}

void CSequenceProcessor_CSOT::Process_ReviewEnd()
{
	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::IN] ReviewEnd!"));

	CDitGlassRawClient* m_pDitGlassRaw = CDitGlassRawClient::GetInstance();

	if(m_pDitGlassRaw->isConnect()!=FALSE)	m_pDitGlassRaw->SetReviewEnd();
	
		SendDVDataToSignalControl();//

	if (SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReviewEndAck_CSOT))
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewEnd] Send Review End Ack!"));


	CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if (pGlassResult==NULL) return;

	// review camera stop
	ReviewCamera_CameraControl(CameraControlStop);

 	SetMotionStop();

	AFM_SetAFMTracking(FALSE);

	// °á°úÆÄÀÏ »ý¼ºÀº Review¿¡¼­ °ü¿© ¾ÈÇÔ
	if(m_pDitGlassRaw->isConnect()==FALSE)		WriteRawData(pGlassResult);
	
	//µðÆ÷Ä¿½º ¾Ë¶÷ send 20190819ÃÖÇü¸ñ
	if(pGlassResult->m_nDeFocusCount >0) 
	{
		SendSignalToSignalControl(PCControlSendSignalIndex_State,PCControlSend_Defoucs,1000);

		CTime time =CTime::GetCurrentTime();

		CString strTime = _T("");
		strTime.Format(_T("%04d-%02d-%02d %02d:%02d:%02d"), time.GetYear(), time.GetMonth(), time.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond());

		CDlgDefocusList::GetInstance()->SetDefocusTotalCount(pGlassResult->m_nDeFocusCount);//ÅäÅ» Ä«¿îÆ® Add 
		CDlgDefocusList::GetInstance()->SetDefocusData(strTime,pGlassResult->m_strGlassID,pGlassResult->m_nDeFocusCount);//ui Ãß°¡ÈÄ °»½Å

	}

	SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ResultDataComplete_CSOT);
	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewEnd] Send ResultData Complete Signal!"));

	//5. PCControl ½ÅÈ£ ¾÷µ¥ÀÌÆ®
	if(pGlassResult)
	{
		m_pSP2P->ISP2P_UpdateProcessStatus(GetProcessStatus(), pGlassResult);
		g_pLog->DisplayMessage(_T("PCControl Update Signal"));
	}

	m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::OUT] ReviewEnd!"));
}

BOOL CSequenceProcessor_CSOT::ReadTransferDataFromSignalControl(STransferData* pTransferData)//cmark
{
	if (pTransferData==NULL) return FALSE;
	pTransferData->Reset();

	CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
	if (pSignalControl==NULL) return FALSE;
	if (pSignalControl->IsConnected() == FALSE) return FALSE;

	const CSignalControlInfo* pSignalInfo = m_pSP2P->ISP2P_System_GetPCControlInfo();
	if (pSignalInfo==NULL)	return FALSE;

	int nPCControlReadDataCount = pSignalInfo->GetReadDataAddressCount();

	// [2017:1:9]-[WEZASW] : PCControl GlassData Ç׸ñ ÀçÁ¤ÀÇ.
	if(pSignalInfo->GetUseContinuousReadAddress())
	{
		CString strReadAddress = _T("");
		int nReadTotalSize = 0;
		for(int i=0; i<nPCControlReadDataCount; i++)
		{
			const SSignalSettingData *pInfo = pSignalInfo->GetReadDataAddress(i);
			if (pInfo==NULL) continue;

			if (i==0) strReadAddress = pInfo->strAddr;
			nReadTotalSize += pInfo->nSize;
		}

		CString strData = _T("");
		if (pSignalControl->ReadData(strReadAddress, nReadTotalSize, strData))
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[ReadTransferData] Addr: %s, Size: %d, Data: %s"), strReadAddress, nReadTotalSize, strData);
		}
		else
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[ReadTransferData] Read Fail! Addr: %s"), strReadAddress);
		}

		int nReadSize = 0;
		int nData = 0;
		CString strTemp = strData;
		for(int i=0; i<nPCControlReadDataCount; i++)
		{
			const SSignalSettingData *pInfo = pSignalInfo->GetReadDataAddress(i);
			if (pInfo==NULL) continue;

			nReadSize = pInfo->nSize;
			if(i == nPCControlReadDataCount - 1)
			{
				strData = strTemp;
			}
			else
			{
				strData = strTemp.Left(nReadSize*2);
				strTemp = strTemp.Mid(nReadSize*2);
			}

			switch(i)
			{
			case GLASS_DATA_PROD_ID_CSOT:
				pTransferData->strLotID = strData.TrimRight(_T(" "));
				break;

			case GLASS_DATA_OPER_ID_CSOT:
				pTransferData->strOperID = strData.TrimRight(_T(" "));
				break;

			case GLASS_DATA_LOT_ID_CSOT:
				pTransferData->strLotID = strData.TrimRight(_T(" "));
				break;

			case GLASS_DATA_PPID_CSOT:
				strData.TrimRight(_T(" "));
				if (strData.Compare(_T("")) != 0)
				{
					nData = strData.GetAt(1);
					nData <<= 8;
					nData |= strData.GetAt(0);
					pTransferData->strPPID.Format(_T("%d"), nData);
				}
				else
					pTransferData->strPPID = strData.TrimRight(_T(" "));
				break;

			case GLASS_DATA_PPID_RECIPE_CSOT:
				pTransferData->strPPID_RC = strData.TrimRight(_T(""));;
				//strData.TrimRight(_T(" "));
				break;

			case GLASS_DATA_JOB_TYPE_CSOT:
				pTransferData->strJobType = strData.TrimRight(_T(" "));
				break;

			case GLASS_DATA_JOB_ID_CSOT:
				pTransferData->strJobID = strData.TrimRight(_T(" "));
				break;

			case GLASS_DATA_LOT_SEQUENCE_NUMBER_CSOT:
				break;
			case GLASS_DATA_SLOT_SEQUENCE_NUMBER_CSOT:
				break;
			case GLASS_DATA_PROPERTY_CODE_CSOT:
				break;
			case GLASS_DATA_JOB_JUDGE_CODE_CSOT:
				break;
			case GLASS_DATA_JOB_GRADE_CODE_CSOT:
				break;
			case GLASS_DATA_SUBSTRATE_TYPE_CSOT:
				break;

			case GLASS_DATA_PROCESSING_FLAG_CSOT:
				break;
			case GLASS_DATA_INSPECTION_FLAG_CSOT:
				break;
			case GLASS_DATA_SKIP_FLAG_CSOT:
				break;
			case GLASS_DATA_JOB_SIZE_CSOT:
				break;
			case GLASS_DATA_GLASS_THICKNESS_CSOT:
				break;
			case GLASS_DATA_JOB_ANGLE_CSOT:
				break;
			case GLASS_DATA_JOB_FLIP_CSOT:
				break;
			case GLASS_DATA_CUTTING_GLASS_TYPE_CSOT:
				break;
			case GLASS_DATA_PROCESSING_COUNT_CSOT:
				break;
			case GLASS_DATA_INSPECTION_JUDGE_DATA_CSOT:
				break;
			case GLASS_DATA_PAIR_JOB_ID_CSOT:
				break;
			case GLASS_DATA_PAIR_FLAG_CSOT:
				break;
			case GLASS_DATA_OPTION_VALUE_CSOT:
				break;
			case GLASS_DATA_RESERVED_CSOT:
				break;
			case GLASS_DATA_GLASS_SCAN_SCHEDULE_CSOT:
				pTransferData->strGlassScanSchedule = strData.TrimRight(_T(" "));
				break;
			
			}
		}
	}
	else
	{
		CString strReadAddress = _T("");
		CString strReadData = _T("");
		int nReadSize = 0;
		int readData = 0;
		int nData = 0;

		char chReadData[2048] = {0};

		for(int i=0; i<nPCControlReadDataCount; i++)
		{
			const SSignalSettingData *pInfo = pSignalInfo->GetReadDataAddress(i);
			if (pInfo==NULL) continue;

			strReadAddress	= pInfo->strAddr;
			//nReadSize		= pInfo->nSize*2;
			nReadSize		= pInfo->nSize;
			memset(chReadData, 0, sizeof(chReadData));
			readData = 0;
			switch(i)
			{
				case GLASS_DATA_PROD_ID_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strProdID.Format(_T("%d"), readData);
					strReadData = pTransferData->strProdID;
					break;
					//pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
					//pTransferData->strProdID = strReadData.TrimRight(_T(" "));
					//strReadData = pTransferData->strProdID;
					//break;

				case GLASS_DATA_OPER_ID_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strOperID.Format(_T("%d"), readData);
					strReadData = pTransferData->strOperID;
					break;


				case GLASS_DATA_LOT_ID_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strLotID.Format(_T("%d"), readData);
					strReadData = pTransferData->strLotID;
					break;


				case GLASS_DATA_PPID_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
					pTransferData->strPPID = strReadData.TrimRight(_T(" "));
					strReadData = pTransferData->strPPID;
					break;
					

				case GLASS_DATA_PPID_RECIPE_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
					pTransferData->strPPID_RC = strReadData;
					pTransferData->strPPID_RC = strReadData.Left(12);
					strReadData = pTransferData->strPPID_RC;
					break;


				case GLASS_DATA_JOB_TYPE_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
					pTransferData->strJobType = strReadData.TrimRight(_T(" "));
					strReadData = pTransferData->strJobType;
					break;


				case GLASS_DATA_JOB_ID_CSOT:  //cmark
					pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
					pTransferData->strJobID = strReadData.TrimRight(_T(" "));
					strReadData = pTransferData->strJobID;

					pTransferData->strGlassLastName = strReadData.Right(1);

					break;
					//Á¦¾î¿¡¼­ ¸ø¹Þ¾Æ¿Í¼­ ÀÌ°Ô 0À¸·Î 󸮵ȴ٠¿ØÁö¸ð¸£°ÙÁö¸¸  GLASSID ´ë½Å ÀÌ°ªÀ» ³Ö¾îÁֱ⠶§¹®¿¡ RAW ÆÄÀÏ¿¡¼­ Á¦¾î¿¡¼­ ¸ø¹Þ¾Æ¿À¸é default ÀÎ HPANEL12345 À¸·Î ÇØÁִµ¥ ±×°Ô¾Æ´Ñ 
					//0ÀÌ µé¾î¿ÈÀ¸·Î RAW ÆÄÀÏ À̸§À» 0À¸·Î ó¸®ÇÏ°í ¸øÀÐ¾î ¿Â´Ù.

				case GLASS_DATA_LOT_SEQUENCE_NUMBER_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strLotSeqNum.Format(_T("%d"), readData);
					strReadData = pTransferData->strLotSeqNum;
					break;

				case GLASS_DATA_SLOT_SEQUENCE_NUMBER_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strSlotSeqNum.Format(_T("%d"), readData);
					strReadData = pTransferData->strSlotSeqNum;
					break;

				case GLASS_DATA_PROPERTY_CODE_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, nReadSize);
					pTransferData->strPropertyCode.Format(_T("%d"), readData);
					strReadData = pTransferData->strPropertyCode;
					break;

				case GLASS_DATA_JOB_JUDGE_CODE_CSOT:
					{
						pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
						pTransferData->strJobJudgeCode.Format(_T("%d"), strReadData[0]);
						strReadData = pTransferData->strJobJudgeCode;
					}

					break;

				case GLASS_DATA_JOB_GRADE_CODE_CSOT:
					{
						pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
						pTransferData->strJobGradeCode.Format(_T("%d"), strReadData[0]);
						strReadData = pTransferData->strJobGradeCode;
					}

					break;

				case GLASS_DATA_SUBSTRATE_TYPE_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strSubstrateType.Format(_T("%d"), readData);
					strReadData = pTransferData->strSubstrateType;
					break;

				case GLASS_DATA_PROCESSING_FLAG_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strProcessingFlag.Format(_T("%d"), readData);
					strReadData = pTransferData->strProcessingFlag;
					break;

				case GLASS_DATA_INSPECTION_FLAG_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strInspectionFlag.Format(_T("%d"), readData);
					strReadData = pTransferData->strInspectionFlag;
					break;

				case GLASS_DATA_SKIP_FLAG_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strSkipFlag.Format(_T("%d"), readData);
					strReadData = pTransferData->strSkipFlag;
					break;

				case GLASS_DATA_JOB_SIZE_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strJobSize.Format(_T("%d"), readData);
					strReadData = pTransferData->strJobSize;
					break;

				case GLASS_DATA_GLASS_THICKNESS_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strGlassThickness.Format(_T("%d"), readData);
					strReadData = pTransferData->strGlassThickness;
					break;

				case GLASS_DATA_JOB_ANGLE_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strJobAngle.Format(_T("%d"), readData);
					strReadData = pTransferData->strJobAngle;
					break;

				case GLASS_DATA_JOB_FLIP_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strJobFlip.Format(_T("%d"), readData);
					strReadData = pTransferData->strJobFlip;
					break;

				case GLASS_DATA_CUTTING_GLASS_TYPE_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strCuttingGlassType.Format(_T("%d"), readData);
					strReadData = pTransferData->strCuttingGlassType;
					break;

				case GLASS_DATA_PROCESSING_COUNT_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strProcessingCount.Format(_T("%d"), readData);
					strReadData = pTransferData->strProcessingCount;
					break;

				case GLASS_DATA_INSPECTION_JUDGE_DATA_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strInspectionJudgeData.Format(_T("%d"), readData);
					strReadData = pTransferData->strInspectionJudgeData;
					break;

				case GLASS_DATA_PAIR_JOB_ID_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
					pTransferData->strPairJobID = strReadData.TrimRight(_T(" "));
					strReadData = pTransferData->strPairJobID;
					break;

				case GLASS_DATA_PAIR_FLAG_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
					memcpy(&readData, chReadData, 2);
					pTransferData->strPairFlag.Format(_T("%d"), readData);
					strReadData = pTransferData->strPairFlag;
					break;
				case GLASS_DATA_OPTION_VALUE_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
					pTransferData->strOptionValue = strReadData.TrimRight(_T(" "));
					strReadData = pTransferData->strOptionValue;
					break;
				case GLASS_DATA_RESERVED_CSOT:
					pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
					pTransferData->strReserved = strReadData.TrimRight(_T(" "));
					strReadData = pTransferData->strReserved;
					break;

				case GLASS_DATA_GLASS_SCAN_SCHEDULE_CSOT: // ºÐÆÇ Á¤º¸ cmark
					pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
					pTransferData->strGlassScanSchedule = strReadData.TrimRight(_T(" "));

					if(pTransferData->strGlassScanSchedule==_T("L")){
						pTransferData->strGlassScanSchedule=(_T("0"));
					}
					else if(pTransferData->strGlassScanSchedule==_T("R")){
						pTransferData->strGlassScanSchedule=(_T("1"));
					}
					else{
						pTransferData->strGlassScanSchedule=(_T("0"));
					}
					strReadData = pTransferData->strGlassScanSchedule;
					break;
				}
				m_pSP2P->ISP2P_DisplayMessage(_T("[ReadTransferData] Name: %s, Addr: %s, Size: %d, Data: %s"), pInfo->strName, strReadAddress, nReadSize, strReadData);
		}
	}

	return TRUE;
}

void CSequenceProcessor_CSOT::UpdateGlassResultFromTransferData(CGlassResult *pGlassResult, STransferData* pTransferData)
{
	if (pGlassResult==NULL || pTransferData==NULL) return;

	// [2017:1:9]-[WEZASW] : PCControl GlassData Ç׸ñ ÀçÁ¤ÀÇ
	// transfer data is not exist
	if (pTransferData->strLotID.GetLength()<1)
	{
		pTransferData->strLotID = _T("LOTID");
	}
	if (pTransferData->strJobID.GetLength()<1)
	{
		pTransferData->strJobID =  _T("HPANELID");
	}
	if (pTransferData->strOperID.GetLength()<1)
	{
		pTransferData->strOperID = _T("12345");
	}
	if (pTransferData->strGlassCode.GetLength()<1)
	{
		pTransferData->strGlassCode = _T("12");
	}
	if (pTransferData->strPPID_RC.GetLength()<1)
	{
		pTransferData->strPPID_RC = _T("Default");
	}
	if (pTransferData->strGlassLastName.GetLength()<1)
	{
		pTransferData->strGlassLastName = _T("A");
	}

	// update transfer data to glass result
	pGlassResult->m_strGlassLastName = pTransferData->strGlassLastName;
	pGlassResult->m_strGlassID	= pTransferData->strGlassID;
	pGlassResult->m_strGlassCode	= pTransferData->strGlassCode;
	pGlassResult->m_strMode					=	pTransferData->strMode;
	pGlassResult->m_strGlassType			=	pTransferData->strGlassType;
	pGlassResult->m_strDummyType			=	pTransferData->strDummyType;
	pGlassResult->m_strProdID = pTransferData->strProdID;
	pGlassResult->m_strOperID = pTransferData->strOperID;
	pGlassResult->m_strLotID = pTransferData->strLotID;
	pGlassResult->m_strPPID = pTransferData->strPPID;
	pGlassResult->m_strPPID_RC = pTransferData->strPPID_RC;
	pGlassResult->m_strJobType = pTransferData->strJobType;
	pGlassResult->m_strJobID = pTransferData->strJobID;
	pGlassResult->m_strLotSeqNum = pTransferData->strLotSeqNum;
	pGlassResult->m_strSlotSeqNum = pTransferData->strSlotSeqNum;
	pGlassResult->m_strPropertyCode = pTransferData->strPropertyCode;
	pGlassResult->m_strJobJudgeCode = pTransferData->strJobJudgeCode;
	pGlassResult->m_strJobGradeCode = pTransferData->strJobGradeCode;
	pGlassResult->m_strSubstrateType = pTransferData->strSubstrateType;
	pGlassResult->m_strProcessingFlag = pTransferData->strProcessingFlag;
	pGlassResult->m_strInspectionFlag = pTransferData->strInspectionFlag;
	pGlassResult->m_strSkipFlag = pTransferData->strSkipFlag;
	pGlassResult->m_strJobSize = pTransferData->strJobSize;
	pGlassResult->m_strGlassThickness = pTransferData->strGlassThickness;
	pGlassResult->m_strJobAngle = pTransferData->strJobAngle;
	pGlassResult->m_strJobFlip = pTransferData->strJobFlip;
	pGlassResult->m_strCuttingGlassType = pTransferData->strCuttingGlassType;
	pGlassResult->m_strProcessingCount = pTransferData->strProcessingCount;
	pGlassResult->m_strInspectionJudgeData = pTransferData->strInspectionJudgeData;
	pGlassResult->m_strPairJobID = pTransferData->strPairJobID;
	pGlassResult->m_strPairFlag = pTransferData->strPairFlag;
	pGlassResult->m_strOptionValue = pTransferData->strOptionValue;
	pGlassResult->m_strReserved = pTransferData->strReserved;
	pGlassResult->strGlassScanSchedule = pTransferData->strGlassScanSchedule;//ºÐÆÇ Á¤º¸ cmark
	

}

void CSequenceProcessor_CSOT::CreateResultDirectory(const CString& strGlassID, const CString& strDate)
{
	if (m_pSP2P==NULL) return;

	const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
	if(pNetworkInfo == NULL) return;

	CString strPath = _T("");

	if (strDate.GetLength()>0)
	{
		// raw path
		if(pNetworkInfo->m_strLocalRawPath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
		{
			strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strLocalRawPath, strDate);
			CreateDirectory(strPath, NULL);
		}

		// raw backup path
 		if(pNetworkInfo->m_strLocalRawPath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
 		{
 			strPath.Format(_T("%sBackup\\%s"), pNetworkInfo->m_strLocalRawPath, strDate);
 			CreateDirectory(strPath, NULL);
 		}

		// image path
		if(pNetworkInfo->m_strLocalImagePath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
		{
			strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strLocalImagePath, strDate);
			CreateDirectory(strPath, NULL);
		}
	}
	else
	{
		// image path
		if(pNetworkInfo->m_strLocalImagePath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
		{
			strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strLocalImagePath, strGlassID);
			CreateDirectory(strPath, NULL);
		}
	}

	if(pNetworkInfo->m_strAlignImagePath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
	{
		strPath.Format(_T("%s\\%s"),pNetworkInfo->m_strAlignImagePath, strGlassID);
		CreateDirectory(strPath, NULL);
	}
}




void CSequenceProcessor_CSOT::SetSaveImageBasePathToReviewProcessor(const CString& strGlassID, const CString& strResultDate)
{
	const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
	if(pNetworkInfo == NULL) return;

	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
	if(pReviewProcessor == NULL) return;

	CString strPath = _T("");
	if(pNetworkInfo->m_strLocalImagePath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
	{
		CTime snapTime = CTime::GetCurrentTime();
		CString strSnapTime = _T("");
		strSnapTime.Format(_T("_%04d%02d%02d%02d%02d%02d"), snapTime.GetYear(), snapTime.GetMonth(), snapTime.GetDay(), 
			snapTime.GetHour(), snapTime.GetMinute(), snapTime.GetSecond());	// snap_time

		// Local
		if (strResultDate.GetLength()>0)
		{
			strPath.Format(_T("%s\\%s\\%s"), pNetworkInfo->m_strLocalImagePath, strResultDate, strGlassID + strSnapTime);			
		}
		else
		{
			strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strLocalImagePath, strGlassID + strSnapTime);
		}

		CreateDirectory(strPath, NULL);
		pReviewProcessor->SetSaveImageBasePath(strPath);


		CTime tmServerLoadingTime =  CDitGlassRawClient::GetInstance()->GetGlassData()->m_tmGlassLoading;

		//¾÷·Îµå Æú´õ ¸¸µå´Â°÷
		// Upload
     //	strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strUploadImagePath, strGlassID);
		
		strPath.Format(_T("%s\\%s_%04d%02d%02d%02d%02d%02d"), pNetworkInfo->m_strUploadImagePath, strGlassID,tmServerLoadingTime.GetYear(),tmServerLoadingTime.GetMonth(),tmServerLoadingTime.GetDay(),tmServerLoadingTime.GetHour(),tmServerLoadingTime.GetMinute(),tmServerLoadingTime.GetSecond());
		CreateDirectory(strPath, NULL);
		pReviewProcessor->SetUploadImagePath(strPath);

	}
}

void CSequenceProcessor_CSOT::SetSaveImageBasePathToAlignCameraControl(const CString& strGlassID)
{
	const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
	if(pNetworkInfo == NULL) return;

	CCameraControlAlign* pAlignCameraControl = m_pSP2P->ISP2P_GetAlignCameraControl();
	if(pAlignCameraControl == NULL) return;

	CString strPath = _T("");
	if(pNetworkInfo->m_strAlignImagePath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
	{
		strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strAlignImagePath, strGlassID);
		pAlignCameraControl->SetSaveImageBasePath(strPath);
	}
}

BOOL CSequenceProcessor_CSOT::ReadRecipeDataFromRecipeFile(const CString& strPPID_RC, CString& strRecipeName)// const CString& strPPID, CString& strRecipeName
{
	CRsRecipeManager *pRsRecipeManager = m_pSP2P->ISP2P_Recipe_GetRsRecipeManager();
	if(pRsRecipeManager == NULL) {	return FALSE;	}
	pRsRecipeManager->SetRecipeReadStatus(RCP_READ_STATUS_NONE);

	strRecipeName = _T("");

	// find recipe file
	if(FindRecipeFileName(strPPID_RC, strRecipeName) == FALSE)
	{
		strRecipeName.Format(_T("Default"));
	}

	// read recipe file
	if(pRsRecipeManager->ReadRecipeFile(strRecipeName) == FALSE)
	{
		pRsRecipeManager->SetRecipeReadStatus(RCP_READ_STATUS_FAIL);
		return FALSE;
	}

	pRsRecipeManager->SetRecipeReadStatus(RCP_READ_STATUS_SUCCESS);

	return TRUE;
}

BOOL CSequenceProcessor_CSOT::FindRecipeFileName(const CString& strPPID_RC, CString& strRecipeName/*const CString& strPPID, CString& strRecipeName*/)
{
	BOOL bRet = FALSE, bFind;
	CFileFind finder;
	CString strSearchPath;

	//if(strPPID.IsEmpty() == TRUE) return bRet;
	if(strPPID_RC.IsEmpty() == TRUE) return bRet;

	CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult == NULL) return FALSE;

	const CString* strStepID = pGlassResult->GetStepID();
	strSearchPath.Format(_T("%s\\%s.rcp"), _REVIEW_RECIPE_PATH_, strPPID_RC);

	bFind = finder.FindFile(strSearchPath);

	while(bFind)
	{
		bFind = finder.FindNextFile();

		if(finder.IsDots()) continue;
		if(finder.IsDirectory()) continue;

		strRecipeName = finder.GetFileTitle();
		bRet = TRUE;
		break;
	}

	finder.Close();

	return bRet;
}

BOOL CSequenceProcessor_CSOT::ApplyRecipeDataToGlassResult(CGlassResult *pGlassResult)
{
	if(pGlassResult == NULL) return FALSE;

	// ·¹½ÃÇÇ ¼³Á¤
	const CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo==NULL) return FALSE;

	// system info
	const CSystemInfo* pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();

	// ±Û¶ó½º Á¤º¸
	STransferData* pTransferData = m_pSP2P->ISP2P_GetCurrentTransferData();
	if (pTransferData==NULL) return FALSE;
	int nGlassTypeInfoIndex = 0;
	{
		nGlassTypeInfoIndex = pRsRcpReviewInfo->m_nGlassTypeIdx;
		if(_ttoi(pTransferData->strGlassScanSchedule) == 1)
		{
			nGlassTypeInfoIndex = pRsRcpReviewInfo->m_nGlassTypeIdx + 1;
		}
	}
	
	const CGlassTypeInfo* pGlassTypeInfo = m_pSP2P->ISP2P_System_GetGlassTypeInfo(nGlassTypeInfoIndex);
	m_pSP2P->ISP2P_DisplayMessage(_T("GlassTypeName : %s,GlassTypeIdx : %s"),pGlassTypeInfo->m_strGlassTypeName,pTransferData->strGlassScanSchedule);
	
	// ¸ðÅÍ Á¤º¸
	const CMotorControlInfo *pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();

	// ÁÂÇ¥ º¯È¯±â
	CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();

	// ÁÂÇ¥°è ¼³Á¤
	if (pSystemInfo && pGlassTypeInfo && pMotorInfo && pCoordCalibrator)
	{
		// Get Direction		
		int nDirectionX = GetDirectionX(pGlassTypeInfo->m_nOriginDirection, pMotorInfo->GetOriginDirection());
		int nDirectionY = GetDirectionY(pGlassTypeInfo->m_nOriginDirection, pMotorInfo->GetOriginDirection());

		// ÁÂÇ¥°è ¼³Á¤
		pCoordCalibrator->SetTransDirection(nDirectionX, nDirectionY);
		pCoordCalibrator->SetOriginMotorPosition(pGlassTypeInfo->m_dOriginMotorX, pGlassTypeInfo->m_dOriginMotorY);
		if (fabs(pGlassTypeInfo->m_dAlignAngle) > 0.0000001)
		{
			pCoordCalibrator->SetRotationInfo(pGlassTypeInfo->m_dFirstAlignMotorX, pGlassTypeInfo->m_dFirstAlignMotorY, 
				pGlassTypeInfo->m_dFirstAlignGlassX, pGlassTypeInfo->m_dFirstAlignGlassY, pGlassTypeInfo->m_dAlignAngle);
		}

		// ±Û¶ó½º Á¤º¸ ¼³Á¤
		pGlassResult->SetGlassSize(pGlassTypeInfo->m_nGlassSizeX * 1000, pGlassTypeInfo->m_nGlassSizeY * 1000);
		pGlassResult->SetGlassOriginDirection(pGlassTypeInfo->m_nOriginDirection);
		pGlassResult->SetCornerCutDirection(pGlassTypeInfo->m_nCornerCutDirection);
		pGlassResult->SetGlassCenterCoordinate(pGlassTypeInfo->m_bUseCenterCoodinateSystem);
		pGlassResult->SetGlassInverseCoordinate(pGlassTypeInfo->m_bUseInverseCoordinate);
		pGlassResult->SetCollisionDistanceX(int(pSystemInfo->m_dCollisionDistance*1000.));
	}

	// Align Á¤º¸
	const CRsRcpAlignInfo* pRsRcpAlignInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpAlignInfo();

	// Align Á¤º¸ ¼³Á¤
	if (pGlassTypeInfo && pRsRcpAlignInfo)
	{
		// Align ¸¶Å© Á¤º¸ ¼³Á¤ (Çȼ¿, ¸ðÅÍ, ±Û¶ó½º À§Ä¡)
		pGlassResult->m_AlignRecipe.m_nUseAlignPosMove		= pGlassTypeInfo->m_nUseAlignPosMove;

		// Çȼ¿ À§Ä¡
		pGlassResult->m_AlignRecipe.dOriginPixelX[0]		= pGlassTypeInfo->m_nFirstAlignFindPixelX;
		pGlassResult->m_AlignRecipe.dOriginPixelY[0]		= pGlassTypeInfo->m_nFirstAlignFindPixelY;
		pGlassResult->m_AlignRecipe.dOriginPixelX[1]		= pGlassTypeInfo->m_nSecondAlignFindPixelX;
		pGlassResult->m_AlignRecipe.dOriginPixelY[1]		= pGlassTypeInfo->m_nSecondAlignFindPixelY;

		// ¸ðÅÍ À§Ä¡
		pGlassResult->m_AlignRecipe.dOriginPositionX[0]		= pGlassTypeInfo->m_dFirstAlignMotorX;
		pGlassResult->m_AlignRecipe.dOriginPositionY[0]		= pGlassTypeInfo->m_dFirstAlignMotorY;
		pGlassResult->m_AlignRecipe.dOriginPositionX[1]		= pGlassTypeInfo->m_dSecondAlignMotorX;
		pGlassResult->m_AlignRecipe.dOriginPositionY[1]		= pGlassTypeInfo->m_dSecondAlignMotorY;

		// ±Û¶ó½º À§Ä¡
		pGlassResult->m_AlignRecipe.dGlassPositionX[0]		= pGlassTypeInfo->m_dFirstAlignGlassX;
		pGlassResult->m_AlignRecipe.dGlassPositionY[0]		= pGlassTypeInfo->m_dFirstAlignGlassY;
		pGlassResult->m_AlignRecipe.dGlassPositionX[1]		= pGlassTypeInfo->m_dSecondAlignGlassX;
		pGlassResult->m_AlignRecipe.dGlassPositionY[1]		= pGlassTypeInfo->m_dSecondAlignGlassY;

		// Align Recipe Á¤º¸ ¼³Á¤ ÀÚµ¿±¤·® ã±â ÆĶó¹ÌÅÍ
		// Align Skip Mode
		pGlassResult->m_AlignRecipe.bAlignSkipMode		= pRsRcpAlignInfo->m_bAlignSkipMode;
		pGlassResult->m_AlignRecipe.bUseTotalPitchMeasure = pRsRcpAlignInfo->m_bTotalPitchMeasure;

		// image matching
		pGlassResult->m_AlignRecipe.bUseImage			= pRsRcpAlignInfo->m_bUseImage;
		pGlassResult->m_AlignRecipe.dMatchingRate		= pRsRcpAlignInfo->m_dMatchingRate;
		pGlassResult->m_AlignRecipe.strFirstImageFile	= pRsRcpAlignInfo->m_strFirstImageFile;
		pGlassResult->m_AlignRecipe.strSecondImageFile	= pRsRcpAlignInfo->m_strSecondImageFile;
		pGlassResult->m_AlignRecipe.strTotalPitchImageFile = pRsRcpAlignInfo->m_strTotalPitchImageFile;

		// edge find param
		pGlassResult->m_AlignRecipe.bUseEdge			= pRsRcpAlignInfo->m_bUseEdge;
		pGlassResult->m_AlignRecipe.nEdgeWidth			= pRsRcpAlignInfo->m_nEdgeWidth;
		pGlassResult->m_AlignRecipe.nEdgeHeight			= pRsRcpAlignInfo->m_nEdgeHeight;
		pGlassResult->m_AlignRecipe.nEdgeThreshold		= pRsRcpAlignInfo->m_nEdgeThreshold;
		pGlassResult->m_AlignRecipe.nMergeRange			= pRsRcpAlignInfo->m_nMergeRange;
		pGlassResult->m_AlignRecipe.dEdgeRate			= pRsRcpAlignInfo->m_dEdgeRate;
		
		// ³ëÃâ½Ã°£
		pGlassResult->m_AlignRecipe.bManualProcess			= pRsRcpAlignInfo->m_bManualProcess;
		pGlassResult->m_AlignRecipe.dFirstCamExposure		= pRsRcpAlignInfo->m_dFirstCamExposure;
		pGlassResult->m_AlignRecipe.dSecondCamExposure		= pRsRcpAlignInfo->m_dSecondCamExposure;

		// ÀÚµ¿±¤·® Á¶°Ç
		pGlassResult->m_AlignRecipe.bAutoProcess			= pRsRcpAlignInfo->m_bAutoProcess;
		pGlassResult->m_AlignRecipe.dTargetMin				= pRsRcpAlignInfo->m_dTargetMin;
		pGlassResult->m_AlignRecipe.dTargetMax				= pRsRcpAlignInfo->m_dTargetMax;
		pGlassResult->m_AlignRecipe.dExposureMin			= pRsRcpAlignInfo->m_dExposureMin;
		pGlassResult->m_AlignRecipe.dExposureMax			= pRsRcpAlignInfo->m_dExposureMax;

		// Align Recipe Á¤º¸ ¼³Á¤ rotate info
		pGlassResult->m_AlignRecipe.bRotateProcess			= pRsRcpAlignInfo->m_bRotateProcess;
		pGlassResult->m_AlignRecipe.nRetryCount				= pRsRcpAlignInfo->m_nRetryCount;
		pGlassResult->m_AlignRecipe.dGlassAngleMin			= pRsRcpAlignInfo->m_dGlassAngleMin;
		pGlassResult->m_AlignRecipe.dGlassAngleMax			= pRsRcpAlignInfo->m_dGlassAngleMax;

		// Align Ä«¸Þ¶ó ¹æÇâ ¹× ÇØ»óµµ ¼³Á¤		
		int nAlignCameraInfoCount = 2;
		for(int nAlignCameraIdx = 0; nAlignCameraIdx < nAlignCameraInfoCount; nAlignCameraIdx++)
		{
			// Align Á¶¸í °ª °¡Á®¿À±â.
			int nLightValue = 0;
			
			
			if(pRsRcpAlignInfo->m_bManualProcess == 1)
			{
				nLightValue = (nAlignCameraIdx==0) ? (int)pRsRcpAlignInfo->m_dFirstCamExposure: (int)pRsRcpAlignInfo->m_dSecondCamExposure;

				 //Á¶¸í°ª º¯°æ.
				CLightControl *pLightControl = m_pSP2P->ISP2P_GetAlignLightControl(nAlignCameraIdx);
				if (pLightControl)
				{
					if (pLightControl->SetLightLevel(nLightValue,nAlignCameraIdx))
					{
					if (nAlignCameraIdx==0)
					m_pSP2P->ISP2P_DisplayMessage(_T("[ApplyRecipeData] 1st AlignCamera Light Level Change %d Success!"), nLightValue);
					else if (nAlignCameraIdx==1)
					m_pSP2P->ISP2P_DisplayMessage(_T("[ApplyRecipeData] 2nd AlignCamera Light Level Change %d Success!"), nLightValue);
					}
				else
				{
					if (nAlignCameraIdx==0)
					m_pSP2P->ISP2P_DisplayMessage(_T("[ApplyRecipeData] 1st AlignCamera Light Level Change %d Fail!"), nLightValue);
					else if (nAlignCameraIdx==1)
					m_pSP2P->ISP2P_DisplayMessage(_T("[ApplyRecipeData] 2nd AlignCamera Light Level Change %d Fail!"), nLightValue);
				}

				}
			}
			

			// ¾ó¶óÀÎ Ä«¸Þ¶ó Á¤º¸ °¡Á®¿À±â 
			const CAlignCameraInfo *pCameraInfo	= m_pSP2P->ISP2P_System_GetAlignCameraInfo(nAlignCameraIdx);
			if (pCameraInfo)
			{
				const CCameraControlInfo_Plus* pCameraControlInfo = pCameraInfo->GetCameraControlInfo();
				if(pCameraControlInfo)
				{
					pGlassResult->m_AlignRecipe.dCameraResolution[nAlignCameraIdx] = pCameraControlInfo->GetPixelResolution();
					if(pCameraControlInfo->GetAxisDirectionX() == CAMERA_DIRECTION_FORWARD)
					{
						pGlassResult->m_AlignRecipe.nCameraDirX[nAlignCameraIdx] = 1;
					}
					else
					{
						pGlassResult->m_AlignRecipe.nCameraDirX[nAlignCameraIdx] = -1;
					}

					if(pCameraControlInfo->GetAxisDirectionY() == CAMERA_DIRECTION_FORWARD)
					{
						pGlassResult->m_AlignRecipe.nCameraDirY[nAlignCameraIdx] = 1;
					}
					else
					{
						pGlassResult->m_AlignRecipe.nCameraDirY[nAlignCameraIdx] = -1;
					}
				}
			}

			// ¾ó¶óÀÎ ÅÛÇø´ Á¤º¸ °¡Á®¿À±â
			if((int)pGlassTypeInfo->m_vecTemplateImagePath.size() == nAlignCameraInfoCount)
			{
				pGlassResult->m_AlignRecipe.strTemplateName[nAlignCameraIdx] = pGlassTypeInfo->m_vecTemplateImagePath[nAlignCameraIdx];
			}
		}		
	}

	if (pRsRcpReviewInfo) 
	{
		int nModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount();
		CString strRecipeName = *pGlassResult->GetPPID();

		for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
		{
			// Review Module
			//////////////////////////////////////////////////////////////////////////
			AFM_SetAFMTracking(nModuleIdx, FALSE);

			const CRcpLightInfo *pRcpReviewLightInfo = pRsRcpReviewInfo->GetRcpLightInfo(nModuleIdx);
			if (pRcpReviewLightInfo)
			{
				ReviewLight_SetLightLevel(nModuleIdx, pRcpReviewLightInfo->m_nLightLevel);
			}

			const CRcpAFMRecipeInfo *pRcpReviewAFMInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
			if (pRcpReviewAFMInfo)
			{
				int nRealAFMIndex = pRcpReviewAFMInfo->m_nRecipeIndex;
				if(nRealAFMIndex == -1)// ·¹½ÃÇÇ¿¡ ¼±ÅÃµÈ ¹èÀ²ÀÇ ½ÇÁ¦ MagnificInfo Index¸¦ ¾Ë¾Æ¿È
				{
					//-1ÀÇ °æ¿ì ¹èÀ² À妽º °¡Á®´Ù ¾¸.
					nRealAFMIndex = GetRealMagnification(nModuleIdx, pRcpReviewAFMInfo->m_nZoomIndex);
				}
				AFM_SetAFMRecipeName(nModuleIdx, strRecipeName, nRealAFMIndex);

				if(pRcpReviewAFMInfo->m_bAFMHomeOffMode==TRUE) //190618AFMȨ ½ÃÄö½º ÁøÇà X
				{
					SetUseAfmHomePosition(FALSE);
				}
				else
				{
					SetUseAfmHomePosition(TRUE);
				}
			}
		}
	}

	// °áÇÔ Ã£±â ·¹½ÃÇÇ ¼³Á¤
	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
	const CRsRcpDefectFindInfo* pRsRcpDefectFindInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpDefectFindInfo();
	if(pReviewProcessor && pRsRcpDefectFindInfo)
	{
		pReviewProcessor->SetDefectFindInfo(pRsRcpDefectFindInfo);
	}

	// EdgeAlign Check
	CCameraControlAlign* pCameraControlAlign = m_pSP2P->ISP2P_GetAlignCameraControl();
	if(pCameraControlAlign)
	{
		pCameraControlAlign->SetAlignType(pRsRcpAlignInfo->m_bEdgeAlignProcess);
		g_pLog->DisplayMessage(_T("[ApplyRecipeDataToGlassResult] EdgeAlignCheck"));
	}

	// range info
	CRsRcpReviewInfo* pRsRcpReviewInfo2 = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo2)
	{
		CRcpSchedulingInfo* pScheduleInfo = pRsRcpReviewInfo2->GetRcpSchedulingInfo();
		if (pScheduleInfo)
		{
			if (pScheduleInfo->GetUseRangeCntInfo())
			{
				// pointer re init
				m_pSP2P->ISP2P_GetDefectPicker(PICKER_IDX_RANGE);
				m_pSP2P->ISP2P_GetReviewScheduler(PICKER_IDX_RANGE);

				// add range info
				for (int nIdx=0; nIdx<Range_Count; nIdx++)
				{
					SRangePoint* pRangeInfo = pScheduleInfo->GetRangePointInfo(nIdx);
					if (pRangeInfo == NULL) continue;

					GetRangeName(nIdx, pRangeInfo);
					GetRangeSize(nIdx, pRangeInfo);
				}
				GetRangeStartEnd(pScheduleInfo);
			}
		}
	}	
	return TRUE;
}

BOOL CSequenceProcessor_CSOT::ReadAOIRawFileToGlassResult(CGlassResult *pGlassResult)
{
	BOOL bRet = FALSE;

	CString strRawTDPath=_T(""), strRawCDPath=_T(""), strRawSDPath=_T("");

	// °á°úÆÄÀÏ À̸§ ã±â
	FindAOIRawFilePath(pGlassResult, &strRawTDPath, &strRawCDPath, &strRawSDPath);

	bRet = m_pSP2P->ISP2P_ReadAOIRawFileToGlassResult(strRawTDPath);
		
	return bRet;
}

BOOL CSequenceProcessor_CSOT::FindAOIRawFilePath(CGlassResult *pGlassResult, CString* pRawTDPath, CString* pRawCDPath, CString* pRawSDPath)
{
	*pRawTDPath = _T("");
	*pRawCDPath = _T("");
	*pRawSDPath = _T("");

	CString strGlassID = *pGlassResult->GetJobID();

	if (strGlassID.IsEmpty())
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("Glass ID is not Exist!"));
		return FALSE;
	}

	const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
	if(pNetworkInfo == NULL) return 0;

	CString strAOIRawPath = pNetworkInfo->m_strAOIRawPath;
	CString strLocalRawPath = pNetworkInfo->m_strLocalRawPath;
	if (strAOIRawPath.IsEmpty() || strLocalRawPath.IsEmpty() )
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("%s ResultFile Search Fail!"), strGlassID);
		return FALSE;
	}

	// set find name
	CString strSearchPath;
	strSearchPath.Format(_T("%s\\%s*"), strAOIRawPath, strGlassID);

	// find file 
	CTime timeLastWrite;
	CString strFileName, strFileGlassID, strFileWriteTime, strFileExtension, strExtTemp;
	SRawFile sRawFile;
	VectorSRawFile vectorSRowFile;

	int nIdx = -1;
	CFileFind finder;
	BOOL bRet = finder.FindFile(strSearchPath);
	while(bRet)
	{
		sRawFile.Reset();
		bRet = finder.FindNextFile();

		if(finder.IsDots()) continue;
		if(finder.IsDirectory()) continue;

		// [2017:5:16]-[WEZASW] : AOI ServerÀÇ °áÇÔ ÆÄÀÏ À§Ä¡¿¡ °áÇÔ¸Ê À̹ÌÁö ÆÄÀÏ Á¸Àç·Î °áÇÕ ÆÄÀϸ¸ ÃßÃâ
		sRawFile.strFileName = finder.GetFileName();
		strExtTemp = sRawFile.strFileName;
		int nIdx = strExtTemp.Remove('.');		
		AfxExtractSubString(strFileExtension, sRawFile.strFileName, nIdx, '.');
		//if(strFileExtension.Compare(_T("hgl")) != 0 ) continue;

		finder.GetLastWriteTime(timeLastWrite);
		sRawFile.dWriteTime = (double)timeLastWrite.GetTime();
		vectorSRowFile.push_back(sRawFile);
	}
	finder.Close();

	// find file size check
	if(vectorSRowFile.size() < 1)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("%s ResultFile Search Fail!"), strGlassID);
		return FALSE;
	}

	// sorting find file
	SortingFindAOIRawFile(vectorSRowFile, RESULT_SORTING_DESCENDING);

	CString strSourcePath, strTargetPath;
	strFileName.Format(_T("%s"), vectorSRowFile[0].strFileName);
	strSourcePath.Format(_T("%s\\%s"), strAOIRawPath, strFileName);
	strTargetPath.Format(_T("%s\\%s"), strLocalRawPath, strFileName);

	//TD
	if (CopyFile(strSourcePath, strTargetPath, FALSE))
	{
		CString strSrcFilePath, strDstFilePath, strFileTemp;

		bRet = TRUE;
		pGlassResult->m_strLocalRawFilePath = strTargetPath;
		pGlassResult->m_strAOIRawFileName = strFileName;
		pGlassResult->m_strAOIRawFilePath = strSourcePath;
		m_pSP2P->ISP2P_DisplayMessage(_T("%s -> %s"), strSourcePath, strTargetPath);
		m_pSP2P->ISP2P_DisplayMessage(_T("[TD] ResultFile Copy Success!"));
		
		// Backup
		strSourcePath = strTargetPath;
		if (pGlassResult->m_strResultDate.GetLength()>0)
		{
			strTargetPath.Format(_T("%sBackup\\%s\\%s"), strLocalRawPath, pGlassResult->m_strResultDate, strFileName); // here mch
		}
		else
		{
			strTargetPath.Format(_T("%sBackup\\%s"), strLocalRawPath, strFileName); // here mch
		}

		CopyFile(strSourcePath, strTargetPath, FALSE);
		
		*pRawTDPath = pGlassResult->m_strLocalRawFilePath;
	}
	else
	{
		bRet = FALSE;
		pGlassResult->m_strLocalRawFilePath = _T("");
		pGlassResult->m_strAOIRawFileName = _T("");
		pGlassResult->m_strAOIRawFilePath = _T("");
		m_pSP2P->ISP2P_DisplayMessage(_T("[TD] %s ResultFile Copy Fail!"), strTargetPath);
	}

	return bRet;
}

BOOL CSequenceProcessor_CSOT::ReviewStartProcessing(CGlassResult *pGlassResult, int nPlanIndex)
{
	// clear frame index
	int nCameraControlCount = m_pSP2P->ISP2P_GetReviewCameraControlCount();
	for(int nCameraControlIdx = 0; nCameraControlIdx < nCameraControlCount; nCameraControlIdx++)
	{
		CCameraControlReview* pCameraControl = m_pSP2P->ISP2P_GetReviewCameraControl(nCameraControlIdx);
		if(pCameraControl == NULL) continue ;
		pCameraControl->Camera_ClearIndex();
	}	
	
	// AFM Tracking OFF
	//AFM_SetAFMTracking(TRUE);

	// set Mag (Revolver, AFM)
	if(!AllChangeMagnification(0, ZoomLevel_Auto_CSOT, CSOT_PlanReview))
	{
		g_pLog->DisplayMessage(_T("[Revolver] Magnification Change Fail"));
	}	

	// set Light Value
	CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo) 
	{
		int nModuleCount = Module_GetModuleStatusCount();
		for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
		{
			const CRcpLightInfo *pRcpLightInfo = pRsRcpReviewInfo->GetRcpLightInfo(nModuleIdx);
			if (pRcpLightInfo)
			{
				ReviewLight_SetLightLevel(nModuleIdx, pRcpLightInfo->m_nLightLevel);
			}

			BOOL isTopReview = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx)->GetAFMOffMode();
			if (!isTopReview)
			{
				// AFM Tracking ON
				AFM_SetAFMTracking(nModuleIdx, TRUE);
			}
		}
	}
	
	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
	if(pGlassResult && pReviewProcessor)
	{
		// ReviewStart
		pReviewProcessor->SetJobID(pGlassResult->m_strJobID);//pGlassResult->m_strGlassID -> pGlassResult->m_strJobID
		pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
		m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_ReviewStart, nPlanIndex);

		// Send ReviewPos to motor
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Review Point to Motor Started!"));
		SendReviewPositionToMotorControl(pGlassResult);
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Review Point to Motor Ended!"));

		return TRUE;
	}	

	return FALSE;
}

int CSequenceProcessor_CSOT::SendReviewPositionToMotorControl(CGlassResult *pGlassResult)
{
	CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
	if(pMotorControl == NULL) return 0;

	const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
	if(pSystemInfo == NULL) return -1;

	const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
	if (pMotorInfo == NULL) return -2;

	const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
	if (pMotorInfo == NULL) return -3;

	// set move count zero
	for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
	{
		pMotorControl->GantrySetMoveCount(i, 0);
	}

	// set move delay time
	pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
	pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
	pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());

	// get direction
	int nDirectionX, nDirectionY;
	pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);

	int nTotalCount = 0;
	double dDefectPosX, dDefectPosY;

	// review result count
	for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
	{		
		// get review result
		CReviewResult*					pReviewResult	= pGlassResult->GetReviewResult(nModuleIdx); 
		if (pReviewResult==NULL) continue;
		const SCoordInfo*				pCoordInfo		= Module_GetCoordInfo(nModuleIdx);
		if (pCoordInfo==NULL) continue;
		CModuleStatus*					pModuleStatus	= Module_GetModuleStatus(nModuleIdx);		
		if (pModuleStatus == NULL) continue;

		// set result index
		int nStartIdx = pReviewResult->GetStartSReviewResultIndex();
		int nEndIdx = pReviewResult->GetEndSReviewResultIndex();
		nEndIdx = min(nEndIdx, (pReviewResult->GetSReviewResultCount()-1)) + 1;		// End Index ´Ù½Ã¼³Á¤

		// get review pos
		VectorDouble vectorPosX, vectorPosY;
		for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
		{
			SReviewResult* pReview = pReviewResult->GetSReviewResult(nResultIdx);
			if (pReview==NULL) continue;

			// set defect pos
			dDefectPosX = double(pReview->nUMOriginX) / 1000.0;
			dDefectPosY = double(pReview->nUMOriginY) / 1000.0;

			// trans glass to motor pos
			pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);

			// set offset
			ApplyMotorOffset(pReview->nModuleIdx, pReview->nZoomIdx, MotorOffsetCamera + MotorOffsetMag+MotorOffset_Glass, dDefectPosX, dDefectPosY);

			// calibration
			CalibrateMotorPos(pReview->nModuleIdx,dDefectPosX,dDefectPosY);

			// add review result
			if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
			{
				pReview->dTargetMotorX = dDefectPosX;
				pReview->dTargetMotorY = dDefectPosY;
				vectorPosX.push_back(dDefectPosX);
				vectorPosY.push_back(dDefectPosY);
			}
		}

		// move path to motor
		// FALSE->TRUE(HSJ TEST)
		if (pMotorControl->GantryAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))
		{
			nTotalCount += (int)vectorPosX.size();
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success! Point[%d]"), pModuleStatus->GetGantryIndex(), int(vectorPosX.size()));
			//cmark
		}
		else
		{
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
		}
	}

	// all auto go
	// HSJ TEST
 	if (pMotorControl->CommonSetAutoGoAll()==FALSE)
 	{
 		g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoReview Fail!"));
 		return 0;
 	}

	g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoReview Success!"));
	return nTotalCount;
}

BOOL CSequenceProcessor_CSOT::UserStartProcessing(CGlassResult *pGlassResult, int nPlanIndex)
{
	// clear frame index
	int nCameraControlCount = m_pSP2P->ISP2P_GetReviewCameraControlCount();
	for(int nCameraControlIdx = 0; nCameraControlIdx < nCameraControlCount; nCameraControlIdx++)
	{
		CCameraControlReview* pCameraControl = m_pSP2P->ISP2P_GetReviewCameraControl(nCameraControlIdx);
		if(pCameraControl == NULL) continue ;
		pCameraControl->Camera_ClearIndex();
	}	

	// AFM Tracking OFF
	AFM_SetAFMTracking(FALSE);

	// set Mag (Revolver, AFM)
	if(!AllChangeMagnification(0, ZoomLevel_Auto_CSOT, CSOT_PlanUser))
	{
		g_pLog->DisplayMessage(_T("[Revolver] Magnification Change Fail"));
	}	

	// set Light Value
	const CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo) 
	{
		int nModuleCount = Module_GetModuleStatusCount();
		for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
		{
			const CRcpLightInfo *pRcpLightInfo = pRsRcpReviewInfo->GetRcpUserLightInfo(nModuleIdx);
			if (pRcpLightInfo)
			{
				ReviewLight_SetLightLevel(nModuleIdx, pRcpLightInfo->m_nLightLevel);
			}
		}
	}

	// AFM Tracking ON
	AFM_SetAFMTracking(TRUE);

	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
	if(pGlassResult && pReviewProcessor)
	{
		// UserStart
		pReviewProcessor->SetJobID(pGlassResult->m_strJobID);	//pGlassResult->m_strGlassID -> pGlassResult->m_strJobID º¯°æ
		pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
		m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_UserStart, nPlanIndex);

		// Send UserPos to motor
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send User Point to Motor Started!"));
		SendUserPositionToMotorControl(pGlassResult);
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send User Point to Motor Ended!"));

		return TRUE;
	}	

	return FALSE;
}

int	CSequenceProcessor_CSOT::SendUserPositionToMotorControl(CGlassResult *pGlassResult)
{
	CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
	if(pMotorControl == NULL) return 0;

	const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
	if(pSystemInfo == NULL) return -1;

	const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
	if (pMotorInfo == NULL) return -2;

	const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
	if (pMotorInfo == NULL) return -3;

	// set move count zero
	for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
	{
		pMotorControl->GantrySetMoveCount(i, 0);
	}

	// set move delay time
	pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
	pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
	pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());


	// get direction
	int nDirectionX, nDirectionY;
	pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);

	int nTotalCount = 0;
	double dDefectPosX, dDefectPosY;

	// review result count
	for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
	{		
		// get UserResult
		CReviewResult*					pReviewResult	= pGlassResult->GetUserResult(nModuleIdx);
		if (pReviewResult==NULL) continue;
		const SCoordInfo*				pCoordInfo		= Module_GetCoordInfo(nModuleIdx);
		if (pCoordInfo==NULL) continue;
		CModuleStatus*					pModuleStatus	= Module_GetModuleStatus(nModuleIdx);		
		if (pModuleStatus == NULL) continue;

		// get result index
		int nStartIdx = pReviewResult->GetStartSReviewResultIndex();
		int nEndIdx = pReviewResult->GetEndSReviewResultIndex();
		nEndIdx = min(nEndIdx, (pReviewResult->GetSReviewResultCount()-1)) + 1;		// End Index ´Ù½Ã¼³Á¤

		// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
		double m_dMinOffset = -5.0; 
		double m_dMaxOffset = 5.0;

		// get user pos
		VectorDouble vectorPosX, vectorPosY;
		for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
		{
			SReviewResult* pReview = pReviewResult->GetSReviewResult(nResultIdx);
			if (pReview==NULL) continue;

			// set defect pos
			dDefectPosX = double(pReview->nUMOriginX) / 1000.0;
			dDefectPosY = double(pReview->nUMOriginY) / 1000.0;

			// trans glass to motor pos
			pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);

			// set offset
			ApplyMotorOffset(pReview->nModuleIdx, pReview->nZoomIdx, MotorOffsetCamera + MotorOffsetMag+MotorOffset_Glass, dDefectPosX, dDefectPosY);

			CalibrateMotorPos(pReview->nModuleIdx, dDefectPosX, dDefectPosY);

			// push move pos
			if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
			{
				pReview->dTargetMotorX = dDefectPosX;
				pReview->dTargetMotorY = dDefectPosY;
				vectorPosX.push_back(dDefectPosX);
				vectorPosY.push_back(dDefectPosY);
			}
		}

		// move path to motor
		if (pMotorControl->GantryAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))
		{
			nTotalCount += (int)vectorPosX.size();
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success! Point Count : %d"), pModuleStatus->GetGantryIndex(), (int)vectorPosX.size());
		}
		else
		{
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
		}
	}

	// all auto go
 	if (pMotorControl->CommonSetAutoGoAll()==FALSE)
 	{
 		g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoUser Fail!"));
 		return 0;
 	}

	g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoUser Success!"));
	return nTotalCount;
}

BOOL CSequenceProcessor_CSOT::WsiStartProcessing(CGlassResult *pGlassResult, int nPlanIndex)
{
	AFM_SetAFMTracking(FALSE);  
	// send wsi start

	SetWsiType(0);
	WSIAllReadySignal(0);

	if(!WSIAllStartSignal())
	{
		g_pLog->DisplayMessage(_T("[WSI] WSI Start Fail!!"));
	}

	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
	if(pGlassResult && pReviewProcessor)
	{
		// WsiStart
		pReviewProcessor->SetJobID(pGlassResult->m_strJobID);	// pGlassResult->m_strGlassID -> pGlassResult->m_strJobID º¯°æ
		pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
		m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_WSIStart, nPlanIndex);

		// Send WsiPos to Motor
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Wsi Point to Motor Started!"));
		SendWsiPositionToMotorControl(pGlassResult);
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Wsi Point to Motor Ended!"));

		
		MakeWSIUpLoadDirectory(pReviewProcessor->GetUploadImagePath());

		//20190219 chm 
		pReviewProcessor->SetReviewCount(0);			// ¸®ºä Sequence No ÃʱâÈ­.

		return TRUE;
	}	
	
	return FALSE;
}

void CSequenceProcessor_CSOT::MakeWSIUpLoadDirectory(CString strPath)
{
	strPath  = strPath + _T("\\WSI");
	if(CreateDirectory(strPath,NULL)==FALSE)
	{
		g_pLog->DisplayMessage(_T("[MakeWSIUpLoadDirectory]Directory Create Fail %s "),strPath);
	}
	
}

int	 CSequenceProcessor_CSOT::SendWsiPositionToMotorControl(CGlassResult* pGlassResult)
{
	CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
	if(pMotorControl == NULL) return 0;

	const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
	if(pSystemInfo == NULL) return -1;

	const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
	if (pMotorInfo == NULL) return -2;

	const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
	if (pMotorInfo == NULL) return -3;

	// set move count zero
	for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
	{
		pMotorControl->GantrySetMoveCount(i, 0);
	}

	// set move delay time
	pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
	pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
	pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());

	// get direction
	int nDirectionX, nDirectionY;
	pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);

	int nTotalCount = 0;
	double dDefectPosX, dDefectPosY;

	// WSI result count
	for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
	{		
		CReviewResult*					pWsiResult	= pGlassResult->GetWsiResult(nModuleIdx);
		if (pWsiResult==NULL) continue;
		const SCoordInfo*				pCoordInfo		= Module_GetCoordInfo(nModuleIdx);
		if (pCoordInfo==NULL) continue;
		CModuleStatus*					pModuleStatus	= Module_GetModuleStatus(nModuleIdx);		
		if (pModuleStatus == NULL) continue;

		// get result index
		int nStartIdx = pWsiResult->GetStartSReviewResultIndex();
		int nEndIdx = pWsiResult->GetEndSReviewResultIndex();
		nEndIdx = min(nEndIdx, (pWsiResult->GetSReviewResultCount()-1)) + 1;		// set End Index 

		// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
		double m_dMinOffset = -5.0; 
		double m_dMaxOffset = 5.0;

		// get wsi pos
		VectorDouble vectorPosX, vectorPosY;

		for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
		{
			SReviewResult* pWsi = pWsiResult->GetSReviewResult(nResultIdx);
			if (pWsi==NULL) continue;

			// set defect pos
			dDefectPosX = double(pWsi->nUMOriginX) / 1000.0;
			dDefectPosY = double(pWsi->nUMOriginY) / 1000.0;

			// trans glass to motor pos
			pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);

			// set offset
			ApplyMotorOffset(pWsi->nModuleIdx, -1, MotorOffsetCamera + MotorOffsetWSI+MotorOffset_Glass, dDefectPosX, dDefectPosY);

			// motor calibrate
			CalibrateMotorPos(pWsi->nModuleIdx, dDefectPosX, dDefectPosY);

			// add move pos
			if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
			{
				pWsi->dTargetMotorX = dDefectPosX;
				pWsi->dTargetMotorY = dDefectPosY;
				vectorPosX.push_back(dDefectPosX);
				vectorPosY.push_back(dDefectPosY);				
			}
		}

	
		if (pMotorControl->GantryWsiAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))
		{
			nTotalCount += (int)vectorPosX.size();
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success! PointCount : %d"), pModuleStatus->GetGantryIndex(), (int)vectorPosX.size());
		}
		else
		{
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
		}
	}

	// all auto go
	if (pMotorControl->CommonSetAutoWsiGoAll()==FALSE)
	{
		g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoWsi Fail!"));
		return 0;
	}

	g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoWsi Success!"));
	return nTotalCount;
}
BOOL CSequenceProcessor_CSOT::ReflowStartProcessing( CGlassResult *pGlassResult, int nPlanIndex/*=0*/ )
{
	// clear frame index
	int nCameraControlCount = m_pSP2P->ISP2P_GetReviewCameraControlCount();
	for(int nCameraControlIdx = 0; nCameraControlIdx < nCameraControlCount; nCameraControlIdx++)
	{
		CCameraControlReview* pCameraControl = m_pSP2P->ISP2P_GetReviewCameraControl(nCameraControlIdx);
		if(pCameraControl == NULL) continue ;
		pCameraControl->Camera_ClearIndex();
	}	

	// AFM Tracking OFF
	AFM_SetAFMTracking(FALSE);

	// set Mag (Revolver, AFM)
	if(!AllChangeMagnification(0, ZoomLevel_Auto_CSOT, CSOT_PlanReflow))
	{
		g_pLog->DisplayMessage(_T("[Revolver] Magnification Change Fail"));
	}	

	// set Light Value
	const CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo) 
	{
		int nModuleCount = Module_GetModuleStatusCount();
		for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
		{
			const CRcpLightInfo *pRcpLightInfo = pRsRcpReviewInfo->GetRcpUserLightInfo(nModuleIdx);
			if (pRcpLightInfo)
			{
				ReviewLight_SetLightLevel(nModuleIdx, pRcpLightInfo->m_nLightLevel);
			}
		}
	}

	// AFM Tracking ON
	AFM_SetAFMTracking(TRUE);

	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
	if(pGlassResult && pReviewProcessor)
	{
		// UserStart
		pReviewProcessor->SetJobID(pGlassResult->m_strJobID);
		pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
		m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_ReflowStart, nPlanIndex);

		// Send UserPos to motor
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Reflow Point to Motor Started!"));
		SendReflowPositionToMotorControl(pGlassResult);
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Reflow Point to Motor Ended!"));

		return TRUE;
	}	

	return FALSE;
}

int CSequenceProcessor_CSOT::SendReflowPositionToMotorControl( CGlassResult* pGlassResult )
{
	CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
	if(pMotorControl == NULL) return 0;

	const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
	if(pSystemInfo == NULL) return -1;

	const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
	if (pMotorInfo == NULL) return -2;

	const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
	if (pMotorInfo == NULL) return -3;

	// set move count zero
	for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
	{
		pMotorControl->GantrySetMoveCount(i, 0);
	}

	// set move delay time
	pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
	pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
	pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());


	// get direction
	int nDirectionX, nDirectionY;
	pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);

	int nTotalCount = 0;
	double dDefectPosX, dDefectPosY;

	// review result count
	for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
	{		
		// get reflow result
		CReviewResult*					pReviewResult	= pGlassResult->GetReflowResult(nModuleIdx);
		if (pReviewResult==NULL) continue;
		const SCoordInfo*				pCoordInfo		= Module_GetCoordInfo(nModuleIdx);
		if (pCoordInfo==NULL) continue;
		CModuleStatus*					pModuleStatus	= Module_GetModuleStatus(nModuleIdx);		
		if (pModuleStatus == NULL) continue;

		// get result index
		int nStartIdx = pReviewResult->GetStartSReviewResultIndex();
		int nEndIdx = pReviewResult->GetEndSReviewResultIndex();
		nEndIdx = min(nEndIdx, (pReviewResult->GetSReviewResultCount()-1)) + 1;		// End Index ´Ù½Ã¼³Á¤

		// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
		double m_dMinOffset = -5.0; 
		double m_dMaxOffset = 5.0;

		// get reflow pos
		VectorDouble vectorPosX, vectorPosY;
		for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
		{
			SReviewResult* pReview = pReviewResult->GetSReviewResult(nResultIdx);
			if (pReview==NULL) continue;

			// set defect pos
			dDefectPosX = double(pReview->nUMOriginX) / 1000.0;
			dDefectPosY = double(pReview->nUMOriginY) / 1000.0;

			g_pLog->DisplayMessage(_T("[ReflowStart] %d Module, %d Point, Glass: %.3lf mm, %.3lf mm"), nModuleIdx, nResultIdx, dDefectPosX, dDefectPosY);

			// trans glass to motor pos
			pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);

			// set offset
			ApplyMotorOffset(pReview->nModuleIdx, pReview->nZoomIdx, MotorOffsetCamera + MotorOffsetMag, dDefectPosX, dDefectPosY);

			CalibrateMotorPos(pReview->nModuleIdx, dDefectPosX, dDefectPosY);

			// push move pos
			if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
			{
				pReview->dTargetMotorX = dDefectPosX;
				pReview->dTargetMotorY = dDefectPosY;
				vectorPosX.push_back(dDefectPosX);
				vectorPosY.push_back(dDefectPosY);

				g_pLog->DisplayMessage(_T("[ReflowStart] %d Module, %d Point, Motor: %.3lf mm, %.3lf mm"), nModuleIdx, nResultIdx, dDefectPosX, dDefectPosY);
			}
		}

		// move path to motor
		if (pMotorControl->GantryAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))//
		{
			nTotalCount += (int)vectorPosX.size();
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success!"), pModuleStatus->GetGantryIndex());
		}
		else
		{
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
		}
	}

	// all auto go
	if (pMotorControl->CommonSetAutoGoAll()==FALSE)
	{
		g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoReflow Fail!"));
		return 0;
	}

	g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoReflow Success!"));
	return nTotalCount;
}

BOOL CSequenceProcessor_CSOT::MeasureStartProcessing(CGlassResult *pGlassResult, int nPlanIndex)
{
	// Check Glass per MeausreRecipeGlassCount
	const CRsRcpMeasureInfo *pRsRcpMeasureInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpMeasureInfo();

	// clear frame index
	int nCameraControlCount = m_pSP2P->ISP2P_GetReviewCameraControlCount();
	for(int nCameraControlIdx = 0; nCameraControlIdx < nCameraControlCount; nCameraControlIdx++)
	{
		CCameraControlReview* pCameraControl = m_pSP2P->ISP2P_GetReviewCameraControl(nCameraControlIdx);
		if(pCameraControl == NULL) continue ;
		pCameraControl->Camera_ClearIndex();
	}	

	// AFM Tracking OFF
	AFM_SetAFMTracking(FALSE);

	// set Mag (Revolver, AFM)
	if(!AllChangeMagnification(0, ZoomLevel_Auto_CSOT, CSOT_PlanMeasure))
	{
		g_pLog->DisplayMessage(_T("[Revolver] Magnification Change Fail"));
	}	

	// set Light Value
// 	if (pRsRcpMeasureInfo) 
// 	{
// 		const CRcpMeasureInfo* pMeasureInfo = pRsRcpMeasureInfo->GetRcpMeasureInfo(0); //first pos
// 		if (pMeasureInfo)
// 		{
// 			int nModuleCount = Module_GetModuleStatusCount();
// 			for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
// 			{
// 				ReviewLight_SetLightLevel(nModuleIdx, pMeasureInfo->GetLightLevel());
// 			}
// 		}
// 	}

	if (pRsRcpMeasureInfo) 
	{
		int nModuleCount = Module_GetModuleStatusCount();
		int nLightIndex = 0;
		for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
		{
			const CRcpMeasureInfo* pMeasureInfo = pRsRcpMeasureInfo->GetRcpMeasureInfo(nLightIndex);
			ReviewLight_SetLightLevel(nModuleIdx, pMeasureInfo->GetLightLevel());
			nLightIndex += pRsRcpMeasureInfo->GetResultCount();
		}
	}

	// AFM Tracking ON
	AFM_SetAFMTracking(TRUE);

	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
	if(pGlassResult && pReviewProcessor)
	{
		// MeasureStart
		pReviewProcessor->SetJobID(pGlassResult->m_strJobID);	// pGlassResult->m_strGlassID -> pGlassResult->m_strJobID º¯°æ
		pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
		m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_MeasureStart, nPlanIndex);

		// Send MeasurePos to Motor
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Measure Point to Motor Started!"));
		SendMeasurePositionToMotorControl(pGlassResult);
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Measure Point to Motor Ended!"));

		return TRUE;
	}

	return FALSE;
}


int	CSequenceProcessor_CSOT::SendMeasurePositionToMotorControl(CGlassResult *pGlassResult)
{
	CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
	if(pMotorControl == NULL) return 0;

	const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
	if(pSystemInfo == NULL) return -1;

	const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
	if (pMotorInfo == NULL) return -2;

	const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
	if (pCoordCalibrator == NULL) return -3;

	const CRsRcpMeasureInfo* pRsRcpMeasureInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpMeasureInfo();
	if (pRsRcpMeasureInfo==NULL) return -4;

	// set move count zero
	int nGantryCount = pSystemInfo->GetGantryInfoCount();
	for (int nGantryIdx=0; nGantryIdx<nGantryCount; nGantryIdx++)
	{
		pMotorControl->GantrySetMoveCount(nGantryIdx, 0);
	}

	// set move delay time
	pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
	pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetAfDelayTime());
	pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());

	// get direction
// 	int nDirectionX, nDirectionY;
// 	pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);

	int nTotalCount = 0;
	double dDefectPosX, dDefectPosY;

	int nResultCount = pRsRcpMeasureInfo->GetResultCount();

	for (int nGantryIdx=0; nGantryIdx<nGantryCount; nGantryIdx++)
	{
		VectorDouble vecGantryPos;	
		for (int nResultIdx=0; nResultIdx<nResultCount; nResultIdx++)
		{
			VectorDouble vecTempPos;	
			for(int nModuleIdx=0; nModuleIdx<m_pSP2P->ISP2P_GetModuleStatusCount(); nModuleIdx++)
			{
				const CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
				if (pModuleStatus==NULL) continue;

				// check gantry idx
				if (nGantryIdx!=pModuleStatus->GetGantryIndex()) continue;

				// get measure result
				SReviewResult* pSReviewResult = pGlassResult->GetSMeasureResult(nModuleIdx, nResultIdx);
				if (pSReviewResult==NULL) continue;

				const SCoordInfo* pCoordInfo = Module_GetCoordInfo(nModuleIdx);
				if(pCoordInfo == NULL) continue;	

				// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
				double m_dMinOffset = -5.0; 
				double m_dMaxOffset = 5.0;

				dDefectPosX = double(pSReviewResult->nUMOriginX) / 1000.0;
				dDefectPosY = double(pSReviewResult->nUMOriginY) / 1000.0;			

				// trans glass to motor pos
				pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);

				// set offset
				ApplyMotorOffset(nModuleIdx, pSReviewResult->nZoomIdx, MotorOffsetCamera+MotorOffsetMag+MotorOffset_Glass, dDefectPosX, dDefectPosY);

				// motor calibrator
				CalibrateMotorPos(nModuleIdx, dDefectPosX, dDefectPosY);

				// last motor pos
				pSReviewResult->dTargetMotorX = dDefectPosX;
				pSReviewResult->dTargetMotorY = dDefectPosY;

				if (pModuleStatus->GetHeaderIndex()==0) // main header
				{
					vecTempPos.push_back(dDefectPosX);	// X1
					vecTempPos.push_back(dDefectPosY);	// Y1
				}
				else // sub header
				{					
					vecTempPos.push_back(dDefectPosY);	// Y2
					double dSxPos = dDefectPosX - vecTempPos[0]; // X2 - X1
					vecTempPos.push_back(dSxPos);
				}
			} // end for module


			CString strValue = _T("");
			strValue.Format(_T("[%d_Gantry_%d_Pos] "), nGantryIdx, nResultIdx);
			CString strTemp = _T("");
			for (VectorDoubleIt it=vecTempPos.begin(); it!=vecTempPos.end(); it++)
			{
				strTemp.Format(_T("%.3lf , "), *it);
				strValue += strTemp;
				vecGantryPos.push_back(*it);
			}

			g_pLog->DisplayMessage(strValue);

		} // end for result

		// send measure pos & count
		if(pMotorControl->GantryMeasureAutoGo(nGantryIdx, vecGantryPos, TRUE))
		{
			nTotalCount += (int)vecGantryPos.size();
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success! %d ea"), nGantryIdx, (int)vecGantryPos.size());
		}
		else
		{
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail!"), nGantryIdx);
		}

	}

	// all gantry measure command
	if (pMotorControl->CommonSetAutoMeasureGoAll()==FALSE)
	{
		g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoMeasure Fail!"));
		return 0;
	}

	g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoMeasure Success!"));

	return nTotalCount;
}


int	CSequenceProcessor_CSOT::SendMeasurePositionToMotorControl_Old(CGlassResult *pGlassResult)
{
	CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
	if(pMotorControl == NULL) return 0;

	const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
	if(pSystemInfo == NULL) return -1;

	const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
	if (pMotorInfo == NULL) return -2;

	const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
	if (pMotorInfo == NULL) return -3;

	// set move count zero
	for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
	{
		pMotorControl->GantrySetMoveCount(i, 0);
	}

	// set move delay time
	pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
	pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
	pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());

	// get direction
	int nDirectionX, nDirectionY;
	pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);

	int nTotalCount = 0;
	double dDefectPosX, dDefectPosY;

	// ModuleÀÇ À§Ä¡¿¡ µû¸¥ ModuleStatus sorting
	std::vector<CModuleStatus*> SortedModuleStatus;
	for(int nModuleIdx = 0; nModuleIdx < m_pSP2P->ISP2P_GetModuleStatusCount(); nModuleIdx++)
	{
		SortedModuleStatus.push_back(m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx));
	}

	// y sort => x sort
	std::sort(SortedModuleStatus.begin(), SortedModuleStatus.end(), CompareFuction);	

	//std::vector<CReviewResult*> vecReviewResult;
	VectorReviewResult* vecReviewResult = pGlassResult->GetVectorMeasureResult();

	std::vector<VectorReviewResult> vecGantryReviewResult;
	vecGantryReviewResult.resize(pSystemInfo->GetGantryInfoCount());

	for(int nReviewResultIdx = 0; nReviewResultIdx < vecReviewResult->size(); nReviewResultIdx++)
	{
		int nModuleStatusIdx = vecReviewResult->at(nReviewResultIdx).GetModuleIndex();
		CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleStatusIdx);
		if(pModuleStatus == NULL) continue;

		vecGantryReviewResult.at(pModuleStatus->GetGantryIndex()).push_back(vecReviewResult->at(nReviewResultIdx));
	}

	for(int nGantryIdx = 0; nGantryIdx < pSystemInfo->GetGantryInfoCount(); nGantryIdx++)
	{
		std::sort(vecGantryReviewResult.at(nGantryIdx).begin(), vecGantryReviewResult.at(nGantryIdx).begin(), GantrySorting);
	}

	for(int nGantryIdx = 0; nGantryIdx < pSystemInfo->GetGantryInfoCount(); nGantryIdx++)
	{
		VectorDouble vectorPos;		
		VectorReviewResult* pVectorReviewResult = &vecGantryReviewResult.at(nGantryIdx);
		if(pVectorReviewResult == NULL) continue;
		if(pVectorReviewResult->size() == 0) continue;

		int nStartIdx = pVectorReviewResult->at(0).GetStartSReviewResultIndex();
		int nEndIdx = pVectorReviewResult->at(0).GetEndSReviewResultIndex();

		for(int nSReviewResultIdx = nStartIdx; nSReviewResultIdx < nEndIdx; nSReviewResultIdx++)
		{
			for(int nHeaderIdx = 0; nHeaderIdx < vecGantryReviewResult.at(nGantryIdx).size(); nHeaderIdx++)
			{
				CReviewResult* pReviewResult = &pVectorReviewResult->at(nHeaderIdx);
				if(pReviewResult == NULL)
				{
					m_pSP2P->ISP2P_DisplayMessage(_T("[Measure Error]Gantry[%d] ReviewResult is NULL"), pReviewResult->GetModuleIndex());
					break;
				}

				const SCoordInfo* pCoordInfo = Module_GetCoordInfo(pReviewResult->GetModuleIndex());
				if(pCoordInfo == NULL) continue;				

				// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
				double m_dMinOffset = -5.0; 
				double m_dMaxOffset = 5.0;

				SReviewResult* pSReviewResult = pReviewResult->GetSReviewResult(nSReviewResultIdx);
				if(pSReviewResult == NULL) continue;

				dDefectPosX = double(pSReviewResult->nUMOriginX) / 1000.0;
				dDefectPosY = double(pSReviewResult->nUMOriginY) / 1000.0;			

				// trans glass to motor pos
				pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);

				// set offset
				ApplyMotorOffset(pSReviewResult->nModuleIdx, pSReviewResult->nZoomIdx, MotorOffsetCamera + MotorOffsetMag+MotorOffset_Glass, dDefectPosX, dDefectPosY);

				// motor calibrator
				CalibrateMotorPos(pSReviewResult->nModuleIdx, dDefectPosX, dDefectPosY);

				if(nHeaderIdx == 0)
				{
					// À̵¿ÇÒ ¸ðÅÍÁÂÇ¥ Ãß°¡
					if((int)vectorPos.size() < MAX_MOTOR_ADDRESS_SIZE)
					{
						pSReviewResult->dTargetMotorX = dDefectPosX;
						pSReviewResult->dTargetMotorY = dDefectPosY;
						vectorPos.push_back(dDefectPosX);
						vectorPos.push_back(dDefectPosY);
					}
				}
				else
				{
					if((int)vectorPos.size() < MAX_MOTOR_ADDRESS_SIZE)
					{
						pSReviewResult->dTargetMotorX = dDefectPosX;
						pSReviewResult->dTargetMotorY = dDefectPosY;						
						vectorPos.push_back(dDefectPosY);
						CReviewResult* pFirstReviewResult = &pVectorReviewResult->at(0);
						SReviewResult* pFirstSReviewResult = pFirstReviewResult->GetSReviewResult(nSReviewResultIdx);
						double dSXsize = double(pSReviewResult->nUMOriginX - pFirstSReviewResult->nUMOriginX);
						//						pCoordCalibrator->TransGlass2Motor(pCoordInfo, dSXsize, dDefectPosY);
						vectorPos.push_back(dSXsize);
					}
				}
			}
		}

	
		if(pMotorControl->GantryMeasureAutoGo(nGantryIdx, vectorPos, TRUE))
		{
			nTotalCount += (int)vectorPos.size();
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success!"), nGantryIdx);
		}
		else
		{
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success!"), nGantryIdx);
		}
	}

	// all gantry measure command
	if (pMotorControl->CommonSetAutoMeasureGoAll()==FALSE)
	{
		g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoMeasure Fail!"));
		return 0;
	}

	g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoMeasure Success!"));
	return nTotalCount;
}

void CSequenceProcessor_CSOT::ReviewScheduler_ResizeReviewResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CDefectPicker* pDefectPicker, int nSize)
{
	pReviewResult->Reset();
	int nResultIdx = 0;

	int nModuleIdx = pReviewResult->GetModuleIndex();

	CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
	if (pModuleStatus==NULL) return;
	
	CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo==NULL) return;

	CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
	if (pRcpAFMRecipeInfo==NULL) return;

	int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);
	
	SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
	SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
	if (pMagnificInfo==NULL) return;
	if (pCameraInfo==NULL) return;	
	
	for (int i=0; i<nSize; i++)
	{
		SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
		if (pNode==NULL)	continue;

		SReviewResult* sResult		= pDefectPicker->GetPickingResult(pNode->nTotalIndex);
		if(sResult == NULL)	continue;

		sResult->nReviewType		= ReviewType_Review;
		sResult->nModuleIdx			= nModuleIdx;
		sResult->nResultIdx			= nResultIdx;

		sResult->nZoomIdx			= nZoomIdx;
		sResult->dMagnification		= pMagnificInfo->dMagnification;
		sResult->dMeasureResolution	= pCameraInfo->dResolution / sResult->dMagnification;
		sResult->bDigitalZoom		= FALSE;

		pReviewResult->AddSReviewResult(*sResult);

		nResultIdx++;
	}

	pScheduleResult->ResizeScheduleResult(nSize);
}

void CSequenceProcessor_CSOT::ReviewScheduler_ResizeUserResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize)
{
	pReviewResult->Reset();
	int nResultIdx = 0;

	int nModuleIdx = pScheduleResult->GetModuleIndex();
	pReviewResult->SetModuleIndex(nModuleIdx);

	CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
	if (pModuleStatus==NULL) return;

	CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo==NULL) return;

	CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpUserAFMRecipeInfo(nModuleIdx);//pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
	if (pRcpAFMRecipeInfo==NULL) return;

	int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);

	SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
	SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
	if (pMagnificInfo==NULL) return;
	if (pCameraInfo==NULL) return;	

	for (int i=0; i<nSize; i++)
	{		
		SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
		if (pNode==NULL)	continue;
		
		SReviewResult* sResult = pPrioritySorter->GetSortingResultUser(pNode->nTotalIndex);
		if(sResult == NULL)	continue;

		sResult->nReviewType		= ReviewType_User;
		sResult->nModuleIdx			= nModuleIdx;
		sResult->nResultIdx			= nResultIdx;

		sResult->nZoomIdx			= nZoomIdx;
		sResult->dMagnification		= pMagnificInfo->dMagnification;
		sResult->dMeasureResolution	= pCameraInfo->dResolution / sResult->dMagnification;
		sResult->bDigitalZoom		= FALSE;

		pReviewResult->AddSReviewResult(*sResult);

		nResultIdx++;
	}

	pScheduleResult->ResizeScheduleResult(nSize);
}

void CSequenceProcessor_CSOT::ReviewScheduler_ResizeWsiResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pWsiResult, CDefectPicker* pDefectPicker, int nSize)
{
	pWsiResult->Reset();
	int nResultIdx = 0;
	
	int nModuleIdx = pScheduleResult->GetModuleIndex();
	pWsiResult->SetModuleIndex(nModuleIdx);

	CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
	if (pModuleStatus==NULL) return;

	CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo==NULL) return;

	CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
	if (pRcpAFMRecipeInfo==NULL) return;

	int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);

	SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
	SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
	if (pMagnificInfo==NULL) return;
	if (pCameraInfo==NULL) return;	

	for (int i=0; i<nSize; i++)
	{
		SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
		if (pNode==NULL)	continue;

		SReviewResult* sResult = pDefectPicker->GetPickingResultWsi(pNode->nTotalIndex);
		if(sResult == NULL)	continue;

		sResult->nReviewType			= ReviewType_Wsi;
		sResult->nModuleIdx			= nModuleIdx;
		sResult->nResultIdx			= nResultIdx;

// 		sResult->nZoomIdx			= nZoomIdx;
// 		sResult->dMagnification		= pMagnificInfo->dMagnification;
// 		sResult->dMeasureResolution	= pCameraInfo->dResolution / sResult->dMagnification;
// 		sResult->bDigitalZoom		= FALSE;

		pWsiResult->AddSReviewResult(*sResult);

		nResultIdx++;
	}

	pScheduleResult->ResizeScheduleResult(nSize);
}

void CSequenceProcessor_CSOT::ReviewScheduler_ResizeReflowResult( CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize)
{
	pReviewResult->Reset();
	int nResultIdx = 0;

	int nModuleIdx = pScheduleResult->GetModuleIndex();
	pReviewResult->SetModuleIndex(nModuleIdx);

	CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
	if (pModuleStatus==NULL) return;

	CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo==NULL) return;

	CRcpUserDefectInfo* pRcpUserDefectInfo;

	CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
	if (pRcpAFMRecipeInfo==NULL) return;

	int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);

	SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
	SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
	if (pMagnificInfo==NULL) return;
	if (pCameraInfo==NULL) return;	

	CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult ==NULL)	return;

	CString strGlassLastName = pGlassResult->m_strGlassLastName;

	for (int i=0; i<nSize; i++)
	{
		SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
		if (pNode==NULL)	continue;
		
		SReviewResult* sResult = pPrioritySorter->GetSortingResultReflow(pNode->nTotalIndex);
		if(sResult == NULL)	continue;

		sResult->nReviewType		= ReviewType_Reflow;
		sResult->nModuleIdx			= nModuleIdx;
		sResult->nResultIdx			= nResultIdx;

		sResult->nZoomIdx			= nZoomIdx;
		sResult->dMagnification		= pMagnificInfo->dMagnification;
		sResult->dMeasureResolution	= pCameraInfo->dResolution / sResult->dMagnification;
		sResult->bDigitalZoom		= FALSE;
		
		pRcpUserDefectInfo = pRsRcpReviewInfo->GetRcpUserDefectInfo(pNode->nTotalIndex);
		if (pRcpUserDefectInfo == NULL) continue;

		if(strGlassLastName.Compare(_T("B")) == 0 || strGlassLastName.Compare(_T("b")) == 0)		sResult->strCellID			= pRcpUserDefectInfo->GetCellId2();
		else											sResult->strCellID			= pRcpUserDefectInfo->GetCellId();
		
		sResult->nReflow_CellIndex	= pRcpUserDefectInfo->m_nReflowCellIndex;

		pReviewResult->AddSReviewResult(*sResult);

		nResultIdx++;
	}

	pScheduleResult->ResizeScheduleResult(nSize);
}

int CSequenceProcessor_CSOT::GetCorrectMoudleStatusIdex(CPathSchedulerResult* pReviewScheduleResult, int nModuleType)
{
	int nModuleStatusCount = m_pSP2P->ISP2P_GetModuleStatusCount();
	std::vector<int> vecModuleIdx;
	std::vector<int> vecGantryIdx;
	std::vector<int> vecGantryPointX;
	std::vector<int> vecHeaderIdx;	
	
	for(int nModuleIdx = 0; nModuleIdx < nModuleStatusCount; nModuleIdx++)
	{
		CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
		if(pModuleStatus == NULL) continue;
		if(pModuleStatus->GetModuleType() == nModuleType)
		{
			vecModuleIdx.push_back(nModuleIdx);
		}
	}

	for(int nIdx = 0; nIdx < vecModuleIdx.size(); nIdx++)
	{
		CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nIdx);
		if(pModuleStatus == NULL) continue;
		//pModuleStatus->GetGantryIndex()
		if(!IntVectorFinder(vecGantryIdx, pModuleStatus->GetGantryIndex()))
		{
			vecGantryIdx.push_back(pModuleStatus->GetGantryIndex());
			vecGantryPointX.push_back( (int)pModuleStatus->GetMotorPosition()->dGlassPosX );
		}
//		if(!IntVectorFinder(vecHeaderIdx, pModuleStatus->GetHeaderIndex()))
//		{
//			vecHeaderIdx.push_back(pModuleStatus->GetHeaderIndex());
//		}
	}

	// Gantry Sorting
	int nMinPoint;
	int nMinIdx;
	for(int nIdx = 0; nIdx < vecGantryIdx.size(); nIdx++)
	{
		nMinPoint = vecGantryPointX.at(nIdx);
		nMinIdx = nIdx;
		for(int nIdx2 = nIdx; nIdx2 < vecGantryIdx.size(); nIdx2++)
		{
			if(vecGantryPointX.at(nIdx2) < nMinPoint)
			{
				nMinPoint = vecGantryPointX.at(nIdx2);
				nMinIdx = nIdx2;
			}
		}
		std::swap(vecGantryPointX.at(nIdx), vecGantryPointX.at(nMinIdx));
		std::swap(vecGantryIdx.at(nIdx), vecGantryIdx.at(nMinIdx));
	}

	return 1;
}

BOOL CSequenceProcessor_CSOT::IntVectorFinder(std::vector<int> TargetData, int FindData)
{
	for(std::vector<int>::iterator It = TargetData.begin(); It != TargetData.end(); It++)
	{
		if(FindData == *It) return TRUE;
	}
	return FALSE;
}

/*bool CSequenceProcessor_CSOT::sortstruct::CompareModuleStatusX(int i, int j)
{
	CModuleStatus* pLeftModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(i);
	CModuleStatus* pRightModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(j);

	if(pLeftModuleStatus == NULL || pRightModuleStatus == NULL)
	{
		return false;
	}
	double LGlassX = pLeftModuleStatus->GetMotorPosition()->dGlassPosX;	
	double RGlassX = pRightModuleStatus->GetMotorPosition()->dGlassPosX;	

	if(LGlassX < RGlassX) return true;
	else return false;
}*/
bool CSequenceProcessor_CSOT::CompareModuleStatusX::operator()(int i, int j)
{
	CModuleStatus* pLeftModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(i);
	CModuleStatus* pRightModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(j);

	if(pLeftModuleStatus == NULL || pRightModuleStatus == NULL)
	{
		return false;
	}
	double LGlassX = pLeftModuleStatus->GetMotorPosition()->dGlassPosX;	
	double RGlassX = pRightModuleStatus->GetMotorPosition()->dGlassPosX;	
	CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult == NULL) return false;

	if(pGlassResult->GetOriginDir() == 0 || pGlassResult->GetOriginDir() == 2)
	{
		if(LGlassX < RGlassX) return true;
		else return false;
	}
	else
	{
		if(LGlassX > RGlassX) return true;
		else return false;
	}	
}

bool CSequenceProcessor_CSOT::CompareModuleStatusY::operator()(int i, int j)
{
	CModuleStatus* pLeftModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(i);
	CModuleStatus* pRightModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(j);

	if(pLeftModuleStatus == NULL || pRightModuleStatus == NULL)
	{
		return false;
	}
	double LGlassY = pLeftModuleStatus->GetMotorPosition()->dGlassPosY;	
	double RGlassY = pRightModuleStatus->GetMotorPosition()->dGlassPosY;

	//if(LGlassY < RGlassY) return true;
	//else return false;
	CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult == NULL) return false;

	if(pGlassResult->GetOriginDir() == 2 || pGlassResult->GetOriginDir() == 3)
	{
		if(LGlassY < RGlassY) return true;
		else return false;
	}
	else
	{
		if(LGlassY > RGlassY) return true;
		else return false;
	}	
}

bool CSequenceProcessor_CSOT::CompareReviewResultX::operator()(CReviewResult i, CReviewResult j)
{
	SReviewResult* pLeftReviewResult = i.GetSReviewResult(0);
	SReviewResult* pRightReviewResult = j.GetSReviewResult(0);

	if(pLeftReviewResult == NULL || pRightReviewResult == NULL)
	{
		return false;
	}

	int LPointX = pLeftReviewResult->nUMOriginX;
	int	RPointX = pRightReviewResult->nUMOriginX;

//	if(LPointX < RPointX) return true;
	
//	return false;

	CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult == NULL) return false;

	if(pGlassResult->GetOriginDir() == 0 || pGlassResult->GetOriginDir() == 2)
	{
		if(LPointX < RPointX) return true;
		else return false;
	}
	else
	{
		if(LPointX > RPointX) return true;
		else return false;
	}	
}

bool CSequenceProcessor_CSOT::CompareReviewResultY::operator()(CReviewResult i, CReviewResult j)
{
	SReviewResult* pLeftReviewResult = i.GetSReviewResult(0);
	SReviewResult* pRightReviewResult = j.GetSReviewResult(0);

	if(pLeftReviewResult == NULL || pRightReviewResult == NULL)
	{
		return false;
	}

	int LPointY = pLeftReviewResult->nUMOriginY;
	int	RPointY = pRightReviewResult->nUMOriginY;

//	if(LPointY < RPointY) return true;
	
//	return false;
	CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult == NULL) return false;

	if(pGlassResult->GetOriginDir() == 2 || pGlassResult->GetOriginDir() == 3)
	{
		if(LPointY < RPointY) return true;
		else return false;
	}
	else
	{
		if(LPointY > RPointY) return true;
		else return false;
	}
}

bool CSequenceProcessor_CSOT::CompareWsiResultX::operator()(CReviewResult i, CReviewResult j)
{
	SReviewResult* pLeftReviewResult = i.GetSReviewResult(0);
	SReviewResult* pRightReviewResult = j.GetSReviewResult(0);

	if(pLeftReviewResult == NULL || pRightReviewResult == NULL)
	{
		return false;
	}

	int LPointX = pLeftReviewResult->nUMOriginX;
	int	RPointX = pRightReviewResult->nUMOriginX;

//	if(LPointX < RPointX) return true;

//	return false;
	CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult == NULL) return false;

	if(pGlassResult->GetOriginDir() == 0 || pGlassResult->GetOriginDir() == 2)
	{
		if(LPointX < RPointX) return true;
		else return false;
	}
	else
	{
		if(LPointX > RPointX) return true;
		else return false;
	}	

}

bool CSequenceProcessor_CSOT::CompareWsiResultY::operator()(CReviewResult i, CReviewResult j)
{
	SReviewResult* pLeftReviewResult = i.GetSReviewResult(0);
	SReviewResult* pRightReviewResult = j.GetSReviewResult(0);

	if(pLeftReviewResult == NULL || pRightReviewResult == NULL)
	{
		return false;
	}

	int LPointY = pLeftReviewResult->nUMOriginY;//.nUMOriginY;
	int	RPointY = pRightReviewResult->nUMOriginY;

//	if(LPointY < RPointY) return true;

//	return false;

	CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult == NULL) return false;

	if(pGlassResult->GetOriginDir() == 2 || pGlassResult->GetOriginDir() == 3)
	{
		if(LPointY < RPointY) return true;
		else return false;
	}
	else
	{
		if(LPointY > RPointY) return true;
		else return false;
	}
}

void CSequenceProcessor_CSOT::SetModuleStatusSReviewProcessor(CReviewResult* pReviewResult, int nModuleIdx)
{
	int nSReviewResultCount = pReviewResult->GetSReviewResultCount();
	for(int nSReviewIndx = 0; nSReviewIndx < nSReviewResultCount; nSReviewIndx++)
	{
		SReviewResult* pSReviewResult = pReviewResult->GetSReviewResult(nSReviewIndx);
		if(pSReviewResult == NULL) continue ;

		pSReviewResult->nModuleIdx = nModuleIdx;
	}
}

void CSequenceProcessor_CSOT::SetModuleStatusSWsiProcessor(CReviewResult* pWsiResult, int nModuleIdx)
{
	int nSWsiResultCount = pWsiResult->GetSReviewResultCount();
	for(int nSWsiIndx = 0; nSWsiIndx < nSWsiResultCount; nSWsiIndx++)
	{
		SReviewResult* pSWsiResult = pWsiResult->GetSReviewResult(nSWsiIndx);
		if(pSWsiResult == NULL) continue ;

		pSWsiResult->nModuleIdx = nModuleIdx;
	}
}

int	CSequenceProcessor_CSOT::SetModuleStatusForReviewResult(VectorReviewResult* pVecReviewResult, int nModuleType)
{
	if(pVecReviewResult->size() < 2) return 0;
	int nModuleStatusCount = m_pSP2P->ISP2P_GetModuleStatusCount(nModuleType);
	std::vector<int> vecModuleIdx;
	std::vector<int> vecReviewIdx;
	std::vector<int> vecGantryIdx;
	std::vector<int> vecHeaderIdx;	

	//sortstruct CompareFcuntions(this);

	for(int nModuleIdx = 0; nModuleIdx < m_pSP2P->ISP2P_GetModuleStatusCount(); nModuleIdx++)
	{
		CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
		if(pModuleStatus == NULL) continue;
		if(pModuleStatus->GetModuleType() & nModuleType)
		{
			vecModuleIdx.push_back(nModuleIdx);
		}
	}

	// Get Gantry, Header Count
	for(int nIdx = 0; nIdx < vecModuleIdx.size(); nIdx++)
	{
		CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(vecModuleIdx.at(nIdx));
		if(pModuleStatus == NULL) continue;
		//pModuleStatus->GetGantryIndex()
		if(!IntVectorFinder(vecGantryIdx, pModuleStatus->GetGantryIndex()))
		{
			vecGantryIdx.push_back(pModuleStatus->GetGantryIndex());			
		}
		if(!IntVectorFinder(vecHeaderIdx, pModuleStatus->GetHeaderIndex()))
		{
			vecHeaderIdx.push_back(pModuleStatus->GetHeaderIndex());
		}
	}	
	// Gantry Sorting
	std::sort(vecModuleIdx.begin(), vecModuleIdx.end(), CompareModuleStatusX(this));
	//std::sort(vecModuleIdx.begin(), vecModuleIdx.end());

	// Header Sorting
	for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx += (int)vecHeaderIdx.size())
	{
		std::vector<int> vecTmp;
		for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
		{
			vecTmp.push_back(vecModuleIdx.at(nIdx + nCount));
		}

		std::sort(vecTmp.begin(), vecTmp.end(), CompareModuleStatusY(this));

		for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
		{			
			vecModuleIdx.at(nIdx + nCount) = vecTmp.at(nCount);
		}
	}

	//pVecReviewResult->at(0).GetSReviewResult(0)->nUMOriginX;

	std::sort(pVecReviewResult->begin(), pVecReviewResult->end(), CompareReviewResultX(this));

	for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx += (int)vecHeaderIdx.size())
	{
		VectorReviewResult vecTmp;
		for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
		{
			vecTmp.push_back(pVecReviewResult->at(nIdx + nCount));
		}
		
		std::sort(vecTmp.begin(), vecTmp.end(), CompareReviewResultY(this));

		for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
		{
			pVecReviewResult->at(nIdx + nCount) = vecTmp.at(nCount);
		}
	}

	for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx++)
	{
		pVecReviewResult->at(nIdx).SetModuleIndex(vecModuleIdx.at(nIdx));
		SetModuleStatusSReviewProcessor(&pVecReviewResult->at(nIdx), vecModuleIdx.at(nIdx));
	}

	return 1;
}

int	CSequenceProcessor_CSOT::SetModuleStatusForWsiResult(VectorReviewResult* pVecWsiResult, int nModuleType)
{
	if(pVecWsiResult->size() < 2) return 0;
	int nModuleStatusCount = m_pSP2P->ISP2P_GetModuleStatusCount(nModuleType);
	std::vector<int> vecModuleIdx;
	std::vector<int> vecReviewIdx;
	std::vector<int> vecGantryIdx;
	std::vector<int> vecHeaderIdx;	

	//sortstruct CompareFcuntions(this);

	for(int nModuleIdx = 0; nModuleIdx < m_pSP2P->ISP2P_GetModuleStatusCount(); nModuleIdx++)
	{
		CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
		if(pModuleStatus == NULL) continue;
		if(pModuleStatus->GetModuleType() & nModuleType)
		{
			vecModuleIdx.push_back(nModuleIdx);
		}
	}

	// Get Gantry, Header Count
	for(int nIdx = 0; nIdx < vecModuleIdx.size(); nIdx++)
	{
		CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(vecModuleIdx.at(nIdx));
		if(pModuleStatus == NULL) continue;
		//pModuleStatus->GetGantryIndex()
		if(!IntVectorFinder(vecGantryIdx, pModuleStatus->GetGantryIndex()))
		{
			vecGantryIdx.push_back(pModuleStatus->GetGantryIndex());			
		}
		if(!IntVectorFinder(vecHeaderIdx, pModuleStatus->GetHeaderIndex()))
		{
			vecHeaderIdx.push_back(pModuleStatus->GetHeaderIndex());
		}
	}	
	// Gantry Sorting
	std::sort(vecModuleIdx.begin(), vecModuleIdx.end(), CompareModuleStatusX(this));
	//std::sort(vecModuleIdx.begin(), vecModuleIdx.end());

	// Header Sorting
	for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx += (int)vecHeaderIdx.size())
	{
		std::vector<int> vecTmp;
		for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
		{
			vecTmp.push_back(vecModuleIdx.at(nIdx + nCount));
		}

		std::sort(vecTmp.begin(), vecTmp.end(), CompareModuleStatusY(this));

		for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
		{			
			vecModuleIdx.at(nIdx + nCount) = vecTmp.at(nCount);
		}
	}

	//pVecReviewResult->at(0).GetSReviewResult(0)->nUMOriginX;

	std::sort(pVecWsiResult->begin(), pVecWsiResult->end(), CompareWsiResultX(this));

	for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx += (int)vecHeaderIdx.size())
	{
		VectorReviewResult vecTmp;
		for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
		{
			vecTmp.push_back(pVecWsiResult->at(nIdx + nCount));
		}

		std::sort(vecTmp.begin(), vecTmp.end(), CompareWsiResultY(this));

		for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
		{
			pVecWsiResult->at(nIdx + nCount) = vecTmp.at(nCount);
		}
	}

	for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx++)
	{
		pVecWsiResult->at(nIdx).SetModuleIndex(vecModuleIdx.at(nIdx));
		SetModuleStatusSWsiProcessor(&pVecWsiResult->at(nIdx), vecModuleIdx.at(nIdx));
	}

	return 1;
}

BOOL CSequenceProcessor_CSOT::CalculateReviewPathPlan(CDefectPicker* pDefectPicker, CGlassResult *pGlassResult)
{
	CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
	if (pGlassResult==NULL || pReviewScheduler==NULL || pDefectPicker==NULL) return FALSE;
	const CRsRcpReviewInfo* pRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	const CRcpSchedulingInfo* pScheduleInfo = pRcpReviewInfo->GetRcpSchedulingInfo();


	int nTotalModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount();
	int nReviewModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Review);
	int nPointCount			= pDefectPicker->GetPickingResultCount();

	// point is zero?
	if (nPointCount==0)	return TRUE;

	// get current glass pos review cameras 181030
	VectorPathData vecStartPathData;
	for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
	{
		const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
		if (pModuleStatus==NULL) continue;

		if ( (pModuleStatus->GetModuleType() & ModuleType_Review) != ModuleType_Review)
		{
			continue;
		}

		const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
		if (pMotorPosition==NULL) continue;

		SPathData ptStartPath;
		ptStartPath.nIndex = nIdx; // module index
		ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
		ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);

		if (ptStartPath.nPosX < 0) ptStartPath.nPosX = 1;
		if (ptStartPath.nPosY < 0) ptStartPath.nPosY = 1;

		if (nIdx == 1)
		{
			ptStartPath.nPosX = 925000;		// lmk test
		}

		vecStartPathData.push_back(ptStartPath);
	}
	int a = pDefectPicker->GetPickingResultCount();
	// get review point result
	VectorPathData vecPathData;
	for (int nPosIdx=0; nPosIdx<pDefectPicker->GetPickingResultCount(); nPosIdx++)
	{
		const SReviewResult *pSReviewResult = pDefectPicker->GetPickingResult(nPosIdx);
		
		if (pSReviewResult==NULL) continue;

		
		if(pSReviewResult->nStackType == 1)	continue;   // ½ºÅÃÀº ´Ù ´ÙÀ½¿¡ÇÏÁî¾Æ
		else if(pSReviewResult->nStackType == 2) continue; // 1==½ºÅà Àε¥ ¸®ºä ¾ÈÇÑ°Å 2==½ºÅÃÀε¥ ¸®ºä ÇÑ°Å 
		
		SPathData pathData(pSReviewResult->nUMOriginX, pSReviewResult->nUMOriginY, pSReviewResult->nResultIdx);
		vecPathData.push_back(pathData);
	}
	// 190405 SJB, StackPathS
	VectorPathData vecStackPathData;
	for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
	{
		const SReviewResult *pSReviewResult = pDefectPicker->GetPickingResult(nPosIdx);
		if (pSReviewResult==NULL) continue;

		if(pSReviewResult->nStackType ==0)		continue;
		

		SPathData pathData(pSReviewResult->nUMOriginX, pSReviewResult->nUMOriginY, pSReviewResult->nResultIdx);
		vecStackPathData.push_back(pathData);
	}
	
	BOOL bUseShortest = TRUE;

	if (pRcpReviewInfo)
	{
		
		if (pScheduleInfo)
			bUseShortest = pScheduleInfo->GetShortestPath();
	}
	
	// calculate path
	int nSchedulingCount = 0;

	// 190405 SJB, Double PathScheduling
	if(int(vecStackPathData.size()) != 0 && int(vecPathData.size()) == 0)		nSchedulingCount = pReviewScheduler->PathScheduling(vecStackPathData, vecStartPathData);
	else if(int(vecStackPathData.size()) != 0 && int(vecPathData.size()) !=0)	nSchedulingCount = pReviewScheduler->PathScheduling(vecPathData, vecStackPathData, vecStartPathData);
	else																		nSchedulingCount = pReviewScheduler->PathScheduling(vecPathData, vecStartPathData);


	if (nSchedulingCount>0)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[ReviewScheduler] CalculatePath"));

		for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
		{
			CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
			if (pScheduleResult==NULL) continue;			

			// add review result
			pGlassResult->AddReviewResult(CReviewResult(nModuleIdx));

			// get review result
			CReviewResult *pReviewResult = pGlassResult->GetReviewResult(nModuleIdx);
			if(pReviewResult == NULL) return FALSE;

			// get sreview result
			ReviewScheduler_ResizeReviewResult(pScheduleResult, pReviewResult, pDefectPicker, pScheduleResult->GetPathSchedulerResultCount());

			// add review schedule result
			pGlassResult->AddReviewScheduleResult(*pScheduleResult);

			CakAOISharedSystem* pAOIShared = CReviewInterface::GetInstance(); //20191017
			pProtocolData =pAOIShared->getReviewProtocol();
				
			pProtocolData->SetPlanDefectNum(nModuleIdx,pScheduleResult->GetPathSchedulerResultCount());
			SSchedulerResult *pNode;
			for (int i=0;i<pScheduleResult->GetPathSchedulerResultCount();i++)
			{
				pNode = pScheduleResult->GetPathSchedulerResult(i);
				pProtocolData->SetPlanReviewPos(nModuleIdx,i,int(pNode->dPositionX*1000), int(pNode->dPositionY*1000));
			}
			
// 			CString strFilename = _T("");
// 			strFilename.Format(_T("c:\\%d_module_review_path.csv"), nModuleIdx);
// 			CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
		}
	}	
	else
	{
		return FALSE;
	}
	
	return TRUE;
}

BOOL CSequenceProcessor_CSOT::CalculateUserPathPlan(CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult)
{
	CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
	if (pGlassResult==NULL || pReviewScheduler==NULL || pPrioritySorter==NULL) return FALSE;

	int nTotalModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount();
	int nReviewModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Review);
	int nPointCount			=  pPrioritySorter->GetSortingResultUserCount();

	// point is zero?
	if (nPointCount==0)	return TRUE;

	// get current glass pos review cameras
	VectorPathData vecStartPathData;
	for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
	{
		const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
		if (pModuleStatus==NULL) continue;

		if ( (pModuleStatus->GetModuleType() & ModuleType_Review) != ModuleType_Review)
		{
			continue;
		}

		const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
		if (pMotorPosition==NULL) continue;

		SPathData ptStartPath;
		ptStartPath.nIndex = nIdx; // module index
		ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
		ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);
		vecStartPathData.push_back(ptStartPath);
	}

	const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();

	int nMachine   = pSystemInfo->m_nMachineType;
	
	
	const CModuleStatus *pModuleStatus = Module_GetModuleStatus(0);
	const SCameraControl *pCameraControl = pModuleStatus->GetCameraControl();
	const SMagnificInfo *pModuleMag      = pModuleStatus->GetMagnificInfo(pCameraControl->nZoomLevel);
	
	int nPositionX;
	int nPositionY;
	// get user point result
	VectorPathData vecPathData;
	for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
	{
		const SReviewResult *pSReviewResult = pPrioritySorter->GetSortingResultUser(nPosIdx);
		if (pSReviewResult==NULL) continue;

		nPositionX =  pSReviewResult->nUMOriginX;
		nPositionY =  pSReviewResult->nUMOriginY;
	
		SPathData pathData( nPositionX,nPositionY,pSReviewResult->nResultIdx);
		vecPathData.push_back(pathData);
	}

	// calculate shortest path
	if (pReviewScheduler->PathScheduling(vecPathData, vecStartPathData)>0)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[ReviewScheduler] CalculatePath"));

		for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
		{
			CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
			if (pScheduleResult==NULL) continue;			

			// add user result
			pGlassResult->AddUserResult(CReviewResult(nModuleIdx));

			// get user result
			CReviewResult *pReviewResult = pGlassResult->GetUserResult(nModuleIdx);
			if(pReviewResult == NULL) return FALSE;

			// get sreviewresult
			ReviewScheduler_ResizeUserResult(pScheduleResult, pReviewResult, pPrioritySorter, pScheduleResult->GetPathSchedulerResultCount());

			// add user schedule result
			pGlassResult->AddUserScheduleResult(*pScheduleResult);
			
			//°øÀ¯¸Þ¸ð¸®¿¡ ä¿öÁÙ ¸®ºäÇÒ °¹¼ö¿Í µðÆå ÁÂÇ¥¸¦ ±¸Á¶Ã¼¿¡ ä¿öÁÖ´Â Àå¼Ò  
			{


				CakAOISharedSystem* pAOIShared = CReviewInterface::GetInstance(); //20191017
				pProtocolData =pAOIShared->getReviewProtocol();

				int nStIndex = pProtocolData->m_ModuleData[nModuleIdx].m_nPlanDefectCount;
				pProtocolData->m_ModuleData[nModuleIdx].m_nPlanDefectCount += pScheduleResult->GetPathSchedulerResultCount();
				SSchedulerResult *pNode;
				for (int i=0;i<pScheduleResult->GetPathSchedulerResultCount();i++)
				{
					pNode = pScheduleResult->GetPathSchedulerResult(i);
					pProtocolData->SetPlanReviewPos(nModuleIdx,nStIndex+i, int(pNode->dPositionX*1000), int(pNode->dPositionY*1000));
				}
			}

// 			CString strFilename = _T("");
// 			strFilename.Format(_T("c:\\%d_module_user_path.csv"), nModuleIdx);
// 			CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
		}
	}	
	else
	{
		return FALSE;
	}

	return TRUE;
}

BOOL CSequenceProcessor_CSOT::CalculateWsiPathPlan(CDefectPicker* pDefectPicker, CGlassResult *pGlassResult)
{
	CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
	if (pGlassResult==NULL || pReviewScheduler==NULL || pDefectPicker==NULL) return FALSE;

	int nTotalModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount();
	int nReviewModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Wsi);
	int nPointCount			=  pDefectPicker->GetPickingResultWsiCount();

	// point is zero?
	if (nPointCount==0)	return TRUE;

	// get current glass pos review cameras
	VectorPathData vecStartPathData;
	for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
	{
		const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
		if (pModuleStatus==NULL) continue;

		if ( (pModuleStatus->GetModuleType() & ModuleType_Wsi) != ModuleType_Wsi)
		{
			continue;
		}

		const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
		if (pMotorPosition==NULL) continue;

		SPathData ptStartPath;
		ptStartPath.nIndex = nIdx; // module index
		ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
		ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);
		vecStartPathData.push_back(ptStartPath);
	}

	// get wsi point result
	VectorPathData vecPathData;
	for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
	{
		const SReviewResult *pSWsiResult = pDefectPicker->GetPickingResultWsi(nPosIdx);
		if (pSWsiResult==NULL) continue;

		if(pSWsiResult->nStackType == 1)	continue;   // ½ºÅÃÀº ´Ù ´ÙÀ½¿¡ÇÏÁî¾Æ
		else if(pSWsiResult->nStackType == 2) continue; // 1==½ºÅà Àε¥ ¸®ºä ¾ÈÇÑ°Å 2==½ºÅÃÀε¥ ¸®ºä ÇÑ°Å 

		SPathData pathData(pSWsiResult->nUMOriginX, pSWsiResult->nUMOriginY, pSWsiResult->nResultIdx);
		vecPathData.push_back(pathData);
	}

	VectorPathData vecStackPathData;;
	for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
	{
		const SReviewResult *pSWsiResult = pDefectPicker->GetPickingResultWsi(nPosIdx);
		if (pSWsiResult==NULL) continue;
		
		if(pSWsiResult->nStackType ==0)		continue;
		

		SPathData pathData(pSWsiResult->nUMOriginX, pSWsiResult->nUMOriginY, pSWsiResult->nResultIdx);
		vecStackPathData.push_back(pathData);
	}

	// calculate path
	int nSchedulingCount = 0;

	// 190405 SJB, Double PathScheduling
	if(int(vecStackPathData.size()) != 0 && int(vecPathData.size()) == 0)		nSchedulingCount = pReviewScheduler->PathScheduling(vecStackPathData, vecStartPathData);
	else if(int(vecStackPathData.size()) != 0 && int(vecPathData.size()) !=0)	nSchedulingCount = pReviewScheduler->PathScheduling(vecPathData, vecStackPathData, vecStartPathData);
	else																		nSchedulingCount = pReviewScheduler->PathScheduling(vecPathData, vecStartPathData);
	

		if (nSchedulingCount>0)
		{
		for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
		{
			CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
			if (pScheduleResult==NULL) continue;			

			// add wsi result
			pGlassResult->AddWsiResult(CReviewResult(nModuleIdx));

			// get wsi result
			CReviewResult *pWsiResult = pGlassResult->GetWsiResult(nModuleIdx);
			if(pWsiResult == NULL) return FALSE;
			
			// get swsiresult
			ReviewScheduler_ResizeWsiResult(pScheduleResult, pWsiResult, pDefectPicker, pScheduleResult->GetPathSchedulerResultCount());

			// add wsi schedule result
			pGlassResult->AddWsiScheduleResult(*pScheduleResult);

// 			CString strFilename = _T("");
// 			strFilename.Format(_T("c:\\%d_module_wsi_path.csv"), nModuleIdx);
// 			CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
		}
		}	
		else
		{
			return FALSE;
		}

	return TRUE;
}
BOOL CSequenceProcessor_CSOT::CalculateReflowPathPlan( CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult )
{
	CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
	if (pGlassResult==NULL || pReviewScheduler==NULL || pPrioritySorter==NULL) return FALSE;

	int nTotalModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount();
	int nReviewModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Review);
	int nPointCount			=  pPrioritySorter->GetSortingResultReflowCount();

	// point is zero?
	if (nPointCount==0)	return TRUE;

	CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo == NULL)
	{
		return -1;
	}

	// get current glass pos review cameras
	VectorPathData vecStartPathData;
	for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
	{
		const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
		if (pModuleStatus==NULL) continue;

		if ( (pModuleStatus->GetModuleType() & ModuleType_Review) != ModuleType_Review)
		{
			continue;
		}

		const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
		if (pMotorPosition==NULL) continue;

		SPathData ptStartPath;
		ptStartPath.nIndex = nIdx; // module index
		ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
		ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);
		vecStartPathData.push_back(ptStartPath);
	}

	// get user point result
	VectorPathData vecPathData;
	for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
	{
		const SReviewResult *pSReviewResult = pPrioritySorter->GetSortingResultReflow(nPosIdx);
		if (pSReviewResult==NULL) continue;

		SPathData pathData(pSReviewResult->nUMOriginX, pSReviewResult->nUMOriginY, pSReviewResult->nResultIdx);
		vecPathData.push_back(pathData);
	}

	// calculate shortest path
	if (pReviewScheduler->PathScheduling(vecPathData, vecStartPathData)>0)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[ReviewScheduler] CalculatePath"));

		for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
		{
			CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
			if (pScheduleResult==NULL) continue;			

			// add reflow result
			pGlassResult->AddReflowResult(CReviewResult(nModuleIdx));

			// get user result
			CReviewResult *pReviewResult = pGlassResult->GetReflowResult(nModuleIdx);
			if(pReviewResult == NULL) return FALSE;

			// get sreview result
			ReviewScheduler_ResizeReflowResult(pScheduleResult, pReviewResult, pPrioritySorter, pScheduleResult->GetPathSchedulerResultCount());

			// add user schedule result
			pGlassResult->AddReflowScheduleRedult(*pScheduleResult);

// 			CString strFilename = _T("");
// 			strFilename.Format(_T("c:\\%d_module_reflow_path.csv"), nModuleIdx);
// 			CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
		}
	}	
	else
	{
		return FALSE;
	}

	return TRUE;
}
void CSequenceProcessor_CSOT::GetAxisDirection(int nOrgGlass, int nOrgRecipe, int &nDirX, int& nDirY)
{
	nDirX = 1; // same dir
	if ( (nOrgGlass==GlassOriginDir_LeftTop || nOrgGlass==GlassOriginDir_LeftBottom) && (nOrgRecipe==GlassOriginDir_LeftTop || nOrgRecipe==GlassOriginDir_LeftBottom) )
	{
		nDirX = 1;
	}
	else if ( (nOrgGlass==GlassOriginDir_RightTop || nOrgGlass==GlassOriginDir_RightBottom) && (nOrgRecipe==GlassOriginDir_RightTop || nOrgRecipe==GlassOriginDir_RightBottom) )
	{
		nDirX = 1;
	}
	else
	{
		nDirX = -1;
	}

	nDirY = 1; // same dir
	if ( (nOrgGlass==GlassOriginDir_LeftTop || nOrgGlass==GlassOriginDir_RightTop) && (nOrgRecipe==GlassOriginDir_LeftTop || nOrgRecipe==GlassOriginDir_RightTop) )
	{
		nDirY = 1;
	}
	else if ( (nOrgGlass==GlassOriginDir_LeftBottom || nOrgGlass==GlassOriginDir_RightBottom) && (nOrgRecipe==GlassOriginDir_LeftBottom || nOrgRecipe==GlassOriginDir_RightBottom) )
	{
		nDirY = 1;
	}
	else
	{
		nDirY = -1;
	}
}

void CSequenceProcessor_CSOT::GetMeasureModuleIndex(int nDirX, int nDirY, int& nModuleIdx)
{
	if (nDirX==-1 && nDirY==-1)
	{
		switch(nModuleIdx)
		{
		case 0:
			nModuleIdx = 3;
			break;
		case 1:
			nModuleIdx = 2;
			break;
		case 2:
			nModuleIdx = 1;
			break;
		case 3:
			nModuleIdx = 0;
			break;
		}
	}
	else if (nDirX==-1)
	{
		switch(nModuleIdx)
		{
		case 0:
			nModuleIdx = 2;
			break;
		case 1:
			nModuleIdx = 3;
			break;
		case 2:
			nModuleIdx = 0;
			break;
		case 3:
			nModuleIdx = 1;
			break;
		}
	}
	else if (nDirY==-1)
	{
		switch(nModuleIdx)
		{
		case 0:
			nModuleIdx = 1;
			break;
		case 1:
			nModuleIdx = 0;
			break;
		case 2:
			nModuleIdx = 3;
			break;
		case 3:
			nModuleIdx = 2;
			break;
		}
	}
}

BOOL CSequenceProcessor_CSOT::CalculateMeasurePathPlan(CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult)
{
//	CMeasureScheduler *pMeasureScheduler	= m_pSP2P->ISP2P_GetMeasureScheduler();
	CRsRcpMeasureInfo* pRsRcpMeasureInfo	= m_pSP2P->ISP2P_Recipe_GetRsRcpMeasureInfo();

	if (pGlassResult==NULL || pPrioritySorter==NULL || pRsRcpMeasureInfo==NULL) return FALSE;

	int nPointCount	=  pPrioritySorter->GetSortingResultMeasureCount();
	if (nPointCount<1) return TRUE;

	// add measure result
	int nSystemModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Measure);
	int nRecipeModuleCount	= pRsRcpMeasureInfo->GetModuleCount();
	int nResultCount		= pRsRcpMeasureInfo->GetResultCount();
	
	if (nSystemModuleCount!=nRecipeModuleCount) return FALSE;

	// add measure result to glass result
	for (int nModuleIdx=0; nModuleIdx<nRecipeModuleCount; nModuleIdx++)
	{
		pGlassResult->AddMeasureResult(CReviewResult(nModuleIdx));

		CReviewResult *pReviewResult = pGlassResult->GetMeasureResult(nModuleIdx);

		pReviewResult->ResizeReviewResult(nResultCount);
	}
	
	// add measure point to measure result
	int nGlassDir = pGlassResult->GetOriginDir();
	int nRecipeDir = pRsRcpMeasureInfo->GetGlassOriginDir();

	int nAxisXDir = 1;
	int nAxisYDir = 1;
	GetAxisDirection(nGlassDir, nRecipeDir, nAxisXDir, nAxisYDir);

	for (int nPointIdx=0; nPointIdx<nPointCount; nPointIdx++)
	{
		SReviewResult *pSourceResult = pPrioritySorter->GetSortingResultMeasure(nPointIdx);
		if (pSourceResult==NULL) continue;

		int nModuleIdx = pSourceResult->nModuleIdx;

		// change module index from axis direction
		GetMeasureModuleIndex(nAxisXDir, nAxisYDir, nModuleIdx);

		SReviewResult *pTargetResult =  pGlassResult->GetSMeasureResult(nModuleIdx, pSourceResult->nResultIdx);
		if (pTargetResult==NULL) continue;

		// copy
		*pTargetResult = *pSourceResult;

		// add recipe info
		CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
		if (pModuleStatus==NULL) continue;

		// get zoom info
		int nZoomIdx = GetRealMagnification(nModuleIdx, pTargetResult->nZoomIdx);
		SMagnificInfo *pMagnificInfo	= pModuleStatus->GetMagnificInfo(nZoomIdx);
		SCameraInfo *pCameraInfo		= pModuleStatus->GetCameraInfo(0);
		if (pMagnificInfo==NULL || pCameraInfo==NULL) continue;

		// set info
		pTargetResult->nZoomIdx				= nZoomIdx;
		pTargetResult->dMagnification		= pMagnificInfo->dMagnification;
		pTargetResult->dMeasureResolution	= pCameraInfo->dResolution / pTargetResult->dMagnification;
		pTargetResult->bDigitalZoom			= FALSE;
	}

	return TRUE;
}

BOOL CSequenceProcessor_CSOT::MotorMotionEnd()
{
	BOOL bMotionEnd = FALSE;

	const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
	if(pMotorInfo == NULL) return FALSE;

	CMotorControl* pMotorControl = m_pSP2P->ISP2P_GetMotorControl();	
	if(pMotorControl == NULL) return FALSE;

	while(!bMotionEnd)
	{
		int nGantryCount = pMotorInfo->GetMotorGantryAddrCount();
		bMotionEnd = TRUE;
		for(int nGantryIdx = 0; nGantryIdx < nGantryCount; nGantryIdx++)
		{
			const CMotorGantryAddr* pMotorGantryAddr = pMotorInfo->GetMotorGantryAddr(nGantryIdx);
			if(pMotorGantryAddr == NULL) continue ;
			int nAxisCount = pMotorGantryAddr->GetMotorAxisAddrCount();
			for(int nAxisIdx = 0; nAxisIdx < nAxisCount; nAxisIdx++)
			{
				const CMotorAxisAddr* pMotorAxisAddr = pMotorGantryAddr->GetMotorAxisAddr(nAxisIdx);
				if(pMotorAxisAddr == NULL) continue ;
				int nCheckAddrass = pMotorAxisAddr->m_nStatusAddr;
				long data = 0;
				pMotorControl->ReadAddressValue(nCheckAddrass, data);
				bMotionEnd = 1 & data;
				if(!bMotionEnd) break;
			}
			if(!bMotionEnd) break;
		}		
	}

	g_pLog->DisplayMessage(_T("[Motor] Motion End!!"));
	return TRUE;
}

BOOL CSequenceProcessor_CSOT::AllChangeMagnification(int nZoomIdx, int nCmd, int nPlanMode)
{
	CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult == NULL) return FALSE;

	CRsRcpReviewInfo* pRsRcpReviewInfo = NULL;
	CRsRcpMeasureInfo* pRsRcpMeasureInfo = NULL;
	switch(nPlanMode)
	{
	case CSOT_PlanReview:
	case CSOT_PlanUser:
	case CSOT_PlanWSI:
		pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
		break;
       case CSOT_PlanReflow:
                pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
		break;
	case CSOT_PlanMeasure:
		pRsRcpMeasureInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpMeasureInfo();
		break;
	}

	if (nPlanMode!=CSOT_PlanMeasure && pRsRcpReviewInfo==NULL) return FALSE;
	if (nPlanMode==CSOT_PlanMeasure && pRsRcpMeasureInfo==NULL) return FALSE;

	int nModuleStatusCount = m_pSP2P->ISP2P_GetModuleStatusCount();
	for(int nModuleIdx = 0; nModuleIdx < nModuleStatusCount; nModuleIdx++)
	{
		int nZoomIndex = -1;
		switch(nPlanMode)
		{
		case CSOT_PlanReview:
			{
				const CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
				if(pRcpAFMRecipeInfo == NULL)
				{
					g_pLog->DisplayMessage(_T("[AllChangeMagnification] pRcpAFMRecipeInfo NULL Error !!"));
				}
				nZoomIndex = pRcpAFMRecipeInfo->GetZoomIndex();
				break;
			}

		case CSOT_PlanUser:
			{
				const CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpUserAFMRecipeInfo(nModuleIdx);
				if(pRcpAFMRecipeInfo == NULL)
				{
					g_pLog->DisplayMessage(_T("[AllChangeMagnification] pRcpAFMRecipeInfo NULL Error !!"));
				}
				nZoomIndex = pRcpAFMRecipeInfo->GetZoomIndex();
				break;
			}

		case CSOT_PlanWSI:
			{
				const CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpWsiAFMRecipeInfo(nModuleIdx);
				if(pRcpAFMRecipeInfo == NULL)
				{
					g_pLog->DisplayMessage(_T("[AllChangeMagnification] pRcpAFMRecipeInfo NULL Error !!"));
				}
				else
				{
				nZoomIndex = pRcpAFMRecipeInfo->GetZoomIndex();
				}				
				break;
			}
			break;
		// ¹Ì»ç¿ë
		case CSOT_PlanMeasure:
			{
				const CRcpMeasureInfo *pRcpMeasureInfo = pRsRcpMeasureInfo->GetRcpMeasureInfo(0);
				if(pRcpMeasureInfo == NULL)
				{
					g_pLog->DisplayMessage(_T("[AllChangeMagnification] pRcpAFMRecipeInfo NULL Error !!"));
				}

				if (pRsRcpMeasureInfo)
				{
					nZoomIndex = pRcpMeasureInfo->GetMagnificationIdx();
				}
				break;
			}

		case CSOT_PlanReflow:
			{
				const CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpUserAFMRecipeInfo(nModuleIdx);
				if(pRcpAFMRecipeInfo == NULL)
				{
					g_pLog->DisplayMessage(_T("[AllChangeMagnification] pRcpAFMRecipeInfo NULL Error !!"));
				}
				nZoomIndex = pRcpAFMRecipeInfo->GetZoomIndex();
				break;
			}
		}

		int nRealMagIndex = -1;
		if(nCmd == ZoomLevel_Auto_CSOT)
		{
			nRealMagIndex = GetRealMagnification(nModuleIdx, nZoomIndex);	
		}
		else
		{
			nRealMagIndex = nZoomIdx;
		}
		
		Revolver_SetRevolverLevel(nModuleIdx, nRealMagIndex);

		CString strRecipeName = *pGlassResult->GetPPID();

		AFM_SetAFMRecipeName(nModuleIdx, strRecipeName, nRealMagIndex);
	}

	return TRUE;
}

BOOL CSequenceProcessor_CSOT::SetDelayTimeToMotor()
{	
	const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
	
	if(pMotorInfo == NULL) return FALSE;

	CMotorControl* pMotorControl = m_pSP2P->ISP2P_GetMotorControl();	
	if(pMotorControl == NULL) return FALSE;

	if(!pMotorControl->WriteAddressValue(pMotorInfo->GetMotorCommonAddr()->m_nWsiDelayTimeAddr, (long)pMotorInfo->GetWsiDelayTime()))
	{
		return FALSE;
	}

	if(pMotorControl->WriteAddressValue(pMotorInfo->GetMotorCommonAddr()->m_nAfDelayTimeAddr, (long)pMotorInfo->GetAfDelayTime()))
	{
		return FALSE;
	}

	if(!pMotorControl->WriteAddressValue(pMotorInfo->GetMotorCommonAddr()->m_nImageDelayTimeAddr, (long)pMotorInfo->GetImageDelayTime()))
	{
		return FALSE;
	}
	return TRUE;
}

int CSequenceProcessor_CSOT::GetDirectionX(int nGlassDirection, int nMotorDirection)
{
	if(nGlassDirection == GlassOriginDir_LeftTop || nGlassDirection == GlassOriginDir_LeftBottom)
	{
		if(nMotorDirection == MotorOriginDir_LeftTop || nMotorDirection == MotorOriginDir_LeftBottom)
		{
			return COORDINATE_DIRECTION_FORWARD;
		}
		else
		{
			return COORDINATE_DIRECTION_BACKWARD;
		}
	}

	if(nGlassDirection == GlassOriginDir_RightTop || nGlassDirection == GlassOriginDir_RightBottom)
	{
		if(nMotorDirection == MotorOriginDir_RightTop || nMotorDirection == MotorOriginDir_RightBottom)
		{
			return COORDINATE_DIRECTION_FORWARD;
		}
		else
		{
			return COORDINATE_DIRECTION_BACKWARD;
		}
	}

	return COORDINATE_DIRECTION_BACKWARD;
}

int CSequenceProcessor_CSOT::GetDirectionY(int nGlassDirection, int nMotorDirection)
{
	if(nGlassDirection == GlassOriginDir_LeftTop || nGlassDirection == GlassOriginDir_RightTop)
	{
		if(nMotorDirection == MotorOriginDir_LeftTop || nMotorDirection == MotorOriginDir_RightTop)
		{
			return COORDINATE_DIRECTION_FORWARD;
		}
		else
		{
			return COORDINATE_DIRECTION_BACKWARD;
		}
	}

	if(nGlassDirection == GlassOriginDir_LeftBottom || nGlassDirection == GlassOriginDir_RightBottom)
	{
		if(nMotorDirection == MotorOriginDir_LeftBottom || nMotorDirection == MotorOriginDir_RightBottom)
		{
			return COORDINATE_DIRECTION_FORWARD;
		}
		else
		{
			return COORDINATE_DIRECTION_BACKWARD;
		}
	}

	return COORDINATE_DIRECTION_BACKWARD;
}

//CIM DV Data
BOOL CSequenceProcessor_CSOT::SendDVDataToSignalControl() // ¼öÁ¤
{
	CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if (pGlassResult==NULL) return FALSE;

	CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
	if (pSignalControl==NULL) return FALSE;
	if (pSignalControl->IsConnected() == FALSE) return FALSE;

	const CSignalControlInfo* pSignalInfo = m_pSP2P->ISP2P_System_GetPCControlInfo();
	if (pSignalInfo==NULL)	return FALSE;

	const CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo==NULL) return FALSE;

	char DVData[5000]={};
	int nSize = MakeDVData(pGlassResult, DVData);

	//pSignalControl->WritePacketData(_T("15100"), nSize, (short*)&DVData);
	g_pLog->DisplayMessage(_T("[SequenceProcessor] DVData writing succeeded. Addr: %s, size: %d"), PC_ADDR_DCOLL_DATA, nSize);

	return TRUE;
}


int CSequenceProcessor_CSOT::MakeDVData(CGlassResult *pGlassResult, char* pDVData, int nIndex) // ¼öÁ¤
{
	g_pLog->DisplayMessage(_T("[SequenceProcessor] SendDVDataToSignalControl->MakeDVData IN."));

	if (pGlassResult==NULL) return FALSE;

	const CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo==NULL) return FALSE;

	// Review Á¶¸í Á¤º¸
	const CRcpLightInfo *pReviewLightInfo = pRsRcpReviewInfo->GetRcpLightInfo(nIndex);
	// Review AFM Á¤º¸
	const CRcpAFMRecipeInfo *pReviewAFMInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nIndex);
	// Review Align Info
	const CAlignResult*	pAlignResult = pGlassResult->GetAlignResult();
	// Review Defect Info
	const CReviewResult* pReviewResult = pGlassResult->GetReviewResult(nIndex);

	// Review ¹èÀ² Á¤º¸
	const CModuleStatus* pModuleStatus = Module_GetModuleStatus(nIndex);		
	const SMagnificInfo* pSMagnificInfo = pModuleStatus->GetMagnificInfo(pReviewAFMInfo->GetZoomIndex());
	CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
	if (pSignalControl==NULL) return FALSE;
	if (pSignalControl->IsConnected() == FALSE) return FALSE;
	const SReviewResult* pSReviewResult = pGlassResult->GetSReviewResult(nIndex, 0);

	//int nReviewResultCount = min(_countof(DVDataPack.reviewDefectData), pGlassResult->GetSReviewResultCount(nIndex));
	//int nReviewResultCount = pGlassResult->GetSReviewResultCount(nIndex);
	//int nWSIResultCount = pGlassResult->GetSWsiResultCount(nIndex);
	int nEqpID = m_pSP2P->ISP2P_System_GetSystemInfo()->m_nMachineType;
	int nReviewResultCount = 0;
	int nWSIResultCount = 0;
	int offset=0;
	int nSize = 0;
	int nWritePacketDataLimitPlag=0;

	//////////////////////////////////////////////////////////////////////////
	// Write DVData Packet
	//_DVDataPack_B7_8ver DVDataPack;
	//**Review
	//INLINE  : 10°³ 
	//TFE-OFF : 20°³ 
	//Hcut : 50°³ 
	//LAMI : 5°³ 
	//**WSI
	//10°³ °íÁ¤ 
	///////////////////////////////////////////////////////////////////////////



	_DVDataPack_B7_8ver DVDataPack;
	_DVDataPack_Hcut DVDataPackhcut;
	_DVDataPack_TFEOFF DVDataPacktfeoff;


	char DVData[10000]={};

	if(nEqpID==0){//Crack
		nReviewResultCount=10;
		nSize = 1500;
		nWritePacketDataLimitPlag=1;
		memset(&DVDataPack, 0, sizeof(DVDataPack));
	}
	else if(nEqpID==1){//ijp
		nReviewResultCount= 10;
		nSize = 1500;
		nWritePacketDataLimitPlag=1;
		memset(&DVDataPack, 0, sizeof(DVDataPack));
	}
	else if(nEqpID ==2){ //TFE_IN
		nReviewResultCount=10;
		nWSIResultCount=10;
		memset(&DVDataPack, 0, sizeof(DVDataPack));
	}
	else if(nEqpID==3){//lami
		nReviewResultCount= 5;
		nSize = 1500;
		nWritePacketDataLimitPlag=1;
		memset(&DVDataPack, 0, sizeof(DVDataPack));
	}
	else if(nEqpID == 4){ //hcut
		nReviewResultCount= 50;
		memset(&DVDataPackhcut, 0, sizeof(DVDataPackhcut));

	}
	else if(nEqpID==5){//TfeOff
		nReviewResultCount= 20;
		nWSIResultCount=10;
		memset(&DVDataPacktfeoff, 0, sizeof(DVDataPacktfeoff));
	}


	if(nEqpID == 4)
	{
		for (int i=0; i<nReviewResultCount; i++)
		{

			const SReviewResult* pSReviewResult = pGlassResult->GetSReviewResult(nIndex, i);
			if (NULL == pSReviewResult) continue;

			DVDataPackhcut.reviewDefectData[i].PositionX = (int)pSReviewResult->dUMCenterOriginX;				// mm
			DVDataPackhcut.reviewDefectData[i].PositionY = (int)pSReviewResult->dUMCenterOriginY;				// mm

			for(int j=0; j<pSReviewResult->strDefectType.GetLength();j++){
				if(pSReviewResult->strDefectType.GetAt(j)==NULL){break;}
				DVDataPackhcut.reviewDefectData[i].defectType[j]= pSReviewResult->strDefectType.GetAt(j);
			}

			DVDataPackhcut.reviewDefectData[i].judgeCode = pSReviewResult->nSizeType;						    // ??
			DVDataPackhcut.reviewDefectData[i].sizeRScale = pSReviewResult->nAOISizeLength*1000;				// um
		}

		for( int j=0; j<_countof(DVDataPackhcut.reviewDefectData); j++ )
		{
			if( strcmp( DVDataPackhcut.reviewDefectData[j].defectType, "") == 0 )
				strcpy( DVDataPackhcut.reviewDefectData[j].defectType, " " );
		}

		for (int i=0; i<nWSIResultCount; i++)
		{
			const SReviewResult* pSWsiResult = pGlassResult->GetSWsiResult(nIndex, i);
			if (NULL == pSWsiResult) continue;

			// 8.2.WSI_MEASURE_Ruslut
			DVDataPackhcut.wsiDefectData[i].measureResult = pSWsiResult->nWsi_ResultCode;		// ¼º°ø / ½ÇÆÐ
			// 8.3.WSI_MEASURE_TYPE
			DVDataPackhcut.wsiDefectData[i].measureType = pSWsiResult->nWsi_Type;				// µ¹Ãâ / ÇÔ¸ô
			// 8.4.WSI_DEFECT_MEASURE_HEIGHT
			DVDataPackhcut.wsiDefectData[i].measureHeight = int(pSWsiResult->pWsi_ResultData[0]*1000);		// um
			// 8.5.WSI_DEFECT_MEASURE_WIDTH_X
			DVDataPackhcut.wsiDefectData[i].measureWidthX = int(pSWsiResult->pWsi_ResultData[1]*1000);		// um
			// 8.6.WSI_DEFECT_MEASURE_WIDTH_Y
			DVDataPackhcut.wsiDefectData[i].measureWidthY = int(pSWsiResult->pWsi_ResultData[2]*1000);		// um
			// 8.7.WSI_DEFECT_MEASURE_RATION
		}

		memcpy(DVData,&DVDataPackhcut,sizeof(DVDataPackhcut));

		pSignalControl->WritePacketData(_T("15100"), sizeof(DVDataPackhcut), (short*)&DVData);
	}
	else if (nEqpID == 5){
		for (int i=0; i<nReviewResultCount; i++)
		{

			const SReviewResult* pSReviewResult = pGlassResult->GetSReviewResult(nIndex, i);
			if (NULL == pSReviewResult) continue;

			DVDataPacktfeoff.reviewDefectData[i].PositionX = (int)pSReviewResult->dUMCenterOriginX;				// mm
			DVDataPacktfeoff.reviewDefectData[i].PositionY = (int)pSReviewResult->dUMCenterOriginY;				// mm

			for(int j=0; j<pSReviewResult->strDefectType.GetLength();j++){
				if(pSReviewResult->strDefectType.GetAt(j)==NULL){break;}
				DVDataPacktfeoff.reviewDefectData[i].defectType[j]= pSReviewResult->strDefectType.GetAt(j);
			}

			DVDataPacktfeoff.reviewDefectData[i].judgeCode = pSReviewResult->nSizeType;						    // ??
			DVDataPacktfeoff.reviewDefectData[i].sizeRScale = pSReviewResult->nAOISizeLength*1000;				// um
		}

		for( int j=0; j<_countof(DVDataPacktfeoff.reviewDefectData); j++ )
		{
			if( strcmp( DVDataPacktfeoff.reviewDefectData[j].defectType, "") == 0 )
				strcpy( DVDataPacktfeoff.reviewDefectData[j].defectType, " " );
		}

		for (int i=0; i<nWSIResultCount; i++)
		{
			const SReviewResult* pSWsiResult = pGlassResult->GetSWsiResult(nIndex, i);
			if (NULL == pSWsiResult) continue;

			// 8.2.WSI_MEASURE_Ruslut
			DVDataPacktfeoff.wsiDefectData[i].measureResult = pSWsiResult->nWsi_ResultCode;		// ¼º°ø / ½ÇÆÐ
			// 8.3.WSI_MEASURE_TYPE
			DVDataPacktfeoff.wsiDefectData[i].measureType = pSWsiResult->nWsi_Type;				// µ¹Ãâ / ÇÔ¸ô
			// 8.4.WSI_DEFECT_MEASURE_HEIGHT
			DVDataPacktfeoff.wsiDefectData[i].measureHeight = int(pSWsiResult->pWsi_ResultData[0]*1000);		// um
			// 8.5.WSI_DEFECT_MEASURE_WIDTH_X
			DVDataPacktfeoff.wsiDefectData[i].measureWidthX = int(pSWsiResult->pWsi_ResultData[1]*1000);		// um
			// 8.6.WSI_DEFECT_MEASURE_WIDTH_Y
			DVDataPacktfeoff.wsiDefectData[i].measureWidthY = int(pSWsiResult->pWsi_ResultData[2]*1000);		// um
			// 8.7.WSI_DEFECT_MEASURE_RATION
		}

		memcpy(DVData,&DVDataPacktfeoff,sizeof(DVDataPacktfeoff));

		pSignalControl->WritePacketData(_T("15100"), sizeof(DVDataPacktfeoff), (short*)&DVData);
	}
	else
	{
		for (int i=0; i<nReviewResultCount; i++)
		{

			const SReviewResult* pSReviewResult = pGlassResult->GetSReviewResult(nIndex, i);
			if (NULL == pSReviewResult) continue;

			DVDataPack.reviewDefectData[i].PositionX = (int)pSReviewResult->dUMCenterOriginX;				// mm
			DVDataPack.reviewDefectData[i].PositionY = (int)pSReviewResult->dUMCenterOriginY;				// mm

			for(int j=0; j<pSReviewResult->strDefectType.GetLength();j++){
				if(pSReviewResult->strDefectType.GetAt(j)==NULL){break;}
				DVDataPack.reviewDefectData[i].defectType[j]= pSReviewResult->strDefectType.GetAt(j);
			}

			DVDataPack.reviewDefectData[i].judgeCode = pSReviewResult->nSizeType;						    // ??
			DVDataPack.reviewDefectData[i].sizeRScale = pSReviewResult->nAOISizeLength*1000;				// um
		}

		for( int j=0; j<nReviewResultCount; j++ )
		{
			const SReviewResult* pSReviewResult = pGlassResult->GetSReviewResult(nIndex, j);
			if (NULL == pSReviewResult) continue;

			if( strcmp( DVDataPack.reviewDefectData[j].defectType, "") == 0 )
				strcpy( DVDataPack.reviewDefectData[j].defectType, " " );
		}

		for (int i=0; i<nWSIResultCount; i++)
		{
			const SReviewResult* pSWsiResult = pGlassResult->GetSWsiResult(nIndex, i);
			if (NULL == pSWsiResult) continue;

			// 8.2.WSI_MEASURE_Ruslut
			DVDataPack.wsiDefectData[i].measureResult = pSWsiResult->nWsi_ResultCode;		// ¼º°ø / ½ÇÆÐ
			// 8.3.WSI_MEASURE_TYPE
			DVDataPack.wsiDefectData[i].measureType = pSWsiResult->nWsi_Type;				// µ¹Ãâ / ÇÔ¸ô
			// 8.4.WSI_DEFECT_MEASURE_HEIGHT
			DVDataPack.wsiDefectData[i].measureHeight = int(pSWsiResult->pWsi_ResultData[0]*1000);		// um
			// 8.5.WSI_DEFECT_MEASURE_WIDTH_X
			DVDataPack.wsiDefectData[i].measureWidthX = int(pSWsiResult->pWsi_ResultData[1]*1000);		// um
			// 8.6.WSI_DEFECT_MEASURE_WIDTH_Y
			DVDataPack.wsiDefectData[i].measureWidthY = int(pSWsiResult->pWsi_ResultData[2]*1000);		// um
			// 8.7.WSI_DEFECT_MEASURE_RATION
		}

		memcpy(DVData,&DVDataPack,sizeof(DVDataPack));


		if(nWritePacketDataLimitPlag ==1 ){// »çÀÌÁî ³Ê¹« Å©¸é Á¦¾î¸Þ¸ð¸® ¼³ºñ¸¶´Ù ´Þ¶ó¼­ ÅÍÁü ¿¹¹æ CRACK,IJP,LAMI
			pSignalControl->WritePacketData(_T("15100"), nSize, (short*)&DVData);
		}
		else{
			pSignalControl->WritePacketData(_T("15100"), sizeof(DVDataPack), (short*)&DVData);
		}
	}

	g_pLog->DisplayMessage(_T("[SequenceProcessor] SendDVDataToSignalControl->MakeDVData OUT."));
	//	return nPackSize;
	return sizeof(DVDataPack);
}

// [2017:4:13]-[WEZASW] : CIM Signal.
BOOL CSequenceProcessor_CSOT::RecvCIMSignalToSignalControl(int nAddrIndex, int nSignalIndex)
{
	CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
	if (pSignalControl==NULL) return FALSE;
	if (pSignalControl->IsConnected() == FALSE) return FALSE;

	BOOL bResult = FALSE;

	// PCControl D2300 (°Ë»ç ¿µ¿ª)
	switch(nSignalIndex)
	{
	case PCControlRecv_TimeChange:
		g_pLog->DisplayMessage(_T("[PCControl_Signal] CIM IF Signal => PCControlRecv_TimeChange."));
		bResult = ChangeReviewSystemTime();
		break;
	}
	return bResult;
}

BOOL CSequenceProcessor_CSOT::SendCIMSignalToSignalControl(int nAddrIndex, int nSignalIndex)
{
	CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
	if (pSignalControl == NULL)	return FALSE;
	if (pSignalControl->IsConnected() == FALSE) return FALSE;

	if (pSignalControl->Write_SendSignal(nAddrIndex, nSignalIndex, 1, 1000) == FALSE)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Send Fail! "));
		return FALSE;
	}

	switch (nAddrIndex)
	{
	case PCControlSend_D2320:
		if (nSignalIndex == PCControlSend_ReviewAlive)
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] CIM IF Signal => %d"), nSignalIndex);
		}
		break;		
	}
	return TRUE;
}

// Change System Time
BOOL CSequenceProcessor_CSOT::ChangeReviewSystemTime()
{
	g_pLog->DisplayMessage(_T("[SequenceProcessor] ChangeReviewSystemTime IN"));

	SYSTEMTIME CurrentTime, ChangedTime;
	GetLocalTime(&CurrentTime);
	ChangedTime = CurrentTime;

	int nReadData = 0;
	int nReadSize = 1;
	int nAddrCount = 0;
	
	if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData))	return FALSE;
	ChangedTime.wYear = nReadData;
	if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData))	return FALSE;
	ChangedTime.wMonth = nReadData;
	if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData))	return FALSE;
	ChangedTime.wDay = nReadData;
	if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData))	return FALSE;
	ChangedTime.wHour = nReadData;
	if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData))	return FALSE;
	ChangedTime.wMinute = nReadData;
	if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData))	return FALSE;
	ChangedTime.wSecond = nReadData;
	if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData))	return FALSE;

	if (SetLocalTime(&ChangedTime))	{		
 		g_pLog->DisplayMessage(_T("[SequenceProcessor] Success! SetLocalTime(), Current: %04d-%02d-%02d %02d-%02d-%02d, Changed: %04d-%02d-%02d %02d-%02d-%02d"), 
			CurrentTime.wYear, CurrentTime.wMonth, CurrentTime.wDay, CurrentTime.wHour, CurrentTime.wMinute, CurrentTime.wSecond,
			ChangedTime.wYear, ChangedTime.wMonth, ChangedTime.wDay, ChangedTime.wHour, ChangedTime.wMinute, ChangedTime.wSecond);
		// AFM & WSI TIME µ¿±âÈ­
		SendSystemTime(ChangedTime);
	} else {
 		g_pLog->DisplayMessage(_T("[SequenceProcessor] Fail! SetLocalTime()"));
	}

	g_pLog->DisplayMessage(_T("[SequenceProcessor] ChangeReviewSystemTime OUT"));

	return TRUE;
}

BOOL CSequenceProcessor_CSOT::ReadCIMTimeData(CString strAddr, int nAddrCnt, int& nData)
{
	CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
	if (pSignalControl==NULL) return FALSE;
	if (pSignalControl->IsConnected() == FALSE) return FALSE;
	
	CString strReadAddr = _T("");
	char readData[8] = {0};

	strReadAddr.Format(_T("D%d"), _ttoi(strAddr) + nAddrCnt);	
	if (pSignalControl->ReadData(strReadAddr, 1, readData) == FALSE)		return FALSE;
	memcpy(&nData, readData, 2);

	return TRUE;
}

// Local System º¯°æ ½Ã°£°ú º¯°æ ¿äû ÄÁÆ®·Ñ·¯ÀÇ ½Ã°£Â÷ ó¸® »ý°¢
BOOL CSequenceProcessor_CSOT::SendSystemTime(SYSTEMTIME sysTime)
{
	SYSTEMTIME CurrentTime;

	int nWSIControlCount = m_pSP2P->ISP2P_GetWSIControlCount();

	for(int nWSIControlIdx = 0; nWSIControlIdx < nWSIControlCount; nWSIControlIdx++)
	{
		CWsiControl* pWSIControl = m_pSP2P->ISP2P_GetWSIControl(nWSIControlIdx);
		if(pWSIControl == NULL) continue;

		GetLocalTime(&CurrentTime);
		pWSIControl->SetSystemTime(CurrentTime);
	}

	int nAFMControlCount = m_pSP2P->ISP2P_GetAFMControlCount();
	for(int nAFMControlIdx = 0; nAFMControlIdx < nAFMControlCount; nAFMControlIdx++)
	{
		CAfmControl* pAFMControl = m_pSP2P->ISP2P_GetAFMControl(nAFMControlIdx);
		if(pAFMControl == NULL) continue;

		GetLocalTime(&CurrentTime);
		pAFMControl->SetSystemTime(CurrentTime);
	}
	return TRUE;
}

BOOL CSequenceProcessor_CSOT::SendSignalOffToSignalControl( int nSignalIndex, int nSignalValue )
{
	CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
	if (pSignalControl == NULL)	return FALSE;

	if (pSignalControl->IsConnected() == FALSE) return FALSE;

	int nAddrIdx = 0;
	if (pSignalControl->Write_SendSignal(nSignalIndex, nSignalValue, 0,SIGNAL_ON_TIME_INFINITY) == FALSE)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Send Fail! "));
		return FALSE;
	}

	if (nSignalIndex==PCControlSendSignalIndex_State)
	{
		switch(nSignalValue)
		{
		case PCControlSend_RecipeASCEND:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Recipe ASCEND Bit OFF! => %d"),0);
			break;
		case PCControlSend_WSIError:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] WSIError Bit OFF! => %d"),0);
			break;
		}
	}
	else if (nSignalIndex==PCControlSendSignalIndex_Seq)
	{
		switch(nSignalValue)
		{
		case PCControlSend_LoadingComplete_CSOT:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Complete Off! => %d"), 0);
			break;

		case PCControlSend_AlignComplete_CSOT:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Complete Off! => %d"), 0);
			break;

		case PCControlSend_ReviewReady_CSOT:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Ready Off! => %d"), 0);
			break;

		case PCControlSend_ReviewComplete_CSOT:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Complete Off! => %d"), 0);
			break;

		case PCControlSend_ResultDataComplete_CSOT:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete Off! => %d"), 0);
			break;
		}
	}
	else if (nSignalIndex==PCControlSendSignalIndex_Ack)
	{
		switch(nSignalValue)
		{
		case PCControlSend_LoadingAck_CSOT:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Ack Off! => %d"), 0);
			break;

		case PCControlSend_AlignStartAck_CSOT:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Start Ack Off! => %d"), 0);
			break;

		case PCControlSend_ReadRawFileAck_CSOT:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Read Raw File Ack Off! => %d"), 0);
			break;

		case PCControlSend_ReviewStartAck_CSOT:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Start Ack Off! => %d"), 0);
			break;

		case PCControlSend_ResultDataComplete_CSOT:
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete Off! => %d"), 0);
			break;
		}
	}

	return TRUE;
}

BOOL CSequenceProcessor_CSOT::SendSignalToSignalControl( int nSignalIndex, int nSignalValue )
{
	CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
	if (pSignalControl == NULL)	return FALSE;

	if (pSignalControl->IsConnected() == FALSE) return FALSE;

	int nAddrIdx = 0;
	if (pSignalControl->Write_SendSignal(nSignalIndex, nSignalValue, 1, SIGNAL_ON_TIME_INFINITY) == FALSE)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Send Fail! "));
		return FALSE;
	}
	
	switch(nSignalIndex)
	{
	case PCControlSendSignalIndex_State:
		{
			switch(nSignalValue)
			{
			case PCControlSend_RecipeASCEND:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Recipe Is ASCEND! => %d"),1);
				break;
			case PCControlSend_WSIError:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] WSIError! => %d"),0);
				break;
			case PCControlSend_Defoucs:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Defoucs! => %d"),0);
				break;
			}
		}
		break;
	case PCControlSendSignalIndex_Seq:
		{
			switch(nSignalValue)
			{
			case PCControlSend_LoadingComplete_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Complete! => %d"), 1);
				break;

			case PCControlSend_AlignComplete_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Complete! => %d"), 1);
				break;

			case PCControlSend_ReviewReady_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Ready! => %d"), 1);
				break;

			case PCControlSend_ReviewComplete_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Complete! => %d"), 1);
				break;

			case PCControlSend_ResultDataComplete_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete! => %d"), 1);
				break;
			}
		}
		break;
	case PCControlSendSignalIndex_Ack:
		{
			switch(nSignalValue)
			{
			case PCControlSend_LoadingAck_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Ack! => %d"), 1);
				break;

			case PCControlSend_AlignStartAck_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Start Ack! => %d"), 1);
				break;

			case PCControlSend_ReadRawFileAck_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Read Raw File Ack! => %d"), 1);
				break;

			case PCControlSend_ReviewStartAck_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Start Ack! => %d"), 1);
				break;

			case PCControlSend_ResultDataComplete_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete! => %d"), 1);
				break;
			}
		}
		break;
	}

	return TRUE;
}

BOOL CSequenceProcessor_CSOT::SendSignalToSignalControl( int nSignalIndex, int nSignalValue,int nSignalOnTime )
{
	CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
	if (pSignalControl == NULL)	return FALSE;

	if (pSignalControl->IsConnected() == FALSE) return FALSE;

	int nAddrIdx = 0;
	if (pSignalControl->Write_SendSignal(nSignalIndex, nSignalValue, 1, nSignalOnTime) == FALSE)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Send Fail! "));
		return FALSE;
	}

	switch(nSignalIndex)
	{
	case PCControlSendSignalIndex_State:
		{
			switch(nSignalValue)
			{
			case PCControlSend_RecipeASCEND:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Recipe Is ASCEND! => %d"),1);
				break;
			case PCControlSend_WSIError:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] WSIError! => %d"),0);
				break;
			case PCControlSend_Defoucs:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Defoucs! => %d"),0);
				break;
			}
		}
		break;
	case PCControlSendSignalIndex_Seq:
		{
			switch(nSignalValue)
			{
			case PCControlSend_LoadingComplete_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Complete! => %d"), 1);
				break;

			case PCControlSend_AlignComplete_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Complete! => %d"), 1);
				break;

			case PCControlSend_ReviewReady_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Ready! => %d"), 1);
				break;

			case PCControlSend_ReviewComplete_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Complete! => %d"), 1);
				break;

			case PCControlSend_ResultDataComplete_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete! => %d"), 1);
				break;
			}
		}
		break;
	case PCControlSendSignalIndex_Ack:
		{
			switch(nSignalValue)
			{
			case PCControlSend_LoadingAck_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Ack! => %d"), 1);
				break;

			case PCControlSend_AlignStartAck_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Start Ack! => %d"), 1);
				break;

			case PCControlSend_ReadRawFileAck_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Read Raw File Ack! => %d"), 1);
				break;

			case PCControlSend_ReviewStartAck_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Start Ack! => %d"), 1);
				break;

			case PCControlSend_ResultDataComplete_CSOT:
				m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete! => %d"), 1);
				break;
			}
		}
		break;
	}

	return TRUE;
}

BOOL CSequenceProcessor_CSOT::ProcessSignal_State( int nSignalValue, BOOL bSignalOn )
{
	BOOL bResult = FALSE;

	if (bSignalOn==FALSE) return TRUE;

	switch(nSignalValue)
	{
	case PCControlRecv_ByPassMode_CSOT:	// bypass mode on
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] BY-PASS Mode"));
			bResult = SetProcessMode(ProcessBypassMode_CSOT);
			if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] BY-PASS Mode Error!"));
		}
		break;

	case PCControlRecv_AutoMode_CSOT:		// auto mode on
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Auto Mode"));
			bResult = SetProcessMode(ProcessAutoMode_CSOT);
			if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Auto Mode Error!"));
		}
		break;

	case PCControlRecv_ManualMode_CSOT:	// manual mode on
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Manual Mode"));
			bResult = SetProcessMode(ProcessManualMode_CSOT);
			if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Manual Mode Error!"));

			// lmk simul manual camera,motor stop
			//ReviewCamera_CameraControl(CameraControlStop);	// ¸ðÅÍ ¸ØÃ߸é Ä«¸Þ¶ó ÀÚµ¿ ½ºÅ¾
			CMotorControl*  pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
			if(pMotorControl)
				pMotorControl->CommonSetAutoStop();
		}
		break;

	case PCControlRecv_ReviewManualMode_CSOT:	// review mode on
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Review Mode"));
			bResult = SetProcessMode(ProcessReviewMode_CSOT);
			if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Review Mode Error!"));
		}
		break;

	default:
		return FALSE;
		break;
	}

	return bResult;
}


BOOL CSequenceProcessor_CSOT::ProcessSignal_Seq( int nSignalValue, BOOL bSignalOn )
{
	BOOL bResult = FALSE;

	switch(nSignalValue)
	{
	case PCControlRecv_Loading_CSOT:		// loading on
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Glass Loading! => %d"), bSignalOn);
			if (bSignalOn)
				bResult = SetProcessStatus(ProcessLoading_CSOT);
			else
				bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_LoadingAck_CSOT);
			if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Glass Loading Error!"));
		}
		break;

	case PCControlRecv_AlignStart_CSOT:	// align start on
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Align Start! => %d"), bSignalOn);
			if (bSignalOn)
				bResult = SetProcessStatus(ProcessAlignStart_CSOT);
			else
				bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_AlignStartAck_CSOT);
			if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Align Start Error!"));
		}
		break;

	case PCControlRecv_ReadRawFile_CSOT:	// read raw file on
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Read Raw File! => %d"), bSignalOn);
			if (bSignalOn)
				bResult = SetProcessStatus(ProcessReadRawFile_CSOT);
			else
				bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReadRawFileAck_CSOT);
			if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Read Raw File Error!"));
		}
		break;

	case PCControlRecv_ReviewStart_CSOT:	// review start on
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Start! => %d"), bSignalOn);
			if (bSignalOn)
				bResult = SetProcessStatus(ProcessReviewStart_CSOT);
			else
				bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReviewStartAck_CSOT);
			if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Start Error!"));
		}
		break;

	case PCControlRecv_ReviewEnd_CSOT:		// review end on
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review End! => %d"), bSignalOn);
			if (bSignalOn)
				bResult = SetProcessStatus(ProcessReviewEnd_CSOT);
			else
				bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReviewEndAck_CSOT);
			if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review End Error!"));
		}
		break;

	case PCControlRecv_AFM_Home_Move_CSOT:		// AFM Home Move On
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] AFM Home Move! => %d"), bSignalOn);
			if (bSignalOn)
				bResult = SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_AFMHomeMoveAck_CSOT);
			else
				bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_AFMHomeMoveAck_CSOT);

			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Send AFM Home Move Ack!"));
		}
		break;

	case PCControlRecv_WSI_Home_Move_CSOT:		// WSI Home Move ON
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] WSI Home Move!"));
			if (bSignalOn)
				bResult = SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_WSIHomeMoveAck_CSOT);
			else
				bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_WSIHomeMoveAck_CSOT);

			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Send WSI Home Move Ack!"));
		}
		break;

	default:
		return FALSE;
		break;
	}

	return bResult;
}

BOOL CSequenceProcessor_CSOT::ProcessSignal_Ack( int nSignalValue, BOOL bSignalOn )
{
	BOOL bResult = FALSE;

	if (bSignalOn==FALSE) return TRUE;

	switch(nSignalValue)
	{
	case PCControlRecv_LoadingCompleteAck_CSOT:	// Loading complete ack on
		m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Loading Complete Ack!"));
		bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_LoadingComplete_CSOT);
		if (bResult)	m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Loading Complete Off!"));
		else			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Loading Complete Off Fail!"));
		break;

	case PCControlRecv_AlignCompleteAck_CSOT:	// align complete ack on
		m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Align Complete Ack!"));
		bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_AlignComplete_CSOT);
		if (bResult)	m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Align Complete Off!"));
		else			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Align Complete Off Fail!"));
		break;

	case PCControlRecv_ReviewReadyAck_CSOT:	// review ready ack on
		m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Ready Ack!"));
		bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewReady_CSOT);
		if (bResult)	m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Ready Off!"));
		else			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Ready Off Fail!"));
		break;

	case PCControlRecv_ReviewCompleteAck_CSOT:	// review complete ack on
		m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Complete Ack!"));
		bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewComplete_CSOT);
		if (bResult)	m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Complete Off!"));
		else			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Complete Off Fail!"));
		break;

	case PCControlRecv_ResultDataCompleteAck_CSOT:	// result data complete ack on
		m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Result Data Complete Ack!"));
		bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ResultDataComplete_CSOT);
		if (bResult)	m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Result Data Complete Off!"));
		else			m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Result Data Complete Off Fail!"));
		break;

	default:
		return FALSE;
		break;
	}

	return bResult;
}

BOOL CSequenceProcessor_CSOT::SendResultToSignalControl( int nSingalIdx, int nResultValue )
{
	CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
	if (pSignalControl == NULL)	return FALSE;

	if (pSignalControl->IsConnected() == FALSE) return FALSE;

	const CSignalControlInfo* pSignalControlInfo = m_pSP2P->ISP2P_System_GetPCControlInfo();
	if (pSignalControlInfo==NULL) return FALSE;

	if (nSingalIdx<0 || nSingalIdx>=pSignalControlInfo->GetSendDataAddressCount()) return FALSE;

	const SSignalSettingData* pSSignalSendAddr = pSignalControlInfo->GetSendDataAddress(nSingalIdx);
	if (pSSignalSendAddr==NULL) return FALSE;

	if (pSignalControl->WriteWordData(pSSignalSendAddr->strAddr, pSSignalSendAddr->nSize, nResultValue)==FALSE)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Write Result Fail! "));
		return FALSE;
	}

	m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Write Result : Name[%s], Addr[%s], Data[%d]"), 
		pSSignalSendAddr->strName, pSSignalSendAddr->strAddr, nResultValue);

	return TRUE;
}

BOOL CSequenceProcessor_CSOT::SendResultToSignalControl( int nSingalIdx, CString strResultValue )
{
	CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
	if (pSignalControl == NULL)	return FALSE;

	if (pSignalControl->IsConnected() == FALSE) return FALSE;

	const CSignalControlInfo* pSignalControlInfo = m_pSP2P->ISP2P_System_GetPCControlInfo();
	if (pSignalControlInfo==NULL) return FALSE;

	if (nSingalIdx<0 || nSingalIdx>=pSignalControlInfo->GetSendDataAddressCount()) return FALSE;

	const SSignalSettingData* pSSignalSendAddr = pSignalControlInfo->GetSendDataAddress(nSingalIdx);
	if (pSSignalSendAddr==NULL) return FALSE;

	if (pSignalControl->WriteData(pSSignalSendAddr->strAddr, pSSignalSendAddr->nSize, strResultValue)==FALSE)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Write Result Fail! "));
		return FALSE;
	}
	
	m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Write Result : Name[%s], Addr[%s], Data[%s]"), 
		pSSignalSendAddr->strName, pSSignalSendAddr->strAddr, strResultValue);

	return TRUE;
}

void CSequenceProcessor_CSOT::RecvWSIReflowResult( int nModuleIndex, const SWsiResult& measureResut )
{
	return;
}

int CSequenceProcessor_CSOT::ChangeWsiReflowPointIndex( int nIdx )
{
	switch(nIdx)
	{
	case CELL_TOP:
		return TOP;
		break;
	case CELL_LEFT:
		return LEFT;
		break;
	case CELL_RIGHT:
		return RIGHT;
		break;
	case CELL_LEFTTOP:
		return LEFTTOP;
		break;
	case CELL_RIGHTTOP:
		return RIGHTTOP;
		break;
	case CELL_LEFTBOTTOM:
		return LEFTBOTTOM;
		break;
	case CELL_RIGHTBOTTOM:
		return RIGHTBOTTOM;
		break;
	case CELL_BOTTOM:
		return BOTTOM;
		break;
	case CELL_LEFTNOTCH:
		return LEFTNOTCH;
		break;
	case CELL_RIGHTNOTCH:
		return RIGHTNOTCH;
		break;
	}
	return 0;
}

BOOL CSequenceProcessor_CSOT::WsiReflowStartProcessing( CGlassResult *pGlassResult, int nPlanIndex/*=0*/ )
{

	AFM_SetAFMTracking(FALSE); 
	// send wsi start
	SetWsiType(5);
	WSIAllReadySignal(0);
	
	if(!WSIReflowAllStartSignal())
	{
		g_pLog->DisplayMessage(_T("[WSI] WSI Start Fail!!"));
	}

	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
	if(pGlassResult && pReviewProcessor)
	{
		// WsiStart
		pReviewProcessor->SetJobID(pGlassResult->m_strJobID);	// pGlassResult->m_strGlassID -> pGlassResult->m_strJobID º¯°æ
		pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
		m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_WSIReflowStart, nPlanIndex);

		// Send WsiPos to Motor
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send WsiReflow Point to Motor Started!"));
		SendWsiReflowPositionToMotorControl(pGlassResult);
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send WsiReflow Point to Motor Ended!"));

	    MakeWSIUpLoadDirectory(pReviewProcessor->GetUploadImagePath());

		return TRUE;
	}	

	return FALSE;
}

BOOL CSequenceProcessor_CSOT::WsiUserStartProcessing( CGlassResult *pGlassResult, int nPlanIndex/*=0*/ )
{
	// AFM Tracking ON
	AFM_SetAFMTracking(FALSE);

	SetWsiType(0);
	WSIAllReadySignal(0);
	
	// send wsi start
	if(!WSIUserAllStartSignal())
	{
		g_pLog->DisplayMessage(_T("[WSI] WSI Start Fail!!"));
	}


	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
	if(pGlassResult && pReviewProcessor)
	{
		// WsiStart
		pReviewProcessor->SetJobID(pGlassResult->m_strJobID);	// pGlassResult->m_strGlassID -> pGlassResult->m_strJobID º¯°æ
		pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
		m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_WSIStart, nPlanIndex);

		// Send WsiPos to Motor
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send UserWsi Point to Motor Started!"));
		SendWsiUserPositionToMotorControl(pGlassResult);
		m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send UserWsi Point to Motor Ended!"));
	    MakeWSIUpLoadDirectory(pReviewProcessor->GetUploadImagePath());
		return TRUE;
	}	

	return FALSE;
}


int CSequenceProcessor_CSOT::SendWsiReflowPositionToMotorControl( CGlassResult* pGlassResult )
{
	CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
	if(pMotorControl == NULL) return 0;

	const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
	if(pSystemInfo == NULL) return -1;

	const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
	if (pMotorInfo == NULL) return -2;

	const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
	if (pMotorInfo == NULL) return -3;

	// set move count zero
	for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
	{
		pMotorControl->GantrySetMoveCount(i, 0);
	}

	// set move delay time
	pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
	pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
	pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());

	// get direction
	int nDirectionX, nDirectionY;
	pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);

	int nTotalCount = 0;
	double dDefectPosX, dDefectPosY;

	// WSI result count
	for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
	{		
		CReviewResult*					pWsiResult	= pGlassResult->GetWsiReflowResult(nModuleIdx);
		if (pWsiResult==NULL) continue;
		const SCoordInfo*				pCoordInfo		= Module_GetCoordInfo(nModuleIdx);
		if (pCoordInfo==NULL) continue;
		CModuleStatus*					pModuleStatus	= Module_GetModuleStatus(nModuleIdx);		
		if (pModuleStatus == NULL) continue;

		// get result index
		int nStartIdx = pWsiResult->GetStartSReviewResultIndex();
		int nEndIdx = pWsiResult->GetEndSReviewResultIndex();
		nEndIdx = min(nEndIdx, (pWsiResult->GetSReviewResultCount()-1)) + 1;		// set End Index 

		// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
		double m_dMinOffset = -5.0; 
		double m_dMaxOffset = 5.0;

		// get wsi pos
		VectorDouble vectorPosX, vectorPosY;

		for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
		{
			SReviewResult* pWsi = pWsiResult->GetSReviewResult(nResultIdx);
			if (pWsi==NULL) continue;

			// set defect pos
			dDefectPosX = double(pWsi->nUMOriginX) / 1000.0;
			dDefectPosY = double(pWsi->nUMOriginY) / 1000.0;

			// trans glass to motor pos
			pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);

			// set offset
			ApplyMotorOffset(pWsi->nModuleIdx, -1, MotorOffsetCamera + MotorOffsetWSI, dDefectPosX, dDefectPosY);

			// motor calibrate
			CalibrateMotorPos(pWsi->nModuleIdx, dDefectPosX, dDefectPosY);

			// add move pos
			if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
			{
				pWsi->dTargetMotorX = dDefectPosX;
				pWsi->dTargetMotorY = dDefectPosY;
				vectorPosX.push_back(dDefectPosX);
				vectorPosY.push_back(dDefectPosY);

				g_pLog->DisplayMessage(_T("[WsiStart] %d Module, %d Point, Motor: %.3lf mm, %.3lf mm"), nModuleIdx, nResultIdx, dDefectPosX, dDefectPosY);
			}
		}

		// move path to motor
		if (pMotorControl->GantryWsiAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))
		{
			nTotalCount += (int)vectorPosX.size();
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success!"), pModuleStatus->GetGantryIndex());
		}
		else
		{
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
		}
	}

	if (pMotorControl->CommonSetAutoWsiGoAll()==FALSE)
	{
		g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoWsi Fail!"));
		return 0;
	}

	g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry WsiReflow Success!"));
	return nTotalCount;
}
BOOL CSequenceProcessor_CSOT::SendWsiUserPositionToMotorControl( CGlassResult* pGlassResult )
{
	CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
	if(pMotorControl == NULL) return 0;

	const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
	if(pSystemInfo == NULL) return -1;

	const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
	if (pMotorInfo == NULL) return -2;

	const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
	if (pMotorInfo == NULL) return -3;

	// set move count zero
	for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
	{
		pMotorControl->GantrySetMoveCount(i, 0);
	}

	// set move delay time
	pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
	pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
	pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());

	// get direction
	int nDirectionX, nDirectionY;
	pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);

	int nTotalCount = 0;
	double dDefectPosX, dDefectPosY;

	//sjb
	/*
	VectorDouble vectorPosX2, vectorPosY2;
	vectorPosX2.push_back(2635);
	vectorPosX2.push_back(2635);
	vectorPosX2.push_back(2635);
	vectorPosX2.push_back(2635);
	vectorPosX2.push_back(2635);
	vectorPosX2.push_back(2635);
	vectorPosX2.push_back(2635);
	vectorPosX2.push_back(2635);
	vectorPosX2.push_back(2635);
	vectorPosX2.push_back(2635);
	//
	vectorPosY2.push_back(500);
	vectorPosY2.push_back(400);
	vectorPosY2.push_back(500);
	vectorPosY2.push_back(400);
	vectorPosY2.push_back(500);
	vectorPosY2.push_back(400);
	vectorPosY2.push_back(500);
	vectorPosY2.push_back(400);
	vectorPosY2.push_back(500);
	vectorPosY2.push_back(400);
	*/
	// WSI result count
	for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
	{		
		CReviewResult*					pWsiUserResult	= pGlassResult->GetWsiUserResult(nModuleIdx);
		if (pWsiUserResult==NULL) continue;
		const SCoordInfo*				pCoordInfo		= Module_GetCoordInfo(nModuleIdx);
		if (pCoordInfo==NULL) continue;
		CModuleStatus*					pModuleStatus	= Module_GetModuleStatus(nModuleIdx);		
		if (pModuleStatus == NULL) continue;

		// get result index
		int nStartIdx = pWsiUserResult->GetStartSReviewResultIndex();
		int nEndIdx = pWsiUserResult->GetEndSReviewResultIndex();
		nEndIdx = min(nEndIdx, (pWsiUserResult->GetSReviewResultCount()-1)) + 1;		// set End Index 

		// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
		double m_dMinOffset = -5.0; 
		double m_dMaxOffset = 5.0;

		// get wsi pos
		VectorDouble vectorPosX, vectorPosY;

		for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
		{
			SReviewResult* pWsi = pWsiUserResult->GetSReviewResult(nResultIdx);
			if (pWsi==NULL) continue;

			// set defect pos
			dDefectPosX = double(pWsi->nUMOriginX) / 1000.0;
			dDefectPosY = double(pWsi->nUMOriginY) / 1000.0;

			// trans glass to motor pos
			pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);

			// set offset
			ApplyMotorOffset(pWsi->nModuleIdx, -1, MotorOffsetCamera + MotorOffsetWSI, dDefectPosX, dDefectPosY);

			// motor calibrate
			CalibrateMotorPos(pWsi->nModuleIdx, dDefectPosX, dDefectPosY);

			// add move pos
			if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
			{
				pWsi->dTargetMotorX = dDefectPosX;
				pWsi->dTargetMotorY = dDefectPosY;
				vectorPosX.push_back(dDefectPosX);
				vectorPosY.push_back(dDefectPosY);				
			}
		}

		// move path to motor
		if (pMotorControl->GantryWsiAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))
		//if (pMotorControl->GantryWsiAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX2, vectorPosY2, TRUE))
		{
			nTotalCount += (int)vectorPosX.size();
			//nTotalCount += (int)vectorPosX2.size();
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success!, Point Count : %d"), pModuleStatus->GetGantryIndex(),  (int)vectorPosX.size());
		}
		else
		{
			g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
		}
	}

	// all auto go
	if (pMotorControl->CommonSetAutoWsiGoAll()==FALSE)
	{
		g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoWsi Fail!"));
		return 0;
	}

	g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry WsiUser Success!"));
	return nTotalCount;
}


BOOL CSequenceProcessor_CSOT::CalculateWsiReflowPathPlan( CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult )
{
	CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
	if (pGlassResult==NULL || pReviewScheduler==NULL || pPrioritySorter==NULL) return FALSE;

	int nTotalModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount();
	int nReviewModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Wsi);
	int nPointCount			=  pPrioritySorter->GetSortingResultWsiReflowCount();

	// point is zero?
	if (nPointCount==0)	return TRUE;

	// get current glass pos review cameras
	VectorPathData vecStartPathData;
	for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
	{
		const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
		if (pModuleStatus==NULL) continue;

		if ( (pModuleStatus->GetModuleType() & ModuleType_Wsi) != ModuleType_Wsi)
		{
			continue;
		}

		const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
		if (pMotorPosition==NULL) continue;

		SPathData ptStartPath;
		ptStartPath.nIndex = nIdx; // module index
		ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
		ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);
		vecStartPathData.push_back(ptStartPath);
	}

	// get user point result
	VectorPathData vecPathData;
	for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
	{
		const SReviewResult *pSReviewResult = pPrioritySorter->GetSortingResultWsiReflow(nPosIdx);
		if (pSReviewResult==NULL) continue;

		SPathData pathData(pSReviewResult->nUMOriginX, pSReviewResult->nUMOriginY, pSReviewResult->nResultIdx);
		vecPathData.push_back(pathData);
	}

	// calculate shortest path
	if (pReviewScheduler->PathScheduling(vecPathData, vecStartPathData)>0)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[ReviewScheduler] CalculatePath"));

		for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
		{
			CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
			if (pScheduleResult==NULL) continue;

			// add reflow result
			pGlassResult->AddWsiReflowResult(CReviewResult(nModuleIdx));

			// get user result
			CReviewResult *pReviewResult = pGlassResult->GetWsiReflowResult(nModuleIdx);
			if(pReviewResult == NULL) return FALSE;

			// get sreview result
			ReviewScheduler_ResizeWsiReflowResult(pScheduleResult, pReviewResult, pPrioritySorter, pScheduleResult->GetPathSchedulerResultCount());

			// add user schedule result
			pGlassResult->AddWsiReflowScheduleRedult(*pScheduleResult);

// 			CString strFilename = _T("");
// 			strFilename.Format(_T("c:\\%d_module_wsireflow_path.csv"), nModuleIdx);
// 			CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
		}
	}	
	else
	{
		return FALSE;
	}

	return TRUE;
}


BOOL CSequenceProcessor_CSOT::CalculateWsiUserPathPlan( CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult )
{
	CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
	if (pGlassResult==NULL || pReviewScheduler==NULL || pPrioritySorter==NULL) return FALSE;

	int nTotalModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount();
	int nReviewModuleCount	= m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Wsi);
	int nPointCount			=  pPrioritySorter->GetSortingResultWsiUserCount();
	
	// point is zero?
	if (nPointCount==0)	return TRUE;

	// get current glass pos review cameras
	VectorPathData vecStartPathData;
	for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
	{
		const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
		if (pModuleStatus==NULL) continue;

		if ( (pModuleStatus->GetModuleType() & ModuleType_Wsi) != ModuleType_Wsi)
		{
			continue;
		}

		const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
		if (pMotorPosition==NULL) continue;

		SPathData ptStartPath;
		ptStartPath.nIndex = nIdx; // module index
		ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
		ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);
		vecStartPathData.push_back(ptStartPath);
	}

	// get user point result
	VectorPathData vecPathData;
	for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
	{
		const SReviewResult *pSReviewResult = pPrioritySorter->GetSortingResultWsiUser(nPosIdx);
		if (pSReviewResult==NULL) continue;

		SPathData pathData(pSReviewResult->nUMOriginX, pSReviewResult->nUMOriginY, pSReviewResult->nResultIdx);
		vecPathData.push_back(pathData);
	}

	// calculate shortest path
	if (pReviewScheduler->PathScheduling(vecPathData, vecStartPathData)>0)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[ReviewScheduler] CalculatePath"));

		for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
		{
			CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
			if (pScheduleResult==NULL) continue;

			// add reflow result
			pGlassResult->AddWsiUserResult(CReviewResult(nModuleIdx));

			// get user result
			CReviewResult *pReviewResult = pGlassResult->GetWsiUserResult(nModuleIdx);
			if(pReviewResult == NULL) return FALSE;

			// get sreview result
			ReviewScheduler_ResizeWsiUserResult(pScheduleResult, pReviewResult, pPrioritySorter, pScheduleResult->GetPathSchedulerResultCount());

			// add user schedule result
			pGlassResult->AddWsiUserScheduleRedult(*pScheduleResult);

			// 			CString strFilename = _T("");
			// 			strFilename.Format(_T("c:\\%d_module_wsireflow_path.csv"), nModuleIdx);
			// 			CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
		}
	}	
	else
	{
		return FALSE;
	}

	return TRUE;

}


void CSequenceProcessor_CSOT::ReviewScheduler_ResizeWsiReflowResult( CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize)
{
	pReviewResult->Reset();
	int nResultIdx = 0;

	int nModuleIdx = pScheduleResult->GetModuleIndex();
	pReviewResult->SetModuleIndex(nModuleIdx);

	CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
	if (pModuleStatus==NULL) return;

	CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo==NULL) return;

	CRcpUserDefectInfo* pRcpUserDefectInfo;

	CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
	if (pRcpAFMRecipeInfo==NULL) return;

	int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);

	SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
	SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
	if (pMagnificInfo==NULL) return;
	if (pCameraInfo==NULL) return;	

	CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult ==NULL)	return;

	CString strGlassLastName = pGlassResult->m_strGlassLastName;

	for (int i=0; i<nSize; i++)
	{
		SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
		if (pNode==NULL)	continue;

		SReviewResult* sResult = pPrioritySorter->GetSortingResultWsiReflow(pNode->nTotalIndex);
		if(sResult == NULL)	continue;

		sResult->nReviewType		= ReviewType_WsiReflow;
		sResult->nModuleIdx			= nModuleIdx;
		sResult->nResultIdx			= nResultIdx;

		sResult->nZoomIdx			= nZoomIdx;
		sResult->dMagnification		= pMagnificInfo->dMagnification;
		sResult->dMeasureResolution	= pCameraInfo->dResolution / sResult->dMagnification;
		sResult->bDigitalZoom		= FALSE;

		pRcpUserDefectInfo = pRsRcpReviewInfo->GetRcpUserDefectInfo(pNode->nTotalIndex);
		if (pRcpUserDefectInfo == NULL) continue;
		
		if(strGlassLastName.Compare(_T("B")) == 0 || strGlassLastName.Compare(_T("b")) == 0)		sResult->strCellID			= pRcpUserDefectInfo->GetCellId2();
		else											sResult->strCellID			= pRcpUserDefectInfo->GetCellId();

		sResult->nReflow_CellIndex	= pRcpUserDefectInfo->m_nReflowCellIndex;

		// Point Index Change
		int nWsiReflowPointIndex = ChangeWsiReflowPointIndex(pRcpUserDefectInfo->GetCellSide());

		sResult->nWsiReflowPositionIndex	=	nWsiReflowPointIndex;

		pReviewResult->AddSReviewResult(*sResult);

		nResultIdx++;
	}

	pScheduleResult->ResizeScheduleResult(nSize);
}

void CSequenceProcessor_CSOT::ReviewScheduler_ResizeWsiUserResult( CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize)
{
	pReviewResult->Reset();
	int nResultIdx = 0;

	int nModuleIdx = pScheduleResult->GetModuleIndex();
	pReviewResult->SetModuleIndex(nModuleIdx);

	CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
	if (pModuleStatus==NULL) return;

	CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if (pRsRcpReviewInfo==NULL) return;

	CRcpUserDefectInfo* pRcpUserDefectInfo;

	CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
	if (pRcpAFMRecipeInfo==NULL) return;

	int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);

	SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
	SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
	if (pMagnificInfo==NULL) return;
	if (pCameraInfo==NULL) return;	

	CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
	if(pGlassResult ==NULL)	return;

	CString strGlassLastName = pGlassResult->m_strGlassLastName;

	for (int i=0; i<nSize; i++)
	{
		SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
		if (pNode==NULL)	continue;

		SReviewResult* sResult = pPrioritySorter->GetSortingResultWsiUser(pNode->nTotalIndex);
		if(sResult == NULL)	continue;

		sResult->nReviewType		= ReviewType_WsiUser;
		sResult->nModuleIdx			= nModuleIdx;
		sResult->nResultIdx			= nResultIdx;

		sResult->nZoomIdx			= nZoomIdx;
		sResult->dMagnification		= pMagnificInfo->dMagnification;
		sResult->dMeasureResolution	= pCameraInfo->dResolution / sResult->dMagnification;
		sResult->bDigitalZoom		= FALSE;

		pRcpUserDefectInfo = pRsRcpReviewInfo->GetRcpUserDefectInfo(pNode->nTotalIndex);
		if (pRcpUserDefectInfo == NULL) continue;
		
		if(strGlassLastName.Compare(_T("B")) == 0 || strGlassLastName.Compare(_T("b")) == 0)		sResult->strCellID			= pRcpUserDefectInfo->GetCellId2();
		else											sResult->strCellID			= pRcpUserDefectInfo->GetCellId();

		sResult->nReflow_CellIndex	= pRcpUserDefectInfo->m_nReflowCellIndex;

		// Point Index Change
		//int nWsiReflowPointIndex = ChangeWsiReflowPointIndex(pRcpUserDefectInfo->GetCellSide());

		//sResult->nWsiReflowPositionIndex	=	nWsiReflowPointIndex;

		pReviewResult->AddSReviewResult(*sResult);

		nResultIdx++;
	}

	pScheduleResult->ResizeScheduleResult(nSize);
}


BOOL CSequenceProcessor_CSOT::ChangeUserReviewAxisCenterPosition(const CGlassResult *pGlassResult)
{
	if(m_pSP2P == NULL || pGlassResult == NULL)	return FALSE;

	const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
	if(pSystemInfo == NULL)		return FALSE;

	CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if(pRsRcpReviewInfo == NULL)	return FALSE;

	if(pRsRcpReviewInfo->GetRcpUserDefectInfoCount() < 1)	return TRUE;		// °íÁ¤¸®ºä Ä«¿îÆ®°¡ ¾ø´Ù¸é ³Ñ¾î°¡ÀÚ

	double dCenterPosX, dCenterPosY;
	
	CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();

	for(int nUseCnt=0; nUseCnt<pRsRcpReviewInfo->GetRcpUserDefectInfoCount(); nUseCnt++)
	{
		CRcpUserDefectInfo *pUseInfo = pRsRcpReviewInfo->GetRcpUserDefectInfo(nUseCnt);
		if(pUseInfo == NULL)	continue;

		double dGlassPosX = pUseInfo->m_dPosX;
		double dGlassPosY = pUseInfo->m_dPosY;

		if (pSystemInfo->m_nMachineType == 0 || pSystemInfo->m_nMachineType ==  1 ||pSystemInfo->m_nMachineType ==  2)
		{
			dCenterPosX = pReviewProcessor->GetCentertoOrginCoordinate(dGlassPosX*1000,-1,pGlassResult->GetCornerCutDir(),pGlassResult->GetOriginDir());
			dCenterPosY = pReviewProcessor->GetCentertoOrginCoordinate(-1,dGlassPosY*1000,pGlassResult->GetCornerCutDir(),pGlassResult->GetOriginDir());

		}
		else if(pSystemInfo->m_nMachineType == 3 || pSystemInfo->m_nMachineType == 4 || pSystemInfo->m_nMachineType == 5)
		{
			dCenterPosY = pReviewProcessor->GetCentertoOrginCoordinate(dGlassPosX*1000,-1,pGlassResult->GetCornerCutDir(),pGlassResult->GetOriginDir());
			dCenterPosX = pReviewProcessor->GetCentertoOrginCoordinate(-1,dGlassPosY*1000,pGlassResult->GetCornerCutDir(),pGlassResult->GetOriginDir());
		}

		pUseInfo->m_dPosX = dCenterPosX/= 1000.0;
		pUseInfo->m_dPosY = dCenterPosY/= 1000.0;
	}

	return TRUE;
}

void CSequenceProcessor_CSOT::RemoveMotorCount()
{
	CMotorControl* pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
	if(pMotorControl == NULL)
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor] MotorControl Init Fail"));
		return ;
	}

	const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
	if(pSystemInfo == NULL)		return;

	for(int nGantryIdx = 0; nGantryIdx < pSystemInfo->GetGantryInfoCount(); nGantryIdx++)
	{
		pMotorControl->RemoveAllAutoGoCount(nGantryIdx);
	}	
}

BOOL CSequenceProcessor_CSOT::UpdateMemoryUserReflowPlanInfo(CDitGlassRawClient* pDitSharedGlassRaw)
{
	CRsRcpReviewInfo* pRecipeinfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
	if(pRecipeinfo == NULL)	return FALSE;	

	_grmGlassData* pSharedGlassData = pDitSharedGlassRaw->GetGlassData();
	if(pSharedGlassData == NULL) return FALSE;

	//pSharedGlassData->m_nUserReviewNum = 0; //°øÀ¯ ¸Þ¸ð¸® User plan 

	_grmDefectData* pSharedDefect;
	int nPointCount = pRecipeinfo->GetRcpUserDefectInfoCount(); // User ÁÂÇ¥ ÃÑ Ä«¿îÆ®

	int nSharedDefectNum = pSharedGlassData->m_nDefectNum; // µðÆå ÃÑ°³¼ö User Idx ÀÇ Ã¹¹ø° Index °¡ µÈ´Ù
	int nStartIdx=nSharedDefectNum;// USER µðÆå Á¾·ù IDX ºÎ¿©Çϱâ À§ÇÑ ½ÃÀÛÁ¡ 

	CRcpPlanInfo* pRcpPlanInfo; // ·¹½ÃÇÇ Á¤º¸
	CRcpUserDefectInfo *pDefectInfo;// ·¹½ÃÇÇ defect Á¤º¸ 
	
	int nInsepectionType;// User ŸÀÔ Reviewreflow = 0 wsiReflow =1; REV&WSI =2; WSIUSEr =3; USER =4; 

	int nCount = 0;

	for(int nPlanIndex = 0; nPlanIndex < pRecipeinfo->GetRcpPlanInfoCount(); nPlanIndex++)
	{
		nInsepectionType= -1;

		pRcpPlanInfo = pRecipeinfo->GetRcpPlanInfo(nPlanIndex);
		if(pRcpPlanInfo == NULL)	continue;

		//=======================USERRVIEW & REFLOW & WSI Reflow & WSI User===========================================
		if(pRcpPlanInfo->m_nReviewType == CSOT_PlanUser || pRcpPlanInfo->m_nReviewType == CSOT_PlanReflow || pRcpPlanInfo->m_nReviewType == CSOT_PlanWsiUser ||pRcpPlanInfo->m_nReviewType == CSOT_PlanWsiReflow)
		{
			for (int nPointIdx=0; nPointIdx<nPointCount; nPointIdx++)
			{
				pDefectInfo = pRecipeinfo->GetRcpUserDefectInfo(nPointIdx);
				if (pDefectInfo==NULL) continue;

				pSharedDefect = pDitSharedGlassRaw->GetDefectData(nStartIdx);

				nInsepectionType =pDefectInfo->GetInspectionMode(); 
					
				if(CompareRevType(nInsepectionType,pRcpPlanInfo->m_nReviewType) )	
				{
					nCount++;
					
					if (pDefectInfo==NULL) continue;

					pSharedDefect->clear();
					pSharedDefect->m_nDefectIdx = nStartIdx;
					pSharedDefect->m_nUMOriginX = int(pDefectInfo->m_dPosX*1000.0);
					pSharedDefect->m_nUMOriginY = int(pDefectInfo->m_dPosY*1000.0);
					pSharedDefect->m_nUMCenterAlignX = pSharedDefect->m_nUMOriginX - pSharedGlassData->m_nGlassSizeWidth/2;
					pSharedDefect->m_nUMCenterAlignY = pSharedDefect->m_nUMOriginY - pSharedGlassData->m_nGlassSizeHeight/2;


					pSharedDefect->m_ReviewDefect.m_nReflow_Index = nPointIdx;
					pDefectInfo->m_nSharedDefectIndex = nStartIdx;

					if(pRcpPlanInfo->m_nReviewType==CSOT_PlanUser)pSharedDefect->m_ReviewDefect.m_nPlanType = ditRaw::RPT_User;
					else if(pRcpPlanInfo->m_nReviewType==CSOT_PlanReflow)pSharedDefect->m_ReviewDefect.m_nPlanType = ditRaw::RTP_Reflow;
					else if(pRcpPlanInfo->m_nReviewType==CSOT_PlanWsiUser)pSharedDefect->m_ReviewDefect.m_nPlanType = ditRaw::RTP_UserWsi;
					else pSharedDefect->m_ReviewDefect.m_nPlanType = ditRaw::RTP_WsiReflow;

					nStartIdx++;			
				}
			    else
				{
					continue;
			    }
			}
		}
	}
	
	//pSharedGlassData->m_nUserReviewNum = nCount;

	//m_pSP2P->ISP2P_DisplayMessage(_T("Fix Position Add Count : %d!!"), pSharedGlassData->m_nUserReviewNum);	
	
	return TRUE;
}

BOOL CSequenceProcessor_CSOT::CompareRevType(int nInsType,int nRevType)
{
	//Plan ŸÀÔ°ú InspectionMode ºñ±³ 
	if(nRevType ==CSOT_PlanUser)
	{
	  if(nInsType == USER) return TRUE;
	}
	else if (nRevType == CSOT_PlanReflow)
	{
		if(nInsType == REVIEW_REFLOW) return TRUE;
	}
	else if (nRevType ==CSOT_PlanWsiReflow)
	{
		if(nInsType == WSI_REFLOW) return TRUE;
	}
	else if(nRevType==CSOT_PlanWsiUser)
	{
		if(nInsType == WSIUSER) return TRUE;
	}
	else 
	{
		return FALSE;
	}
	return FALSE;
}

void CSequenceProcessor_CSOT::AllAckSignalOff()
{
	if(m_pSP2P == NULL)	return;

	m_pSP2P->ISP2P_DisplayMessage(_T("==========================Ack Signal All Off Start!!"));	
	for (int i = 0; i < PCControlRecv_ReviewAckSignalCount;i++)
	{
		RecvSignalToSignalControl(PCControlRecvSignalIndex_Ack,i,TRUE);
	}

	for (int i = 0; i < PCControlSendSignalAckCount;i++)
	{
		SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, i);
	}
	m_pSP2P->ISP2P_DisplayMessage(_T("==========================Ack Signal All Off End!!"));	


	SendSignalOffToSignalControl(PCControlSendSignalIndex_State,PCControlSend_RecipeASCEND); //190723 recipe ASCEND bit off 
}

void CSequenceProcessor_CSOT::WriteRawData(CGlassResult* pGlassResult)
{
	g_pLog->DisplayMessage(_T("[Process_ReviewEnd] Result FILE WRITE IN"));
	
	const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
	if (pNetworkInfo==NULL) return;

	CString strMessage, strResultFilePath, strUploadResultFilePath, strLocalRawPath;
	CString	strUploadRawPath, strUploadImagePath, strAOIRawFileName, strAOIRawFilePath;

	//3-1. ¸®ºä °á°ú ÆÄÀÏ ¾²±â
	m_pSP2P->ISP2P_SetReviewResultData(pGlassResult);

	strLocalRawPath		= pNetworkInfo->m_strLocalRawPath;
	strUploadRawPath	= pNetworkInfo->m_strUploadRawPath;
	strUploadImagePath	= pNetworkInfo->m_strUploadImagePath;
	strAOIRawFileName	= pGlassResult->m_strAOIRawFileName;
	strAOIRawFilePath	= pGlassResult->m_strAOIRawFilePath;

	if(strLocalRawPath.IsEmpty() == FALSE && strAOIRawFileName.IsEmpty() == FALSE)
	{
		// TD
		if (pGlassResult->m_strResultDate.GetLength()>0)
		{
			strResultFilePath.Format(_T("%s\\%s\\%s"), strLocalRawPath, pGlassResult->m_strResultDate, strAOIRawFileName); // here mch
		}
		else
		{
			strResultFilePath.Format(_T("%s\\%s"), strLocalRawPath, strAOIRawFileName); // here mch
		}

		if(m_pSP2P->ISP2P_WriteGlassResultToAOIRawFile(pGlassResult, strResultFilePath, RESULT_FILE_TD))
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[TD] %s Result File Write Success!"), strResultFilePath);//

			if(strUploadRawPath.IsEmpty() == FALSE && strAOIRawFilePath.IsEmpty() == FALSE)
			{
				// [2017:5:16]-[WEZASW] : ¸®ºä PASS½ÃÀÇ ¼³ºñ ¿î¿µÀÇ »óȲ¿¡ µû¶ó AOI Server°¡ RAW ÆÄÀÏ Á÷Á¢ ¾÷·Îµå ÁøÇà.
				strUploadResultFilePath.Format(_T("%s\\%s"), strUploadRawPath, strAOIRawFileName);

				if(CopyFile(strResultFilePath, strUploadResultFilePath, FALSE))
				{
					m_pSP2P->ISP2P_DisplayMessage(_T("[TD]Result File Upload Success![%s]"), strUploadResultFilePath);//
				}
				else
				{
					m_pSP2P->ISP2P_DisplayMessage(_T("[TD]Result File Upload Fail! Src[%s]"), strResultFilePath);//
					m_pSP2P->ISP2P_DisplayMessage(_T("[TD]Result File Upload Fail! Dst[%s]"), strUploadResultFilePath);
				}
			}
		}
		else
		{
			m_pSP2P->ISP2P_DisplayMessage(_T("[TD]%s Result File Write Fail!"), strResultFilePath);
		}
	}

	// delete file of Glass direction
	DeleteFile(pNetworkInfo->m_strAOIRawPath + _T("\\") + pGlassResult->m_strJobID + _T("TD"));//pGlassResult->m_strGlassID -> m_StrJobID º¯°æ

	// [2017:4:11]-[WEZASW] :CIM(DV Data) º¸°í Ç׸ñ Ãß°¡.
	if (SendDVDataToSignalControl()==FALSE) 
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewEnd] DV Data Send FAIL!"));			
	}
	else
	{
		m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewEnd] DV Data Send Success!"));			
	}
}

BOOL CSequenceProcessor_CSOT::SendReviewStartMotorPosition( int nModuleIndex,double dPosX,double dPosY,int nMoveAxis )
{

	return m_pSP2P->ISP2P_Motor_CameraGo(nModuleIndex,dPosX,dPosY,nMoveAxis);
	
}

BOOL CSequenceProcessor_CSOT::MoveReviewStartMotorPosition(CGlassResult* pGlassResult,int nReviewType)
{
	//Ȥ½Ã³ª ¾²ÀϱîºÁ ³²°Üµã 
	//´ÙÀ½ Ç÷£ÀÇ Ã¹¹ø° À§Ä¡·Î À̵¿
	
	double dDefectPosX,dDefectPosY = 0;
	
	if(nReviewType == CSOT_PlanReview){
		CReviewResult*  pReviewResult	 = pGlassResult->GetReviewResult(0);
		if(pReviewResult==NULL) return FALSE;

		int nStartIdx = pReviewResult->GetStartSReviewResultIndex();
	
		SReviewResult* pRev = pReviewResult->GetSReviewResult(nStartIdx);
	
		if (pRev==NULL) return FALSE;

		dDefectPosX = double(pRev->nUMOriginX) / 1000.0;
		dDefectPosY = double(pRev->nUMOriginY) / 1000.0;

	}
	else if(nReviewType == CSOT_PlanUser){

		CReviewResult*  pReviewResult	 = pGlassResult->GetUserResult(0);
		if(pReviewResult==NULL) return FALSE;

		int nStartIdx = pReviewResult->GetStartSReviewResultIndex();

		SReviewResult* pRev = pReviewResult->GetSReviewResult(nStartIdx);
		if (pRev==NULL) return FALSE;

		dDefectPosX = double(pRev->nUMOriginX) / 1000.0;
		dDefectPosY = double(pRev->nUMOriginY) / 1000.0;

	}
	else if(nReviewType ==CSOT_PlanMeasure)
	{
		CReviewResult*  pReviewResult	 = pGlassResult->GetMeasureResult(0);
		if(pReviewResult==NULL) return FALSE;

		int nStartIdx = pReviewResult->GetStartSReviewResultIndex();

		SReviewResult* pRev = pReviewResult->GetSReviewResult(nStartIdx);
		if (pRev==NULL) return FALSE;

		dDefectPosX = double(pRev->nUMOriginX) / 1000.0;
		dDefectPosY = double(pRev->nUMOriginY) / 1000.0;
	}
	else if(nReviewType ==CSOT_PlanReflow)
	{
		CReviewResult*  pReviewResult	 = pGlassResult->GetReflowResult(0);
		if(pReviewResult==NULL) return FALSE;

		int nStartIdx = pReviewResult->GetStartSReviewResultIndex();

		SReviewResult* pRev = pReviewResult->GetSReviewResult(nStartIdx);
		if (pRev==NULL) return FALSE;

		dDefectPosX = double(pRev->nUMOriginX) / 1000.0;
		dDefectPosY = double(pRev->nUMOriginY) / 1000.0;
	}

	return SendReviewStartMotorPosition(0,dDefectPosX+1,dDefectPosY+1,0); 
}

void CSequenceProcessor_CSOT::SendWsiErrorAlarm_CSOT(int Index) //190801 ÃÖÇü¸ñ
{	
	//wsi ¿¡·¯ ¾Ë¶÷
	if(Index==1)
	{
		g_pLog->DisplayMessage(_T("[SequenceProcessor_CSOT] WSI Alive Error!!!"));
	}
	else 
	{
		g_pLog->DisplayMessage(_T("[SequenceProcessor_CSOT] WSI Error!!!"));
	}
	SendSignalToSignalControl(PCControlSendSignalIndex_State,PCControlSend_WSIError,1000);
}

void CSequenceProcessor_CSOT::SendWsiAlive_CSOT()//190801 ÃÖÇü¸ñ
{
	//WSI Alive ½ÅÈ£ ¹ÞÀ½
	SetWSIAliveCheck(TRUE);
}

void CSequenceProcessor_CSOT::WSIAliveCheckRunThread_CSOT() //190801 ÃÖÇü¸ñ
{
	CWinThread *pThread =NULL;
	pThread = AfxBeginThread(WsiAliveCheckThread,this);

}

UINT CSequenceProcessor_CSOT::WsiAliveCheckThread( LPVOID pParam )//190801 ÃÖÇü¸ñ
{
	DWORD dwTick = GetTickCount();
	
	CSequenceProcessor_CSOT * m_pCSPC =(CSequenceProcessor_CSOT*) pParam;
		
	while(1)
	{
		if(GetTickCount()-dwTick >=30000)
		{
			dwTick = GetTickCount();

			if(bWsiAliveCheck ==FALSE){
				m_pCSPC->SendWsiErrorAlarm_CSOT(1);
			}
			bWsiAliveCheck=FALSE; //30ÃÊ¿¡ Çѹø¾¿ 0À¸·Î ÃʱâÈ­

		}
	}
	return 1;
}

BOOL CSequenceProcessor_CSOT:: bWsiAliveCheck;